.

GlamourerOld/Gui/Customization/CustomizationDrawer.Color.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Numerics;
+using Glamourer.Customization;
+using ImGuiNET;
+using OtterGui.Raii;
+
+namespace Glamourer.Gui.Customization;
+
+public partial class CustomizationDrawer
+{
+    private const string ColorPickerPopupName = "ColorPicker";
+
+    private void DrawColorPicker(CustomizeIndex index)
+    {
+        using var _ = SetId(index);
+        var (current, custom) = GetCurrentCustomization(index);
+        var color = ImGui.ColorConvertU32ToFloat4(custom.Color);
+
+        // Print 1-based index instead of 0.
+        if (ImGui.ColorButton($"{current + 1}##color", color, ImGuiColorEditFlags.None, _framedIconSize))
+            ImGui.OpenPopup(ColorPickerPopupName);
+
+        ImGui.SameLine();
+
+        using (var group = ImRaii.Group())
+        {
+            DataInputInt(current);
+            ImGui.TextUnformatted(_currentOption);
+        }
+        DrawColorPickerPopup();
+    }
+
+    private void DrawColorPickerPopup()
+    {
+        using var popup = ImRaii.Popup(ColorPickerPopupName, ImGuiWindowFlags.AlwaysAutoResize);
+        if (!popup)
+            return;
+
+        using var style = ImRaii.PushStyle(ImGuiStyleVar.ItemSpacing, Vector2.Zero)
+            .Push(ImGuiStyleVar.FrameRounding, 0);
+        for (var i = 0; i < _currentCount; ++i)
+        {
+            var custom = _set.Data(_currentIndex, i, _customize[CustomizeIndex.Face]);
+            if (ImGui.ColorButton((i + 1).ToString(), ImGui.ColorConvertU32ToFloat4(custom.Color)))
+            {
+                UpdateValue(custom.Value);
+                ImGui.CloseCurrentPopup();
+            }
+
+            if (i % 8 != 7)
+                ImGui.SameLine();
+        }
+    }
+
+    // Obtain the current customization and print a warning if it is not known.
+    private (int, CustomizeData) GetCurrentCustomization(CustomizeIndex index)
+    {
+        var current = _set.DataByValue(index, _customize[index], out var custom, _customize.Face);
+        if (_set.IsAvailable(index) && current < 0)
+            throw new Exception($"Read invalid customization value {_customize[index]} for {index}.");
+
+        return (current, custom!.Value);
+    }
+}

GlamourerOld/Gui/Customization/CustomizationDrawer.GenderRace.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Linq;
+using Dalamud.Interface;
+using Glamourer.Customization;
+using Glamourer.Util;
+using ImGuiNET;
+using OtterGui;
+using OtterGui.Raii;
+using Penumbra.GameData.Enums;
+using Penumbra.GameData.Structs;
+
+namespace Glamourer.Gui.Customization;
+
+public partial class CustomizationDrawer
+{
+    private void DrawRaceGenderSelector()
+    {
+        DrawGenderSelector();
+        ImGui.SameLine();
+        using var group = ImRaii.Group();
+        DrawRaceCombo();
+        var gender = _service.AwaitedService.GetName(CustomName.Gender);
+        var clan   = _service.AwaitedService.GetName(CustomName.Clan);
+        ImGui.TextUnformatted($"{gender} & {clan}");
+    }
+
+    private void DrawGenderSelector()
+    {
+        using var font = ImRaii.PushFont(UiBuilder.IconFont);
+        var icon = _customize.Gender switch
+        {
+            Gender.Male when _customize.Race is Race.Hrothgar => FontAwesomeIcon.MarsDouble,
+            Gender.Male                                       => FontAwesomeIcon.Mars,
+            Gender.Female                                     => FontAwesomeIcon.Venus,
+
+            _ => throw new Exception($"Gender value {_customize.Gender} is not a valid gender for a design."),
+        };
+
+        if (!ImGuiUtil.DrawDisabledButton(icon.ToIconString(), _framedIconSize, string.Empty, icon == FontAwesomeIcon.MarsDouble, true))
+            return;
+
+        Changed |= _customize.ChangeGender(CharacterEquip.Null, _customize.Gender is Gender.Male ? Gender.Female : Gender.Male, _items, _service.AwaitedService);
+    }
+
+    private void DrawRaceCombo()
+    {
+        ImGui.SetNextItemWidth(_raceSelectorWidth);
+        using var combo = ImRaii.Combo("##subRaceCombo", _customize.ClanName(_service.AwaitedService));
+        if (!combo)
+            return;
+
+        foreach (var subRace in Enum.GetValues<SubRace>().Skip(1)) // Skip Unknown
+        {
+            if (ImGui.Selectable(CustomizeExtensions.ClanName(_service.AwaitedService, subRace, _customize.Gender), subRace == _customize.Clan))
+                Changed |= _customize.ChangeRace(CharacterEquip.Null, subRace, _items, _service.AwaitedService);
+        }
+    }
+}

GlamourerOld/Gui/Customization/CustomizationDrawer.Icon.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Numerics;
+using Glamourer.Customization;
+using ImGuiNET;
+using OtterGui;
+using OtterGui.Raii;
+using Penumbra.GameData.Enums;
+
+namespace Glamourer.Gui.Customization;
+
+public partial class CustomizationDrawer
+{
+    private const string IconSelectorPopup = "Style Picker";
+
+    private void DrawIconSelector(CustomizeIndex index)
+    {
+        using var _        = SetId(index);
+        using var bigGroup = ImRaii.Group();
+        var       label    = _currentOption;
+
+        var current = _set.DataByValue(index, _currentByte, out var custom, _customize.Face);
+        if (current < 0)
+        {
+            label   = $"{_currentOption} (Custom #{_customize[index]})";
+            current = 0;
+            custom  = _set.Data(index, 0);
+        }
+
+        var icon = _service.AwaitedService.GetIcon(custom!.Value.IconId);
+        if (ImGui.ImageButton(icon.ImGuiHandle, _iconSize))
+            ImGui.OpenPopup(IconSelectorPopup);
+        ImGuiUtil.HoverIconTooltip(icon, _iconSize);
+
+        ImGui.SameLine();
+        using (var group = ImRaii.Group())
+        {
+            if (_currentIndex == CustomizeIndex.Face)
+                FaceInputInt(current);
+            else
+                DataInputInt(current);
+
+            ImGui.TextUnformatted($"{label} ({custom.Value.Value})");
+        }
+
+        DrawIconPickerPopup();
+    }
+
+    private bool UpdateFace(CustomizeData data)
+    {
+        // Hrothgar Hack
+        var value = _set.Race == Race.Hrothgar ? data.Value + 4 : data.Value;
+        if (_customize.Face == value)
+            return false;
+
+        _customize.Face =  value;
+        Changed         |= CustomizeFlag.Face;
+        return true;
+    }
+
+    private void FaceInputInt(int currentIndex)
+    {
+        ++currentIndex;
+        ImGui.SetNextItemWidth(_inputIntSize);
+        if (ImGui.InputInt("##text", ref currentIndex, 1, 1))
+        {
+            currentIndex = Math.Clamp(currentIndex - 1, 0, _currentCount - 1);
+            var data = _set.Data(_currentIndex, currentIndex, _customize.Face);
+            UpdateFace(data);
+        }
+
+        ImGuiUtil.HoverTooltip($"Input Range: [1, {_currentCount}]");
+    }
+
+    private void DrawIconPickerPopup()
+    {
+        using var popup = ImRaii.Popup(IconSelectorPopup, ImGuiWindowFlags.AlwaysAutoResize);
+        if (!popup)
+            return;
+
+        using var style = ImRaii.PushStyle(ImGuiStyleVar.ItemSpacing, Vector2.Zero)
+            .Push(ImGuiStyleVar.FrameRounding, 0);
+        for (var i = 0; i < _currentCount; ++i)
+        {
+            var custom = _set.Data(_currentIndex, i, _customize.Face);
+            var icon   = _service.AwaitedService.GetIcon(custom.IconId);
+            using (var _ = ImRaii.Group())
+            {
+                if (ImGui.ImageButton(icon.ImGuiHandle, _iconSize))
+                {
+                    if (_currentIndex == CustomizeIndex.Face)
+                        UpdateFace(custom);
+                    else
+                        UpdateValue(custom.Value);
+                    ImGui.CloseCurrentPopup();
+                }
+
+                ImGuiUtil.HoverIconTooltip(icon, _iconSize);
+
+                var text      = custom.Value.ToString();
+                var textWidth = ImGui.CalcTextSize(text).X;
+                ImGui.SetCursorPosX(ImGui.GetCursorPosX() + (_iconSize.X - textWidth + 2 * ImGui.GetStyle().FramePadding.X) / 2);
+                ImGui.TextUnformatted(text);
+            }
+
+            if (i % 8 != 7)
+                ImGui.SameLine();
+        }
+    }
+
+
+    // Only used for facial features, so fixed ID.
+    private void DrawMultiIconSelector()
+    {
+        using var bigGroup = ImRaii.Group();
+        DrawMultiIcons();
+        ImGui.SameLine();
+        using var group = ImRaii.Group();
+        ImGui.Dummy(new Vector2(0, ImGui.GetTextLineHeightWithSpacing() + ImGui.GetStyle().ItemSpacing.Y / 2));
+
+        _currentCount = 256;
+        PercentageInputInt();
+
+        ImGui.TextUnformatted(_set.Option(CustomizeIndex.LegacyTattoo));
+    }
+
+    private void DrawMultiIcons()
+    {
+        var       options = _set.Order[CharaMakeParams.MenuType.IconCheckmark];
+        using var _       = ImRaii.Group();
+        foreach (var (featureIdx, idx) in options.WithIndex())
+        {
+            using var id      = SetId(featureIdx);
+            var       enabled = _customize.Get(featureIdx) != CustomizeValue.Zero;
+            var       feature = _set.Data(featureIdx, 0, _customize.Face);
+            var icon = featureIdx == CustomizeIndex.LegacyTattoo
+                ? _legacyTattoo ?? _service.AwaitedService.GetIcon(feature.IconId)
+                : _service.AwaitedService.GetIcon(feature.IconId);
+            if (ImGui.ImageButton(icon.ImGuiHandle, _iconSize, Vector2.Zero, Vector2.One, (int)ImGui.GetStyle().FramePadding.X,
+                    Vector4.Zero, enabled ? Vector4.One : _redTint))
+            {
+                _customize.Set(featureIdx, enabled ? CustomizeValue.Zero : CustomizeValue.Max);
+                Changed |= _currentFlag;
+            }
+
+            ImGuiUtil.HoverIconTooltip(icon, _iconSize);
+            if (idx % 4 != 3)
+                ImGui.SameLine();
+        }
+    }
+}

GlamourerOld/Gui/Customization/CustomizationDrawer.Simple.cs

@@ -0,0 +1,102 @@
+using System;
+using Glamourer.Customization;
+using ImGuiNET;
+using OtterGui;
+using OtterGui.Raii;
+
+namespace Glamourer.Gui.Customization;
+
+public partial class CustomizationDrawer
+{
+    private void PercentageSelector(CustomizeIndex index)
+    {
+        using var _        = SetId(index);
+        using var bigGroup = ImRaii.Group();
+
+        DrawPercentageSlider();
+        ImGui.SameLine();
+        PercentageInputInt();
+        ImGui.SameLine();
+        ImGui.TextUnformatted(_currentOption);
+    }
+
+    private void DrawPercentageSlider()
+    {
+        var tmp = (int)_currentByte.Value;
+        ImGui.SetNextItemWidth(_comboSelectorSize);
+        if (ImGui.SliderInt("##slider", ref tmp, 0, _currentCount - 1, "%i", ImGuiSliderFlags.AlwaysClamp))
+            UpdateValue((CustomizeValue)tmp);
+    }
+
+    private void PercentageInputInt()
+    {
+        var tmp = (int)_currentByte.Value;
+        ImGui.SetNextItemWidth(_inputIntSize);
+        if (ImGui.InputInt("##text", ref tmp, 1, 1))
+            UpdateValue((CustomizeValue)Math.Clamp(tmp, 0, _currentCount - 1));
+        ImGuiUtil.HoverTooltip($"Input Range: [0, {_currentCount - 1}]");
+    }
+
+    // Integral input for an icon- or color based item.
+    private void DataInputInt(int currentIndex)
+    {
+        ++currentIndex;
+        ImGui.SetNextItemWidth(_inputIntSize);
+        if (ImGui.InputInt("##text", ref currentIndex, 1, 1))
+        {
+            currentIndex = Math.Clamp(currentIndex - 1, 0, _currentCount - 1);
+            var data = _set.Data(_currentIndex, currentIndex, _customize.Face);
+            UpdateValue(data.Value);
+        }
+
+        ImGuiUtil.HoverTooltip($"Input Range: [1, {_currentCount}]");
+    }
+
+    private void DrawListSelector(CustomizeIndex index)
+    {
+        using var _        = SetId(index);
+        using var bigGroup = ImRaii.Group();
+
+        ListCombo();
+        ImGui.SameLine();
+        ListInputInt();
+        ImGui.SameLine();
+        ImGui.TextUnformatted(_currentOption);
+    }
+
+    private void ListCombo()
+    {
+        ImGui.SetNextItemWidth(_comboSelectorSize * ImGui.GetIO().FontGlobalScale);
+        using var combo = ImRaii.Combo("##combo", $"{_currentOption} #{_currentByte.Value + 1}");
+
+        if (!combo)
+            return;
+
+        for (var i = 0; i < _currentCount; ++i)
+        {
+            if (ImGui.Selectable($"{_currentOption} #{i + 1}##combo", i == _currentByte.Value))
+                UpdateValue((CustomizeValue)i);
+        }
+    }
+
+    private void ListInputInt()
+    {
+        var tmp = _currentByte.Value + 1;
+        ImGui.SetNextItemWidth(_inputIntSize);
+        if (ImGui.InputInt("##text", ref tmp, 1, 1) && tmp > 0 && tmp <= _currentCount)
+            UpdateValue((CustomizeValue)Math.Clamp(tmp - 1, 0, _currentCount - 1));
+        ImGuiUtil.HoverTooltip($"Input Range: [1, {_currentCount}]");
+    }
+
+    // Draw a customize checkbox.
+    private void DrawCheckbox(CustomizeIndex idx)
+    {
+        using var id  = SetId(idx);
+        var       tmp = _currentByte != CustomizeValue.Zero;
+        if (ImGui.Checkbox(_currentOption, ref tmp))
+        {
+            _customize.Set(idx, tmp ? CustomizeValue.Max : CustomizeValue.Zero);
+            Changed |= _currentFlag;
+        }
+    }
+}

GlamourerOld/Gui/Customization/CustomizationDrawer.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Numerics;
+using System.Reflection;
+using Dalamud.Plugin;
+using Glamourer.Customization;
+using Glamourer.Services;
+using ImGuiNET;
+using OtterGui;
+using OtterGui.Raii;
+
+namespace Glamourer.Gui.Customization;
+
+public partial class CustomizationDrawer : IDisposable
+{
+    private readonly Vector4                 _redTint = new(0.6f, 0.3f, 0.3f, 1f);
+    private readonly ImGuiScene.TextureWrap? _legacyTattoo;
+
+    private bool       _withFlags = false;
+    private Exception? _terminate = null;
+
+    private Customize        _customize;
+    private CustomizationSet _set = null!;
+
+    public Customize Customize;
+
+    public CustomizeFlag CurrentFlag { get; private set; }
+    public CustomizeFlag Changed     { get; private set; }
+
+    public bool RequiresRedraw
+        => Changed.RequiresRedraw();
+
+    private bool    _locked = false;
+    private Vector2 _iconSize;
+    private Vector2 _framedIconSize;
+    private float   _inputIntSize;
+    private float   _comboSelectorSize;
+    private float   _raceSelectorWidth;
+
+    private readonly CustomizationService _service;
+    private readonly ItemManager          _items;
+
+    public CustomizationDrawer(DalamudPluginInterface pi, CustomizationService service, ItemManager items)
+    {
+        _service      = service;
+        _items        = items;
+        _legacyTattoo = GetLegacyTattooIcon(pi);
+        Customize     = Customize.Default;
+    }
+
+    public void Dispose()
+    {
+        _legacyTattoo?.Dispose();
+    }
+
+    public bool Draw(Customize current, bool locked)
+    {
+        _withFlags  = false;
+        CurrentFlag = CustomizeFlagExtensions.All;
+        Init(current, locked);
+        return DrawInternal();
+    }
+
+    public bool Draw(Customize current, CustomizeFlag currentFlags, bool locked)
+    {
+        _withFlags  = true;
+        CurrentFlag = currentFlags;
+        Init(current, locked);
+        return DrawInternal();
+    }
+
+    private void Init(Customize current, bool locked)
+    {
+        UpdateSizes();
+        _terminate = null;
+        Changed    = 0;
+        _customize.Load(current);
+        _locked = locked;
+    }
+
+    // Set state for drawing of current customization.
+    private CustomizeIndex _currentIndex;
+    private CustomizeFlag  _currentFlag;
+    private CustomizeValue _currentByte = CustomizeValue.Zero;
+    private int            _currentCount;
+    private string         _currentOption = string.Empty;
+
+    // Prepare a new customization option.
+    private ImRaii.Id SetId(CustomizeIndex index)
+    {
+        _currentIndex  = index;
+        _currentFlag   = index.ToFlag();
+        _currentByte   = _customize[index];
+        _currentCount  = _set.Count(index, _customize.Face);
+        _currentOption = _set.Option(index);
+        return ImRaii.PushId((int)index);
+    }
+
+    // Update the current id with a new value.
+    private void UpdateValue(CustomizeValue value)
+    {
+        if (_currentByte == value)
+            return;
+
+        _customize[_currentIndex] =  value;
+        Changed                   |= _currentFlag;
+    }
+
+    private bool DrawInternal()
+    {
+        using var disabled = ImRaii.Disabled(_locked);
+
+        try
+        {
+            DrawRaceGenderSelector();
+            _set = _service.AwaitedService.GetList(_customize.Clan, _customize.Gender);
+
+            foreach (var id in _set.Order[CharaMakeParams.MenuType.Percentage])
+                PercentageSelector(id);
+
+            Functions.IteratePairwise(_set.Order[CharaMakeParams.MenuType.IconSelector], DrawIconSelector, ImGui.SameLine);
+
+            DrawMultiIconSelector();
+
+            foreach (var id in _set.Order[CharaMakeParams.MenuType.ListSelector])
+                DrawListSelector(id);
+
+            Functions.IteratePairwise(_set.Order[CharaMakeParams.MenuType.ColorPicker], DrawColorPicker, ImGui.SameLine);
+
+            Functions.IteratePairwise(_set.Order[CharaMakeParams.MenuType.Checkmark], DrawCheckbox,
+                () => ImGui.SameLine(_inputIntSize + _framedIconSize.X + 3 * ImGui.GetStyle().ItemSpacing.X));
+            return Changed != 0;
+        }
+        catch (Exception ex)
+        {
+            _terminate = ex;
+            using var color = ImRaii.PushColor(ImGuiCol.Text, 0xFF4040FF);
+            ImGui.NewLine();
+            ImGuiUtil.TextWrapped(_terminate.ToString());
+            return false;
+        }
+    }
+
+    private void UpdateSizes()
+    {
+        _iconSize          = new Vector2(ImGui.GetTextLineHeightWithSpacing() * 2);
+        _framedIconSize    = _iconSize + 2 * ImGui.GetStyle().FramePadding;
+        _inputIntSize      = 2 * _framedIconSize.X + ImGui.GetStyle().ItemSpacing.X;
+        _comboSelectorSize = 4 * _framedIconSize.X + 3 * ImGui.GetStyle().ItemSpacing.X;
+        _raceSelectorWidth = _inputIntSize + _comboSelectorSize - _framedIconSize.X;
+    }
+
+    private static ImGuiScene.TextureWrap? GetLegacyTattooIcon(DalamudPluginInterface pi)
+    {
+        using var resource = Assembly.GetExecutingAssembly().GetManifestResourceStream("Glamourer.LegacyTattoo.raw");
+        if (resource == null)
+            return null;
+
+        var rawImage = new byte[resource.Length];
+        var length   = resource.Read(rawImage, 0, (int)resource.Length);
+        return length == resource.Length
+            ? pi.UiBuilder.LoadImageRaw(rawImage, 192, 192, 4)
+            : null;
+    }
+}