2.1.0 (#123)

# Patchnotes 2.1.0
The changes in this update are more than just "patches". With a new UI, a new feature, and a bunch of bug fixes, improvements and a new member on the dev team, we thought this was more of a minor update.

We would like to introduce @tsubasahane of MareCN to the team! We’re happy to work with them to bring Lightless and its features to the CN client as well as having another talented dev bring features and ideas to us. Speaking of which:

# Location Sharing (Big shout out to @tsubasahane for bringing this feature)

- Are you TIRED of scrambling to find the address of the venue you're in to share with your friends? We are introducing Location Sharing! An optional feature where you can share your location with direct pairs temporarily [30 minutes, 1 hour, 3 hours] minutes or until you turn it off for them. That's up to you! [#125](<#125>)  [#49](<Lightless-Sync/LightlessServer#49>)
- To share your location with a pair, click the three dots beside the pair and choose a duration to share with them. [#125](<#125>)  [#49](<Lightless-Sync/LightlessServer#49>)
- To view the location of someone who's shared with you, simply hover over the globe icon! [#125](<#125>)  [#49](<Lightless-Sync/LightlessServer#49>)

[1]

# Model Optimization (Mesh Decimating)
 - This new option can automatically “simplify” incoming character meshes to help performance by reducing triangle counts. You choose how strong the reduction is (default/recommended is 80%). [#131](<#131>)
 - Decimation only kicks in when a mesh is above a certain triangle threshold, and only for the items that qualify for it and you selected for. [#131](<#131>)
 - Hair meshes is always excluded, since simplifying hair meshes is very prone to breaking.
 - You can find everything under Settings → Performance → Model Optimization. [#131](<#131>)
+ ** IF YOU HAVE USED DECIMATION IN TESTING, PLEASE CLEAR YOUR CACHE ❗ **

[2]

# Animation (PAP) Validation (Safer animations)
 - Lightless now checks your currently animations to see if they work with your local skeleton/bone mod. If an animation matches, it’s included in what gets sent to other players. If it doesn’t, Lightless will skip it and write a warning to your log showing how many were skipped due to skeleton changes. Its defaulted to Unsafe (off). turn it on if you experience crashes from others users. [#131](<#131>)
 - Lightless also does the same kind of check for incoming animation files, to make sure they match the body/skeleton they were sent with. [#131](<#131>)
 - Because these checks can sometimes be a little picky, you can adjust how strict they are in Settings -> General -> Animation & Bones to reduce false positives. [#131](<#131>)

# UI Changes (Thanks to @kyuwu for UI Changes)
- The top part of the main screen has gotten a makeover. You can adjust the colors of the gradiant in the Color settings of Lightless. [#127](<#127>)

[3]

- Settings have gotten some changes as well to make this change more universal, and will use the same color settings. [#127](<#127>)
- The particle effects of the gradient are toggleable in 'Settings -> UI -> Behavior' [#127](<#127>)
- Instead of showing download/upload on bottom of Main UI, it will show VRAM usage and triangles with their optimization options next to it [#138](<#138>)

# LightFinder / ShellFinder
- UI Changes that follow our new design follow the color codes for the Gradient top as the main screen does.  [#127](<#127>)

[4]

Co-authored-by: defnotken <itsdefnotken@gmail.com>
Co-authored-by: azyges <aaaaaa@aaa.aaa>
Co-authored-by: cake <admin@cakeandbanana.nl>
Co-authored-by: Tsubasa <tsubasa@noreply.git.lightless-sync.org>
Co-authored-by: choco <choco@patat.nl>
Co-authored-by: celine <aaa@aaa.aaa>
Co-authored-by: celine <celine@noreply.git.lightless-sync.org>
Co-authored-by: Tsubasahane <wozaiha@gmail.com>
Co-authored-by: cake <cake@noreply.git.lightless-sync.org>
Reviewed-on: #123

LightlessSync/Interop/BlockedCharacterHandler.cs

@@ -1,4 +1,5 @@
 using Dalamud.Plugin.Services;
+using Dalamud.Game.ClientState.Objects.SubKinds;
 using FFXIVClientStructs.FFXIV.Client.Game.Character;
 using FFXIVClientStructs.FFXIV.Client.UI.Info;
 using Microsoft.Extensions.Logging;
@@ -11,24 +12,35 @@ public unsafe class BlockedCharacterHandler
     private readonly Dictionary<CharaData, bool> _blockedCharacterCache = new();
 
     private readonly ILogger<BlockedCharacterHandler> _logger;
+    private readonly IObjectTable _objectTable;
 
-    public BlockedCharacterHandler(ILogger<BlockedCharacterHandler> logger, IGameInteropProvider gameInteropProvider)
+    public BlockedCharacterHandler(ILogger<BlockedCharacterHandler> logger, IGameInteropProvider gameInteropProvider, IObjectTable objectTable)
     {
         gameInteropProvider.InitializeFromAttributes(this);
         _logger = logger;
+        _objectTable = objectTable;
     }
 
-    private static CharaData GetIdsFromPlayerPointer(nint ptr)
+    private CharaData? TryGetIdsFromPlayerPointer(nint ptr, ushort objectIndex)
     {
-        if (ptr == nint.Zero) return new(0, 0);
-        var castChar = ((BattleChara*)ptr);
+        if (ptr == nint.Zero || objectIndex >= 200)
+            return null;
+
+        var obj = _objectTable[objectIndex];
+        if (obj is not IPlayerCharacter player || player.Address != ptr)
+            return null;
+
+        var castChar = (BattleChara*)player.Address;
         return new(castChar->Character.AccountId, castChar->Character.ContentId);
     }
 
-    public bool IsCharacterBlocked(nint ptr, out bool firstTime)
+    public bool IsCharacterBlocked(nint ptr, ushort objectIndex, out bool firstTime)
     {
         firstTime = false;
-        var combined = GetIdsFromPlayerPointer(ptr);
+        var combined = TryGetIdsFromPlayerPointer(ptr, objectIndex);
+        if (combined == null)
+            return false;
+
         if (_blockedCharacterCache.TryGetValue(combined, out var isBlocked))
             return isBlocked;
 

LightlessSync/Interop/InteropModel/Enums/ResidentialAetheryteKind.cs

@@ -0,0 +1,11 @@
+namespace Lifestream.Enums;
+
+public enum ResidentialAetheryteKind
+{
+    None = -1,
+    Uldah = 9,
+    Gridania = 2,
+    Limsa = 8,
+    Foundation = 70,
+    Kugane = 111,
+}

LightlessSync/Interop/InteropModel/Enums/TerritoryTypeIdHousing.cs

@@ -0,0 +1,51 @@
+namespace Lifestream.Enums;
+
+public enum TerritoryTypeIdHousing
+{
+    None = -1,
+    
+    // Mist (Limsa Lominsa)
+    Mist = 339,
+    MistSmall = 282,
+    MistMedium = 283,
+    MistLarge = 284,
+    MistFCRoom = 384,
+    MistFCWorkshop = 423,
+    MistApartment = 608,
+    
+    // Lavender Beds (Gridania)
+    Lavender = 340,
+    LavenderSmall = 342,
+    LavenderMedium = 343,
+    LavenderLarge = 344,
+    LavenderFCRoom = 385,
+    LavenderFCWorkshop = 425,
+    LavenderApartment = 609,
+    
+    // Goblet (Ul'dah)
+    Goblet = 341,
+    GobletSmall = 345,
+    GobletMedium = 346,
+    GobletLarge = 347,
+    GobletFCRoom = 386,
+    GobletFCWorkshop = 424,
+    GobletApartment = 610,
+    
+    // Shirogane (Kugane)
+    Shirogane = 641,
+    ShiroganeSmall = 649,
+    ShiroganeMedium = 650,
+    ShiroganeLarge = 651,
+    ShiroganeFCRoom = 652,
+    ShiroganeFCWorkshop = 653,
+    ShiroganeApartment = 655,
+    
+    // Empyreum (Ishgard)
+    Empyream = 979,
+    EmpyreamSmall = 980,
+    EmpyreamMedium = 981,
+    EmpyreamLarge = 982,
+    EmpyreamFCRoom = 983,
+    EmpyreamFCWorkshop = 984,
+    EmpyreamApartment = 999,
+}

LightlessSync/Interop/InteropModel/GlobalModels.cs

@@ -0,0 +1 @@
+global using AddressBookEntryTuple = (string Name, int World, int City, int Ward, int PropertyType, int Plot, int Apartment, bool ApartmentSubdivision, bool AliasEnabled, string Alias);

LightlessSync/Interop/Ipc/IpcCallerLifestream.cs

@@ -0,0 +1,129 @@
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using Lifestream.Enums;
+using LightlessSync.Interop.Ipc.Framework;
+using LightlessSync.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+
+namespace LightlessSync.Interop.Ipc;
+
+public sealed class IpcCallerLifestream : IpcServiceBase
+{
+    private static readonly IpcServiceDescriptor LifestreamDescriptor = new("Lifestream", "Lifestream", new Version(0, 0, 0, 0));
+
+    private readonly ICallGateSubscriber<string, object> _executeLifestreamCommand;
+    private readonly ICallGateSubscriber<AddressBookEntryTuple, bool> _isHere;
+    private readonly ICallGateSubscriber<AddressBookEntryTuple, object> _goToHousingAddress;
+    private readonly ICallGateSubscriber<bool> _isBusy;
+    private readonly ICallGateSubscriber<object> _abort;
+    private readonly ICallGateSubscriber<string, bool> _changeWorld;
+    private readonly ICallGateSubscriber<uint, bool> _changeWorldById;
+    private readonly ICallGateSubscriber<string, bool> _aetheryteTeleport;
+    private readonly ICallGateSubscriber<uint, bool> _aetheryteTeleportById;
+    private readonly ICallGateSubscriber<bool> _canChangeInstance;
+    private readonly ICallGateSubscriber<int> _getCurrentInstance;
+    private readonly ICallGateSubscriber<int> _getNumberOfInstances;
+    private readonly ICallGateSubscriber<int, object> _changeInstance;
+    private readonly ICallGateSubscriber<(ResidentialAetheryteKind, int, int)> _getCurrentPlotInfo;
+
+    public IpcCallerLifestream(IDalamudPluginInterface pi, LightlessMediator lightlessMediator, ILogger<IpcCallerLifestream> logger)
+        : base(logger, lightlessMediator, pi, LifestreamDescriptor)
+    {
+        _executeLifestreamCommand = pi.GetIpcSubscriber<string, object>("Lifestream.ExecuteCommand");
+        _isHere = pi.GetIpcSubscriber<AddressBookEntryTuple, bool>("Lifestream.IsHere");
+        _goToHousingAddress = pi.GetIpcSubscriber<AddressBookEntryTuple, object>("Lifestream.GoToHousingAddress");
+        _isBusy = pi.GetIpcSubscriber<bool>("Lifestream.IsBusy");
+        _abort = pi.GetIpcSubscriber<object>("Lifestream.Abort");
+        _changeWorld = pi.GetIpcSubscriber<string, bool>("Lifestream.ChangeWorld");
+        _changeWorldById = pi.GetIpcSubscriber<uint, bool>("Lifestream.ChangeWorldById");
+        _aetheryteTeleport = pi.GetIpcSubscriber<string, bool>("Lifestream.AetheryteTeleport");
+        _aetheryteTeleportById = pi.GetIpcSubscriber<uint, bool>("Lifestream.AetheryteTeleportById");
+        _canChangeInstance = pi.GetIpcSubscriber<bool>("Lifestream.CanChangeInstance");
+        _getCurrentInstance = pi.GetIpcSubscriber<int>("Lifestream.GetCurrentInstance");
+        _getNumberOfInstances = pi.GetIpcSubscriber<int>("Lifestream.GetNumberOfInstances");
+        _changeInstance = pi.GetIpcSubscriber<int, object>("Lifestream.ChangeInstance");
+        _getCurrentPlotInfo = pi.GetIpcSubscriber<(ResidentialAetheryteKind, int, int)>("Lifestream.GetCurrentPlotInfo");
+        CheckAPI();
+    }
+
+    public void ExecuteLifestreamCommand(string command)
+    {
+        if (!APIAvailable) return;
+        _executeLifestreamCommand.InvokeAction(command);
+    }
+
+    public bool IsHere(AddressBookEntryTuple entry)
+    {
+        if (!APIAvailable) return false;
+        return _isHere.InvokeFunc(entry);
+    }
+
+    public void GoToHousingAddress(AddressBookEntryTuple entry)
+    {
+        if (!APIAvailable) return;
+        _goToHousingAddress.InvokeAction(entry);
+    }
+
+    public bool IsBusy()
+    {
+        if (!APIAvailable) return false;
+        return _isBusy.InvokeFunc();
+    }
+
+    public void Abort()
+    {
+        if (!APIAvailable) return;
+        _abort.InvokeAction();
+    }
+
+    public bool ChangeWorld(string worldName)
+    {
+        if (!APIAvailable) return false;
+        return _changeWorld.InvokeFunc(worldName);
+    }
+
+    public bool AetheryteTeleport(string aetheryteName)
+    {
+        if (!APIAvailable) return false;
+        return _aetheryteTeleport.InvokeFunc(aetheryteName);
+    }
+
+    public bool ChangeWorldById(uint worldId)
+    {
+        if (!APIAvailable) return false;
+        return _changeWorldById.InvokeFunc(worldId);
+    }
+
+    public bool AetheryteTeleportById(uint aetheryteId)
+    {
+        if (!APIAvailable) return false;
+        return _aetheryteTeleportById.InvokeFunc(aetheryteId);
+    }
+
+    public bool CanChangeInstance()
+    {
+        if (!APIAvailable) return false;
+        return _canChangeInstance.InvokeFunc();
+    }
+    public int GetCurrentInstance()
+    {
+        if (!APIAvailable) return -1;
+        return _getCurrentInstance.InvokeFunc();
+    }
+    public int GetNumberOfInstances()
+    {
+        if (!APIAvailable) return -1;
+        return _getNumberOfInstances.InvokeFunc();
+    }
+    public void ChangeInstance(int instanceNumber)
+    {
+        if (!APIAvailable) return;
+        _changeInstance.InvokeAction(instanceNumber);
+    }
+    public (ResidentialAetheryteKind, int, int)? GetCurrentPlotInfo()
+    {
+        if (!APIAvailable) return (ResidentialAetheryteKind.None, -1, -1);
+        return _getCurrentPlotInfo.InvokeFunc();
+    }
+}

LightlessSync/Interop/Ipc/IpcCallerPenumbra.cs

@@ -4,7 +4,6 @@ using LightlessSync.Interop.Ipc.Penumbra;
 using LightlessSync.LightlessConfiguration.Models;
 using LightlessSync.PlayerData.Handlers;
 using LightlessSync.Services;
-using LightlessSync.Services.ActorTracking;
 using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
 using Penumbra.Api.Enums;
@@ -36,8 +35,7 @@ public sealed class IpcCallerPenumbra : IpcServiceBase
         IDalamudPluginInterface pluginInterface,
         DalamudUtilService dalamudUtil,
         LightlessMediator mediator,
-        RedrawManager redrawManager,
-        ActorObjectService actorObjectService) : base(logger, mediator, pluginInterface, PenumbraDescriptor)
+        RedrawManager redrawManager) : base(logger, mediator, pluginInterface, PenumbraDescriptor)
     {
         _penumbraEnabled = new GetEnabledState(pluginInterface);
         _penumbraGetModDirectory = new GetModDirectory(pluginInterface);
@@ -46,7 +44,7 @@ public sealed class IpcCallerPenumbra : IpcServiceBase
         _penumbraModSettingChanged = ModSettingChanged.Subscriber(pluginInterface, HandlePenumbraModSettingChanged);
 
         _collections = RegisterInterop(new PenumbraCollections(logger, pluginInterface, dalamudUtil, mediator));
-        _resources = RegisterInterop(new PenumbraResource(logger, pluginInterface, dalamudUtil, mediator, actorObjectService));
+        _resources = RegisterInterop(new PenumbraResource(logger, pluginInterface, dalamudUtil, mediator));
         _redraw = RegisterInterop(new PenumbraRedraw(logger, pluginInterface, dalamudUtil, mediator, redrawManager));
         _textures = RegisterInterop(new PenumbraTexture(logger, pluginInterface, dalamudUtil, mediator, _redraw));
 
@@ -104,8 +102,11 @@ public sealed class IpcCallerPenumbra : IpcServiceBase
     public Task RedrawAsync(ILogger logger, GameObjectHandler handler, Guid applicationId, CancellationToken token)
         => _redraw.RedrawAsync(logger, handler, applicationId, token);
 
-    public Task ConvertTextureFiles(ILogger logger, IReadOnlyList<TextureConversionJob> jobs, IProgress<TextureConversionProgress>? progress, CancellationToken token)
-        => _textures.ConvertTextureFilesAsync(logger, jobs, progress, token);
+    public void RequestImmediateRedraw(int objectIndex, RedrawType redrawType)
+        => _redraw.RequestImmediateRedraw(objectIndex, redrawType);
+
+    public Task ConvertTextureFiles(ILogger logger, IReadOnlyList<TextureConversionJob> jobs, IProgress<TextureConversionProgress>? progress, CancellationToken token, bool requestRedraw = true)
+        => _textures.ConvertTextureFilesAsync(logger, jobs, progress, token, requestRedraw);
 
     public Task ConvertTextureFileDirectAsync(TextureConversionJob job, CancellationToken token)
         => _textures.ConvertTextureFileDirectAsync(job, token);

LightlessSync/Interop/Ipc/IpcManager.cs

@@ -5,9 +5,12 @@ namespace LightlessSync.Interop.Ipc;
 
 public sealed partial class IpcManager : DisposableMediatorSubscriberBase
 {
+    private bool _wasInitialized;
+
     public IpcManager(ILogger<IpcManager> logger, LightlessMediator mediator,
         IpcCallerPenumbra penumbraIpc, IpcCallerGlamourer glamourerIpc, IpcCallerCustomize customizeIpc, IpcCallerHeels heelsIpc,
-        IpcCallerHonorific honorificIpc, IpcCallerMoodles moodlesIpc, IpcCallerPetNames ipcCallerPetNames, IpcCallerBrio ipcCallerBrio) : base(logger, mediator)
+        IpcCallerHonorific honorificIpc, IpcCallerMoodles moodlesIpc, IpcCallerPetNames ipcCallerPetNames, IpcCallerBrio ipcCallerBrio,
+        IpcCallerLifestream ipcCallerLifestream) : base(logger, mediator)
     {
         CustomizePlus = customizeIpc;
         Heels = heelsIpc;
@@ -17,8 +20,10 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
         Moodles = moodlesIpc;
         PetNames = ipcCallerPetNames;
         Brio = ipcCallerBrio;
+        Lifestream = ipcCallerLifestream;
 
-        if (Initialized)
+        _wasInitialized = Initialized;
+        if (_wasInitialized)
         {
             Mediator.Publish(new PenumbraInitializedMessage());
         }
@@ -44,8 +49,8 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
     public IpcCallerPenumbra Penumbra { get; }
     public IpcCallerMoodles Moodles { get; }
     public IpcCallerPetNames PetNames { get; }
-
     public IpcCallerBrio Brio { get; }
+    public IpcCallerLifestream Lifestream { get; }
 
     private void PeriodicApiStateCheck()
     {
@@ -58,5 +63,14 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
         Moodles.CheckAPI();
         PetNames.CheckAPI();
         Brio.CheckAPI();
+
+        var initialized = Initialized;
+        if (initialized && !_wasInitialized)
+        {
+            Mediator.Publish(new PenumbraInitializedMessage());
+        }
+
+        _wasInitialized = initialized;
+        Lifestream.CheckAPI();
     }
 }

LightlessSync/Interop/Ipc/Penumbra/PenumbraCollections.cs

@@ -1,10 +1,8 @@
-using System.Collections.Concurrent;
 using Dalamud.Plugin;
 using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.Services;
 using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
-using Penumbra.Api.Enums;
 using Penumbra.Api.IpcSubscribers;
 
 namespace LightlessSync.Interop.Ipc.Penumbra;
@@ -16,10 +14,6 @@ public sealed class PenumbraCollections : PenumbraBase
     private readonly DeleteTemporaryCollection _removeTemporaryCollection;
     private readonly AddTemporaryMod _addTemporaryMod;
     private readonly RemoveTemporaryMod _removeTemporaryMod;
-    private readonly GetCollections _getCollections;
-    private readonly ConcurrentDictionary<Guid, string> _activeTemporaryCollections = new();
-
-    private int _cleanupScheduled;
 
     public PenumbraCollections(
         ILogger logger,
@@ -32,7 +26,6 @@ public sealed class PenumbraCollections : PenumbraBase
         _removeTemporaryCollection = new DeleteTemporaryCollection(pluginInterface);
         _addTemporaryMod = new AddTemporaryMod(pluginInterface);
         _removeTemporaryMod = new RemoveTemporaryMod(pluginInterface);
-        _getCollections = new GetCollections(pluginInterface);
     }
 
     public override string Name => "Penumbra.Collections";
@@ -62,16 +55,11 @@ public sealed class PenumbraCollections : PenumbraBase
         var (collectionId, collectionName) = await DalamudUtil.RunOnFrameworkThread(() =>
         {
             var name = $"Lightless_{uid}";
-            _createNamedTemporaryCollection.Invoke(name, name, out var tempCollectionId);
-            logger.LogTrace("Creating Temp Collection {CollectionName}, GUID: {CollectionId}", name, tempCollectionId);
+            var createResult = _createNamedTemporaryCollection.Invoke(name, name, out var tempCollectionId);
+            logger.LogTrace("Creating Temp Collection {CollectionName}, GUID: {CollectionId}, Result: {Result}", name, tempCollectionId, createResult);
             return (tempCollectionId, name);
         }).ConfigureAwait(false);
 
-        if (collectionId != Guid.Empty)
-        {
-            _activeTemporaryCollections[collectionId] = collectionName;
-        }
-
         return collectionId;
     }
 
@@ -89,7 +77,6 @@ public sealed class PenumbraCollections : PenumbraBase
             logger.LogTrace("[{ApplicationId}] RemoveTemporaryCollection: {Result}", applicationId, result);
         }).ConfigureAwait(false);
 
-        _activeTemporaryCollections.TryRemove(collectionId, out _);
     }
 
     public async Task SetTemporaryModsAsync(ILogger logger, Guid applicationId, Guid collectionId, Dictionary<string, string> modPaths)
@@ -131,67 +118,5 @@ public sealed class PenumbraCollections : PenumbraBase
 
     protected override void HandleStateChange(IpcConnectionState previous, IpcConnectionState current)
     {
-        if (current == IpcConnectionState.Available)
-        {
-            ScheduleCleanup();
-        }
-        else if (previous == IpcConnectionState.Available && current != IpcConnectionState.Available)
-        {
-            Interlocked.Exchange(ref _cleanupScheduled, 0);
-        }
     }
-
-    private void ScheduleCleanup()
-    {
-        if (Interlocked.Exchange(ref _cleanupScheduled, 1) != 0)
-        {
-            return;
-        }
-
-        _ = Task.Run(CleanupTemporaryCollectionsAsync);
-    }
-
-    private async Task CleanupTemporaryCollectionsAsync()
-    {
-        if (!IsAvailable)
-        {
-            return;
-        }
-
-        try
-        {
-            var collections = await DalamudUtil.RunOnFrameworkThread(() => _getCollections.Invoke()).ConfigureAwait(false);
-            foreach (var (collectionId, name) in collections)
-            {
-                if (!IsLightlessCollectionName(name) || _activeTemporaryCollections.ContainsKey(collectionId))
-                {
-                    continue;
-                }
-
-                Logger.LogDebug("Cleaning up stale temporary collection {CollectionName} ({CollectionId})", name, collectionId);
-                var deleteResult = await DalamudUtil.RunOnFrameworkThread(() =>
-                {
-                    var result = (PenumbraApiEc)_removeTemporaryCollection.Invoke(collectionId);
-                    Logger.LogTrace("Cleanup RemoveTemporaryCollection result for {CollectionName} ({CollectionId}): {Result}", name, collectionId, result);
-                    return result;
-                }).ConfigureAwait(false);
-
-                if (deleteResult == PenumbraApiEc.Success)
-                {
-                    _activeTemporaryCollections.TryRemove(collectionId, out _);
-                }
-                else
-                {
-                    Logger.LogDebug("Skipped removing temporary collection {CollectionName} ({CollectionId}). Result: {Result}", name, collectionId, deleteResult);
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            Logger.LogWarning(ex, "Failed to clean up Penumbra temporary collections");
-        }
-    }
-
-    private static bool IsLightlessCollectionName(string? name)
-        => !string.IsNullOrEmpty(name) && name.StartsWith("Lightless_", StringComparison.Ordinal);
 }

LightlessSync/Interop/Ipc/Penumbra/PenumbraResource.cs

@@ -2,9 +2,10 @@ using Dalamud.Plugin;
 using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.PlayerData.Handlers;
 using LightlessSync.Services;
-using LightlessSync.Services.ActorTracking;
 using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
+using System.Diagnostics;
+using System.Globalization;
 using Penumbra.Api.Helpers;
 using Penumbra.Api.IpcSubscribers;
 
@@ -12,7 +13,6 @@ namespace LightlessSync.Interop.Ipc.Penumbra;
 
 public sealed class PenumbraResource : PenumbraBase
 {
-    private readonly ActorObjectService _actorObjectService;
     private readonly GetGameObjectResourcePaths _gameObjectResourcePaths;
     private readonly ResolveGameObjectPath _resolveGameObjectPath;
     private readonly ReverseResolveGameObjectPath _reverseResolveGameObjectPath;
@@ -24,10 +24,8 @@ public sealed class PenumbraResource : PenumbraBase
         ILogger logger,
         IDalamudPluginInterface pluginInterface,
         DalamudUtilService dalamudUtil,
-        LightlessMediator mediator,
-        ActorObjectService actorObjectService) : base(logger, pluginInterface, dalamudUtil, mediator)
+        LightlessMediator mediator) : base(logger, pluginInterface, dalamudUtil, mediator)
     {
-        _actorObjectService = actorObjectService;
         _gameObjectResourcePaths = new GetGameObjectResourcePaths(pluginInterface);
         _resolveGameObjectPath = new ResolveGameObjectPath(pluginInterface);
         _reverseResolveGameObjectPath = new ReverseResolveGameObjectPath(pluginInterface);
@@ -45,17 +43,33 @@ public sealed class PenumbraResource : PenumbraBase
             return null;
         }
 
-        return await DalamudUtil.RunOnFrameworkThread(() =>
+        var requestId = Guid.NewGuid();
+        var totalTimer = Stopwatch.StartNew();
+        logger.LogTrace("[{requestId}] Requesting Penumbra.GetGameObjectResourcePaths for {handler}", requestId, handler);
+
+        var result = await DalamudUtil.RunOnFrameworkThread(() =>
         {
-            logger.LogTrace("Calling On IPC: Penumbra.GetGameObjectResourcePaths");
             var idx = handler.GetGameObject()?.ObjectIndex;
             if (idx == null)
             {
+                logger.LogTrace("[{requestId}] GetGameObjectResourcePaths aborted (missing object index) for {handler}", requestId, handler);
                 return null;
             }
 
-            return _gameObjectResourcePaths.Invoke(idx.Value)[0];
+            logger.LogTrace("[{requestId}] Invoking Penumbra.GetGameObjectResourcePaths for index {index}", requestId, idx.Value);
+            var invokeTimer = Stopwatch.StartNew();
+            var data = _gameObjectResourcePaths.Invoke(idx.Value)[0];
+            invokeTimer.Stop();
+            logger.LogTrace("[{requestId}] Penumbra.GetGameObjectResourcePaths returned {count} entries in {elapsedMs}ms",
+                requestId, data?.Count ?? 0, invokeTimer.ElapsedMilliseconds);
+            return data;
         }).ConfigureAwait(false);
+
+        totalTimer.Stop();
+        logger.LogTrace("[{requestId}] Penumbra.GetGameObjectResourcePaths finished in {elapsedMs}ms (null: {isNull})",
+            requestId, totalTimer.ElapsedMilliseconds, result is null);
+
+        return result;
     }
 
     public string GetMetaManipulations()
@@ -79,22 +93,10 @@ public sealed class PenumbraResource : PenumbraBase
 
     private void HandleResourceLoaded(nint ptr, string gamePath, string resolvedPath)
     {
-        if (ptr == nint.Zero)
+        if (ptr != nint.Zero && string.Compare(gamePath, resolvedPath, ignoreCase: true, CultureInfo.InvariantCulture) != 0)
         {
-            return;
+            Mediator.Publish(new PenumbraResourceLoadMessage(ptr, gamePath, resolvedPath));
         }
-
-        if (!_actorObjectService.TryGetOwnedKind(ptr, out _))
-        {
-            return;
-        }
-
-        if (string.Compare(gamePath, resolvedPath, StringComparison.OrdinalIgnoreCase) == 0)
-        {
-            return;
-        }
-
-        Mediator.Publish(new PenumbraResourceLoadMessage(ptr, gamePath, resolvedPath));
     }
 
     protected override void HandleStateChange(IpcConnectionState previous, IpcConnectionState current)

LightlessSync/Interop/Ipc/Penumbra/PenumbraTexture.cs

@@ -26,7 +26,7 @@ public sealed class PenumbraTexture : PenumbraBase
 
     public override string Name => "Penumbra.Textures";
 
-    public async Task ConvertTextureFilesAsync(ILogger logger, IReadOnlyList<TextureConversionJob> jobs, IProgress<TextureConversionProgress>? progress, CancellationToken token)
+    public async Task ConvertTextureFilesAsync(ILogger logger, IReadOnlyList<TextureConversionJob> jobs, IProgress<TextureConversionProgress>? progress, CancellationToken token, bool requestRedraw)
     {
         if (!IsAvailable || jobs.Count == 0)
         {
@@ -57,7 +57,7 @@ public sealed class PenumbraTexture : PenumbraBase
             Mediator.Publish(new ResumeScanMessage(nameof(ConvertTextureFilesAsync)));
         }
 
-        if (completedJobs > 0 && !token.IsCancellationRequested)
+        if (requestRedraw && completedJobs > 0 && !token.IsCancellationRequested)
         {
             await DalamudUtil.RunOnFrameworkThread(async () =>
             {
@@ -92,7 +92,7 @@ public sealed class PenumbraTexture : PenumbraBase
     {
         token.ThrowIfCancellationRequested();
 
-        logger.LogInformation("Converting texture {Input} -> {Output} ({Target})", job.InputFile, job.OutputFile, job.TargetType);
+        logger.LogDebug("Converting texture {Input} -> {Output} ({Target})", job.InputFile, job.OutputFile, job.TargetType);
         var convertTask = _convertTextureFile.Invoke(job.InputFile, job.OutputFile, job.TargetType, job.IncludeMipMaps);
         await convertTask.ConfigureAwait(false);