Add MCDO (#80)

* update api * mcd online editor impl * most of chara data hub impl * some state of things * some refactoring * random bullshit go * more nearby impl * add uid to peformance msg * cleanup/homogenization * some split, update nuget packages * migrate to latest packages where possible, remove lz4net, do some split, idk * some polish and cleanup * more cleanup, beautification, etc. * fixes and cleanups --------- Co-authored-by: Stanley Dimant <root.darkarchon@outlook.com>
2025-01-11 22:43:11 +01:00
parent ad42b29a44
commit 30caedbf3a
44 changed files with 5128 additions and 486 deletions
--- a/MareSynchronos/Interop/BlockedCharacterHandler.cs
+++ b/MareSynchronos/Interop/BlockedCharacterHandler.cs
@@ -35,7 +35,7 @@ public unsafe class BlockedCharacterHandler
        firstTime = true;
        var blockStatus = InfoProxyBlacklist.Instance()->GetBlockResultType(combined.AccId, combined.ContentId);
        _logger.LogTrace("CharaPtr {ptr} is BlockStatus: {status}", ptr, blockStatus);
-        if ((int)blockStatus == 0) 
+        if ((int)blockStatus == 0)
            return false;
        return _blockedCharacterCache[combined] = blockStatus != InfoProxyBlacklist.BlockResultType.NotBlocked;
    }
--- a/MareSynchronos/Interop/Ipc/IpcCallerBrio.cs
+++ b/MareSynchronos/Interop/Ipc/IpcCallerBrio.cs
@@ -0,0 +1,146 @@
+using Dalamud.Game.ClientState.Objects.Types;
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using MareSynchronos.API.Dto.CharaData;
+using MareSynchronos.Services;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+using System.Text.Json.Nodes;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerBrio : IIpcCaller
+{
+    private readonly ILogger<IpcCallerBrio> _logger;
+    private readonly DalamudUtilService _dalamudUtilService;
+    private readonly ICallGateSubscriber<(int, int)> _brioApiVersion;
+
+    private readonly ICallGateSubscriber<bool, bool, bool, Task<IGameObject>> _brioSpawnActorAsync;
+    private readonly ICallGateSubscriber<IGameObject, bool> _brioDespawnActor;
+    private readonly ICallGateSubscriber<IGameObject, Vector3?, Quaternion?, Vector3?, bool, bool> _brioSetModelTransform;
+    private readonly ICallGateSubscriber<IGameObject, (Vector3?, Quaternion?, Vector3?)> _brioGetModelTransform;
+    private readonly ICallGateSubscriber<IGameObject, string> _brioGetPoseAsJson;
+    private readonly ICallGateSubscriber<IGameObject, string, bool, bool> _brioSetPoseFromJson;
+    private readonly ICallGateSubscriber<IGameObject, bool> _brioFreezeActor;
+    private readonly ICallGateSubscriber<bool> _brioFreezePhysics;
+
+
+    public bool APIAvailable { get; private set; }
+
+    public IpcCallerBrio(ILogger<IpcCallerBrio> logger, IDalamudPluginInterface dalamudPluginInterface,
+        DalamudUtilService dalamudUtilService)
+    {
+        _logger = logger;
+        _dalamudUtilService = dalamudUtilService;
+
+        _brioApiVersion = dalamudPluginInterface.GetIpcSubscriber<(int, int)>("Brio.ApiVersion");
+        _brioSpawnActorAsync = dalamudPluginInterface.GetIpcSubscriber<bool, bool, bool, Task<IGameObject>>("Brio.Actor.SpawnExAsync");
+        _brioDespawnActor = dalamudPluginInterface.GetIpcSubscriber<IGameObject, bool>("Brio.Actor.Despawn");
+        _brioSetModelTransform = dalamudPluginInterface.GetIpcSubscriber<IGameObject, Vector3?, Quaternion?, Vector3?, bool, bool>("Brio.Actor.SetModelTransform");
+        _brioGetModelTransform = dalamudPluginInterface.GetIpcSubscriber<IGameObject, (Vector3?, Quaternion?, Vector3?)>("Brio.Actor.GetModelTransform");
+        _brioGetPoseAsJson = dalamudPluginInterface.GetIpcSubscriber<IGameObject, string>("Brio.Actor.Pose.GetPoseAsJson");
+        _brioSetPoseFromJson = dalamudPluginInterface.GetIpcSubscriber<IGameObject, string, bool, bool>("Brio.Actor.Pose.LoadFromJson");
+        _brioFreezeActor = dalamudPluginInterface.GetIpcSubscriber<IGameObject, bool>("Brio.Actor.Freeze");
+        _brioFreezePhysics = dalamudPluginInterface.GetIpcSubscriber<bool>("Brio.FreezePhysics");
+
+        CheckAPI();
+    }
+
+    public void CheckAPI()
+    {
+        try
+        {
+            var version = _brioApiVersion.InvokeFunc();
+            APIAvailable = (version.Item1 == 2 && version.Item2 >= 0);
+        }
+        catch
+        {
+            APIAvailable = false;
+        }
+    }
+
+    public async Task<IGameObject?> SpawnActorAsync()
+    {
+        if (!APIAvailable) return null;
+        _logger.LogDebug("Spawning Brio Actor");
+        return await _brioSpawnActorAsync.InvokeFunc(false, false, true).ConfigureAwait(false);
+    }
+
+    public async Task<bool> DespawnActorAsync(nint address)
+    {
+        if (!APIAvailable) return false;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return false;
+        _logger.LogDebug("Despawning Brio Actor {actor}", gameObject.Name.TextValue);
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioDespawnActor.InvokeFunc(gameObject)).ConfigureAwait(false);
+    }
+
+    public async Task<bool> ApplyTransformAsync(nint address, WorldData data)
+    {
+        if (!APIAvailable) return false;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return false;
+        _logger.LogDebug("Applying Transform to Actor {actor}", gameObject.Name.TextValue);
+
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioSetModelTransform.InvokeFunc(gameObject,
+            new Vector3(data.PositionX, data.PositionY, data.PositionZ),
+            new Quaternion(data.RotationX, data.RotationY, data.RotationZ, data.RotationW),
+            new Vector3(data.ScaleX, data.ScaleY, data.ScaleZ), false)).ConfigureAwait(false);
+    }
+
+    public async Task<WorldData> GetTransformAsync(nint address)
+    {
+        if (!APIAvailable) return default;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return default;
+        var data = await _dalamudUtilService.RunOnFrameworkThread(() => _brioGetModelTransform.InvokeFunc(gameObject)).ConfigureAwait(false);
+        _logger.LogDebug("Getting Transform from Actor {actor}", gameObject.Name.TextValue);
+
+        return new WorldData()
+        {
+            PositionX = data.Item1.Value.X,
+            PositionY = data.Item1.Value.Y,
+            PositionZ = data.Item1.Value.Z,
+            RotationX = data.Item2.Value.X,
+            RotationY = data.Item2.Value.Y,
+            RotationZ = data.Item2.Value.Z,
+            RotationW = data.Item2.Value.W,
+            ScaleX = data.Item3.Value.X,
+            ScaleY = data.Item3.Value.Y,
+            ScaleZ = data.Item3.Value.Z
+        };
+    }
+
+    public async Task<string?> GetPoseAsync(nint address)
+    {
+        if (!APIAvailable) return null;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return null;
+        _logger.LogDebug("Getting Pose from Actor {actor}", gameObject.Name.TextValue);
+
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioGetPoseAsJson.InvokeFunc(gameObject)).ConfigureAwait(false);
+    }
+
+    public async Task<bool> SetPoseAsync(nint address, string pose)
+    {
+        if (!APIAvailable) return false;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return false;
+        _logger.LogDebug("Setting Pose to Actor {actor}", gameObject.Name.TextValue);
+
+        var applicablePose = JsonNode.Parse(pose)!;
+        var currentPose = await _dalamudUtilService.RunOnFrameworkThread(() => _brioGetPoseAsJson.InvokeFunc(gameObject)).ConfigureAwait(false);
+        applicablePose["ModelDifference"] = JsonNode.Parse(JsonNode.Parse(currentPose)!["ModelDifference"]!.ToJsonString());
+
+        await _dalamudUtilService.RunOnFrameworkThread(() =>
+        {
+            _brioFreezeActor.InvokeFunc(gameObject);
+            _brioFreezePhysics.InvokeFunc();
+        }).ConfigureAwait(false);
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioSetPoseFromJson.InvokeFunc(gameObject, applicablePose.ToJsonString(), false)).ConfigureAwait(false);
+    }
+
+    public void Dispose()
+    {
+    }
+}
--- a/MareSynchronos/Interop/Ipc/IpcManager.cs
+++ b/MareSynchronos/Interop/Ipc/IpcManager.cs
@@ -7,15 +7,16 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
 {
    public IpcManager(ILogger<IpcManager> logger, MareMediator mediator,
        IpcCallerPenumbra penumbraIpc, IpcCallerGlamourer glamourerIpc, IpcCallerCustomize customizeIpc, IpcCallerHeels heelsIpc,
-        IpcCallerHonorific honorificIpc, IpcCallerPetNames ipcCallerPetNames, IpcCallerMoodles moodlesIpc) : base(logger, mediator)
+        IpcCallerHonorific honorificIpc, IpcCallerMoodles moodlesIpc, IpcCallerPetNames ipcCallerPetNames, IpcCallerBrio ipcCallerBrio) : base(logger, mediator)
    {
        CustomizePlus = customizeIpc;
        Heels = heelsIpc;
        Glamourer = glamourerIpc;
        Penumbra = penumbraIpc;
        Honorific = honorificIpc;
-        PetNames = ipcCallerPetNames;
        Moodles = moodlesIpc;
+        PetNames = ipcCallerPetNames;
+        Brio = ipcCallerBrio;

        if (Initialized)
        {
@@ -41,15 +42,17 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
    public IpcCallerHeels Heels { get; init; }
    public IpcCallerGlamourer Glamourer { get; }
    public IpcCallerPenumbra Penumbra { get; }
-    public IpcCallerPetNames PetNames { get; }
    public IpcCallerMoodles Moodles { get; }
+    public IpcCallerPetNames PetNames { get; }
+
+    public IpcCallerBrio Brio { get; }

    private int _stateCheckCounter = -1;

    private void PeriodicApiStateCheck()
    {
        // Stagger API checks
-        if (++_stateCheckCounter > 7)
+        if (++_stateCheckCounter > 8)
            _stateCheckCounter = 0;
        int i = _stateCheckCounter;
        if (i == 0) Penumbra.CheckAPI();
@@ -58,7 +61,8 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
        if (i == 3) Heels.CheckAPI();
        if (i == 4) CustomizePlus.CheckAPI();
        if (i == 5) Honorific.CheckAPI();
-        if (i == 6) PetNames.CheckAPI();
-        if (i == 7) Moodles.CheckAPI();
+        if (i == 6) Moodles.CheckAPI();
+        if (i == 7) PetNames.CheckAPI();
+        if (i == 8) Brio.CheckAPI();
    }
 }
--- a/MareSynchronos/Interop/Ipc/IpcProvider.cs
+++ b/MareSynchronos/Interop/Ipc/IpcProvider.cs
@@ -2,7 +2,6 @@
 using Dalamud.Plugin;
 using Dalamud.Plugin.Ipc;
 using MareSynchronos.MareConfiguration;
-using MareSynchronos.PlayerData.Export;
 using MareSynchronos.PlayerData.Handlers;
 using MareSynchronos.Services;
 using MareSynchronos.Services.Mediator;
@@ -16,7 +15,6 @@ public class IpcProvider : IHostedService, IMediatorSubscriber
    private readonly ILogger<IpcProvider> _logger;
    private readonly IDalamudPluginInterface _pi;
    private readonly MareConfigService _mareConfig;
-    private readonly MareCharaFileManager _mareCharaFileManager;
    private readonly DalamudUtilService _dalamudUtil;
    private ICallGateProvider<string, IGameObject, bool>? _loadFileProvider;
    private ICallGateProvider<string, IGameObject, Task<bool>>? _loadFileAsyncProvider;
@@ -36,16 +34,17 @@ public class IpcProvider : IHostedService, IMediatorSubscriber
    public MareMediator Mediator { get; init; }

    public IpcProvider(ILogger<IpcProvider> logger, IDalamudPluginInterface pi, MareConfigService mareConfig,
-        MareCharaFileManager mareCharaFileManager, DalamudUtilService dalamudUtil,
+         DalamudUtilService dalamudUtil,
        MareMediator mareMediator)
    {
        _logger = logger;
        _pi = pi;
        _mareConfig = mareConfig;
-        _mareCharaFileManager = mareCharaFileManager;
        _dalamudUtil = dalamudUtil;
        Mediator = mareMediator;

+        // todo: fix ipc to use CharaDataManager
+
        Mediator.Subscribe<GameObjectHandlerCreatedMessage>(this, (msg) =>
        {
            if (msg.OwnedObject) return;
@@ -136,7 +135,7 @@ public class IpcProvider : IHostedService, IMediatorSubscriber

    private async Task<bool> LoadMcdfAsync(string path, IGameObject target)
    {
-        if (_mareCharaFileManager.CurrentlyWorking || !_dalamudUtil.IsInGpose)
+        //if (_mareCharaFileManager.CurrentlyWorking || !_dalamudUtil.IsInGpose)
            return false;

        await ApplyFileAsync(path, target).ConfigureAwait(false);
@@ -146,7 +145,7 @@ public class IpcProvider : IHostedService, IMediatorSubscriber

    private bool LoadMcdf(string path, IGameObject target)
    {
-        if (_mareCharaFileManager.CurrentlyWorking || !_dalamudUtil.IsInGpose)
+        //if (_mareCharaFileManager.CurrentlyWorking || !_dalamudUtil.IsInGpose)
            return false;

        _ = Task.Run(async () => await ApplyFileAsync(path, target).ConfigureAwait(false)).ConfigureAwait(false);
@@ -156,6 +155,7 @@ public class IpcProvider : IHostedService, IMediatorSubscriber

    private async Task ApplyFileAsync(string path, IGameObject target)
    {
+        /*
        try
        {
            var expectedLength = _mareCharaFileManager.LoadMareCharaFile(path);
@@ -168,7 +168,7 @@ public class IpcProvider : IHostedService, IMediatorSubscriber
        finally
        {
            _mareCharaFileManager.ClearMareCharaFile();
-        }
+        }*/
    }

    private List<nint> GetHandledAddresses()
--- a/MareSynchronos/Interop/VfxSpawnManager.cs
+++ b/MareSynchronos/Interop/VfxSpawnManager.cs
@@ -0,0 +1,179 @@
+using Dalamud.Memory;
+using Dalamud.Plugin.Services;
+using Dalamud.Utility.Signatures;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace MareSynchronos.Interop;
+
+/// <summary>
+/// Code for spawning mostly taken from https://git.anna.lgbt/anna/OrangeGuidanceTomestone/src/branch/main/client/Vfx.cs
+/// </summary>
+public unsafe class VfxSpawnManager : DisposableMediatorSubscriberBase
+{
+    private static readonly byte[] _pool = "Client.System.Scheduler.Instance.VfxObject\0"u8.ToArray();
+
+    [Signature("E8 ?? ?? ?? ?? F3 0F 10 35 ?? ?? ?? ?? 48 89 43 08")]
+    private readonly delegate* unmanaged<byte*, byte*, VfxStruct*> _staticVfxCreate;
+
+    [Signature("E8 ?? ?? ?? ?? 8B 4B 7C 85 C9")]
+    private readonly delegate* unmanaged<VfxStruct*, float, int, ulong> _staticVfxRun;
+
+    [Signature("40 53 48 83 EC 20 48 8B D9 48 8B 89 ?? ?? ?? ?? 48 85 C9 74 28 33 D2 E8 ?? ?? ?? ?? 48 8B 8B ?? ?? ?? ?? 48 85 C9")]
+    private readonly delegate* unmanaged<VfxStruct*, nint> _staticVfxRemove;
+
+    public VfxSpawnManager(ILogger<VfxSpawnManager> logger, IGameInteropProvider gameInteropProvider, MareMediator mareMediator)
+        : base(logger, mareMediator)
+    {
+        gameInteropProvider.InitializeFromAttributes(this);
+        mareMediator.Subscribe<GposeStartMessage>(this, (msg) =>
+        {
+            ChangeSpawnVisibility(0f);
+        });
+        mareMediator.Subscribe<GposeEndMessage>(this, (msg) =>
+        {
+            ChangeSpawnVisibility(0.5f);
+        });
+        mareMediator.Subscribe<CutsceneStartMessage>(this, (msg) =>
+        {
+            ChangeSpawnVisibility(0f);
+        });
+        mareMediator.Subscribe<CutsceneEndMessage>(this, (msg) =>
+        {
+            ChangeSpawnVisibility(0.5f);
+        });
+    }
+
+    private unsafe void ChangeSpawnVisibility(float visibility)
+    {
+        foreach (var vfx in _spawnedObjects)
+        {
+            ((VfxStruct*)vfx.Value)->Alpha = visibility;
+        }
+    }
+
+    private readonly Dictionary<Guid, nint> _spawnedObjects = [];
+
+    private VfxStruct* SpawnStatic(string path, Vector3 pos, Quaternion rotation, float r, float g, float b, float a, Vector3 scale)
+    {
+        VfxStruct* vfx;
+        fixed (byte* terminatedPath = Encoding.UTF8.GetBytes(path).NullTerminate())
+        {
+            fixed (byte* pool = _pool)
+            {
+                vfx = _staticVfxCreate(terminatedPath, pool);
+            }
+        }
+
+        if (vfx == null)
+        {
+            return null;
+        }
+
+        vfx->Position = new Vector3(pos.X, pos.Y + 1, pos.Z);
+        vfx->Rotation = new Quaternion(rotation.X, rotation.Y, rotation.Z, rotation.W);
+
+        vfx->SomeFlags &= 0xF7;
+        vfx->Flags |= 2;
+        vfx->Red = r;
+        vfx->Green = g;
+        vfx->Blue = b;
+        vfx->Scale = scale;
+
+        vfx->Alpha = a;
+
+        _staticVfxRun(vfx, 0.0f, -1);
+
+        return vfx;
+    }
+
+    public Guid? SpawnObject(Vector3 position, Quaternion rotation, Vector3 scale, float r = 1f, float g = 1f, float b = 1f, float a = 0.5f)
+    {
+        Logger.LogDebug("Trying to Spawn orb VFX at {pos}, {rot}", position, rotation);
+        var vfx = SpawnStatic("bgcommon/world/common/vfx_for_event/eff/b0150_eext_y.avfx", position, rotation, r, g, b, a, scale);
+        if (vfx == null || (nint)vfx == nint.Zero)
+        {
+            Logger.LogDebug("Failed to Spawn VFX at {pos}, {rot}", position, rotation);
+            return null;
+        }
+        Guid guid = Guid.NewGuid();
+        Logger.LogDebug("Spawned VFX at {pos}, {rot}: 0x{ptr:X}", position, rotation, (nint)vfx);
+
+        _spawnedObjects[guid] = (nint)vfx;
+
+        return guid;
+    }
+
+    public void DespawnObject(Guid id)
+    {
+        if (_spawnedObjects.Remove<Guid, nint>(id, out var vfx))
+        {
+            Logger.LogDebug("Despawning {obj:X}", vfx);
+            _staticVfxRemove((VfxStruct*)vfx);
+        }
+    }
+
+    private void RemoveAllVfx()
+    {
+        foreach (var obj in _spawnedObjects.Values)
+        {
+            Logger.LogDebug("Despawning {obj:X}", obj);
+            _staticVfxRemove((VfxStruct*)obj);
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        if (disposing)
+        {
+            RemoveAllVfx();
+        }
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    internal struct VfxStruct
+    {
+        [FieldOffset(0x38)]
+        public byte Flags;
+
+        [FieldOffset(0x50)]
+        public Vector3 Position;
+
+        [FieldOffset(0x60)]
+        public Quaternion Rotation;
+
+        [FieldOffset(0x70)]
+        public Vector3 Scale;
+
+        [FieldOffset(0x128)]
+        public int ActorCaster;
+
+        [FieldOffset(0x130)]
+        public int ActorTarget;
+
+        [FieldOffset(0x1B8)]
+        public int StaticCaster;
+
+        [FieldOffset(0x1C0)]
+        public int StaticTarget;
+
+        [FieldOffset(0x248)]
+        public byte SomeFlags;
+
+        [FieldOffset(0x260)]
+        public float Red;
+
+        [FieldOffset(0x264)]
+        public float Green;
+
+        [FieldOffset(0x268)]
+        public float Blue;
+
+        [FieldOffset(0x26C)]
+        public float Alpha;
+    }
+}