Some cleanup, use OtterGui.

Glamourer.GameData/Structs/CharacterEquipMask.cs

@@ -0,0 +1,43 @@
+using System;
+using Penumbra.GameData.Enums;
+
+namespace Glamourer.Structs;
+
+[Flags]
+public enum CharacterEquipMask : ushort
+{
+    None = 0,
+    MainHand = 0b000000000001,
+    OffHand = 0b000000000010,
+    Head = 0b000000000100,
+    Body = 0b000000001000,
+    Hands = 0b000000010000,
+    Legs = 0b000000100000,
+    Feet = 0b000001000000,
+    Ears = 0b000010000000,
+    Neck = 0b000100000000,
+    Wrists = 0b001000000000,
+    RFinger = 0b010000000000,
+    LFinger = 0b100000000000,
+    All = 0b111111111111,
+}
+
+public static class CharacterEquipMaskExtensions
+{
+    public static bool Fits(this CharacterEquipMask mask, EquipSlot slot)
+        => slot switch
+        {
+            EquipSlot.Unknown => false,
+            EquipSlot.Head => mask.HasFlag(CharacterEquipMask.Head),
+            EquipSlot.Body => mask.HasFlag(CharacterEquipMask.Body),
+            EquipSlot.Hands => mask.HasFlag(CharacterEquipMask.Hands),
+            EquipSlot.Legs => mask.HasFlag(CharacterEquipMask.Legs),
+            EquipSlot.Feet => mask.HasFlag(CharacterEquipMask.Feet),
+            EquipSlot.Ears => mask.HasFlag(CharacterEquipMask.Ears),
+            EquipSlot.Neck => mask.HasFlag(CharacterEquipMask.Neck),
+            EquipSlot.Wrists => mask.HasFlag(CharacterEquipMask.Wrists),
+            EquipSlot.RFinger => mask.HasFlag(CharacterEquipMask.RFinger),
+            EquipSlot.LFinger => mask.HasFlag(CharacterEquipMask.LFinger),
+            _ => false,
+        };
+}

Glamourer.GameData/Structs/Item.cs

@@ -0,0 +1,54 @@
+using Penumbra.GameData.Enums;
+using Penumbra.GameData.Structs;
+
+namespace Glamourer.Structs;
+
+public readonly struct Item
+{
+    private static (SetId id, WeaponType type, ushort variant) ParseModel(EquipSlot slot, ulong data)
+    {
+        if (slot is EquipSlot.MainHand or EquipSlot.OffHand)
+        {
+            var id      = (SetId)(data & 0xFFFF);
+            var type    = (WeaponType)((data >> 16) & 0xFFFF);
+            var variant = (ushort)((data >> 32) & 0xFFFF);
+            return (id, type, variant);
+        }
+        else
+        {
+            var id      = (SetId)(data & 0xFFFF);
+            var variant = (byte)((data >> 16) & 0xFF);
+            return (id, new WeaponType(), variant);
+        }
+    }
+
+    public readonly Lumina.Excel.GeneratedSheets.Item Base;
+    public readonly string                            Name;
+    public readonly EquipSlot                         EquippableTo;
+
+    public (SetId id, WeaponType type, ushort variant) MainModel
+        => ParseModel(EquippableTo, Base.ModelMain);
+
+    public bool HasSubModel
+        => Base.ModelSub != 0;
+
+    public (SetId id, WeaponType type, ushort variant) SubModel
+        => ParseModel(EquippableTo, Base.ModelSub);
+
+    public Item(Lumina.Excel.GeneratedSheets.Item item, string name, EquipSlot slot = EquipSlot.Unknown)
+    {
+        Base         = item;
+        Name         = name;
+        EquippableTo = slot == EquipSlot.Unknown ? ((EquipSlot)item.EquipSlotCategory.Row).ToSlot() : slot;
+    }
+
+    public static Item Nothing(EquipSlot slot)
+        => new("Nothing", slot);
+
+    private Item(string name, EquipSlot slot)
+    {
+        Name         = name;
+        Base         = new Lumina.Excel.GeneratedSheets.Item();
+        EquippableTo = slot;
+    }
+}

Glamourer.GameData/Structs/Job.cs

@@ -0,0 +1,20 @@
+using Lumina.Excel.GeneratedSheets;
+
+namespace Glamourer.Structs;
+
+public readonly struct Job
+{
+    public readonly string Name;
+    public readonly string Abbreviation;
+    public readonly ClassJob Base;
+
+    public uint Id
+        => Base.RowId;
+
+    public Job(ClassJob job)
+    {
+        Base = job;
+        Name = job.Name.ToString();
+        Abbreviation = job.Abbreviation.ToString();
+    }
+}

Glamourer.GameData/Structs/JobGroup.cs

@@ -0,0 +1,48 @@
+using System.Diagnostics;
+using System.Linq;
+using Lumina.Excel;
+using Lumina.Excel.GeneratedSheets;
+
+namespace Glamourer.Structs;
+
+public readonly struct JobGroup
+{
+    public readonly string Name;
+    private readonly ulong _flags;
+    public readonly int Count;
+    public readonly uint Id;
+
+    public JobGroup(ClassJobCategory group, ExcelSheet<ClassJob> jobs)
+    {
+        Count = 0;
+        _flags = 0ul;
+        Id = group.RowId;
+        Name = group.Name.ToString();
+
+        Debug.Assert(jobs.RowCount < 64);
+        foreach (var job in jobs)
+        {
+            var abbr = job.Abbreviation.ToString();
+            if (!abbr.Any())
+                continue;
+
+            var prop = group.GetType().GetProperty(abbr);
+            Debug.Assert(prop != null);
+
+            if (!(bool)prop.GetValue(group)!)
+                continue;
+
+            ++Count;
+            _flags |= 1ul << (int)job.RowId;
+        }
+    }
+
+    public bool Fits(Job job)
+        => Fits(job.Id);
+
+    public bool Fits(uint jobId)
+    {
+        var flag = 1ul << (int)jobId;
+        return (flag & _flags) != 0;
+    }
+}

Glamourer.GameData/Structs/Stain.cs

@@ -0,0 +1,49 @@
+using Penumbra.GameData.Structs;
+
+namespace Glamourer.Structs;
+
+public readonly struct Stain
+{
+    public readonly string Name;
+    public readonly uint RgbaColor;
+
+    private readonly uint _seColorId;
+
+    public byte R
+        => (byte)(RgbaColor & 0xFF);
+
+    public byte G
+        => (byte)(RgbaColor >> 8 & 0xFF);
+
+    public byte B
+        => (byte)(RgbaColor >> 16 & 0xFF);
+
+    public byte Intensity
+        => (byte)((1 + R + G + B) / 3);
+
+    public uint SeColor
+        => _seColorId & 0x00FFFFFF;
+
+    public StainId RowIndex
+        => (StainId)(_seColorId >> 24);
+
+
+    public static uint SeColorToRgba(uint color)
+        => (color & 0xFF) << 16 | color >> 16 & 0xFF | color & 0xFF00 | 0xFF000000;
+
+    public Stain(byte index, Lumina.Excel.GeneratedSheets.Stain stain)
+    {
+        Name = stain.Name.ToString();
+        _seColorId = stain.Color | (uint)index << 24;
+        RgbaColor = SeColorToRgba(stain.Color);
+    }
+
+    public static readonly Stain None = new("None");
+
+    private Stain(string name)
+    {
+        Name = name;
+        _seColorId = 0;
+        RgbaColor = 0;
+    }
+}