Suggested code for multiple fonts support

[NustyFrozen]

Overlay.cs:

Removed:

        private ushort[]? fontCustomGlyphRange;
        private string fontPathName;
        private float fontSize;
        private FontGlyphRangeType fontLanguage;


public bool ReplaceFont(string pathName, int size, FontGlyphRangeType language)
        {
            if (!File.Exists(pathName))
            {
                return false;
            }

            this.fontPathName = pathName;
            this.fontSize = size;
            this.fontLanguage = language;
            this.replaceFont = true;
            this.fontCustomGlyphRange = null;
            return true;
        }

private void ReplaceFontIfRequired()
        {
            if (this.replaceFont && this.renderer != null)
            {
                this.renderer.UpdateFontTexture(this.fontPathName, this.fontSize, this.fontCustomGlyphRange, this.fontLanguage);
                fontt = ImGuiRenderer.font;
                this.replaceFont = false;
            }
        }

added:

private Dictionary<string, Tuple<string, float, FontGlyphRangeType, ushort[]>> Fonts;

public bool InitializeFonts(Dictionary<string,Tuple<string, float, FontGlyphRangeType, ushort[]>> Fonts)
        {
            foreach(KeyValuePair<string, Tuple<string, float, FontGlyphRangeType, ushort[]>> font in Fonts)
            if (!File.Exists(font.Value.Item1))
            {
                return false;
            }
            this.Fonts = Fonts;
            this.replaceFont = true;
            return true;
        }

private void ReplaceFontIfRequired()
        {
            if (this.replaceFont && this.renderer != null)
            {
                this.renderer.UpdateFontTexture(Fonts);
                this.replaceFont = false;
            }
        }

  public ImFontPtr getFontByLabel(string label)
        {
            ImFontPtr font = new ImFontPtr();
            if(renderer.getFontDictionary().TryGetValue(label,out font))
            {
                return font;
            }
            return ImGui.GetIO().FontDefault;
        }

ImGuiRenderer.cs

Added:

Dictionary<string, ImFontPtr> Fonts = new();

public Dictionary<string, ImFontPtr> getFontDictionary()
        {
            return this.Fonts;
        }

public void UpdateFontTexture(Dictionary<string, Tuple<string, float, FontGlyphRangeType, ushort[]>> Fonts)
        {
            var io = ImGui.GetIO();
            this.DeRegisterTexture(io.Fonts.TexID)?.Dispose();
            io.Fonts.Clear();
            this.Fonts.Clear();
            var config = ImGuiNative.ImFontConfig_ImFontConfig();
            foreach (KeyValuePair<string, Tuple<string, float, FontGlyphRangeType, ushort[]>> item in Fonts)
            {
                var fontPathName = item.Value.Item1;
                var fontSize = item.Value.Item2;
                var fontLanguage = item.Value.Item3;
                var fontCustomGlyphRange = item.Value.Item4;
                ImFontPtr fontPtr = null;
                if (fontCustomGlyphRange == null)
                {
                    switch (fontLanguage)
                    {
                        case FontGlyphRangeType.English:
                            fontPtr = io.Fonts.AddFontFromFileTTF(fontPathName, fontSize, config, io.Fonts.GetGlyphRangesDefault());
                            break;
                        case FontGlyphRangeType.ChineseSimplifiedCommon:
                            fontPtr = io.Fonts.AddFontFromFileTTF(fontPathName, fontSize, config, io.Fonts.GetGlyphRangesChineseSimplifiedCommon());
                            break;
                        case FontGlyphRangeType.ChineseFull:
                            fontPtr = io.Fonts.AddFontFromFileTTF(fontPathName, fontSize, config, io.Fonts.GetGlyphRangesChineseFull());
                            break;
                        case FontGlyphRangeType.Japanese:
                            fontPtr = io.Fonts.AddFontFromFileTTF(fontPathName, fontSize, config, io.Fonts.GetGlyphRangesJapanese());
                            break;
                        case FontGlyphRangeType.Korean:
                            fontPtr = io.Fonts.AddFontFromFileTTF(fontPathName, fontSize, config, io.Fonts.GetGlyphRangesKorean());
                            break;
                        case FontGlyphRangeType.Thai:
                            fontPtr = io.Fonts.AddFontFromFileTTF(fontPathName, fontSize, config, io.Fonts.GetGlyphRangesThai());
                            break;
                        case FontGlyphRangeType.Vietnamese:
                            fontPtr = io.Fonts.AddFontFromFileTTF(fontPathName, fontSize, config, io.Fonts.GetGlyphRangesVietnamese());
                            break;
                        case FontGlyphRangeType.Cyrillic:
                            fontPtr = io.Fonts.AddFontFromFileTTF(fontPathName, fontSize, config, io.Fonts.GetGlyphRangesCyrillic());
                            break;
                        default:
                            throw new Exception($"Font Glyph Range (${fontLanguage}) is not supported.");
                    }
                }
                else
                {
                    //for something like icon fonts require merge so normal text will be normal
                    ImFontConfigPtr iconCfg = ImGuiNative.ImFontConfig_ImFontConfig();
                    iconCfg.MergeMode = true;
                    iconCfg.PixelSnapH = true;
                    GCHandle rangeHandle = GCHandle.Alloc(fontCustomGlyphRange, GCHandleType.Pinned);
                        fontPtr = io.Fonts.AddFontFromFileTTF(fontPathName, fontSize, iconCfg, rangeHandle.AddrOfPinnedObject());
                }
                this.Fonts.Add(item.Key, fontPtr);
            }
            this.CreateFontsTexture();
            ImGuiNative.ImFontConfig_destroy(config);
        }

Usage:

var dictionary = new Dictionary<string, Tuple<string, float, FontGlyphRangeType, ushort[]>>();
            dictionary.Add("MyFirstFont", new Tuple<string, float, FontGlyphRangeType, ushort[]>(@"Segoe.ttf", 24, FontGlyphRangeType.English, null));
            dictionary.Add("MySecondFont", new Tuple<string, float, FontGlyphRangeType, ushort[]>(@"Poppins.ttf", 18, FontGlyphRangeType.English, null));
            dictionary.Add("IconFont", new Tuple<string, float, FontGlyphRangeType, ushort[]>(@"fa-regular-400.ttf", 18, FontGlyphRangeType.English, new ushort[] { 0xe005,
            0xf8ff,0}));
            this.InitializeFonts(dictionary);
            ImGui.PushFont(getFontByLabel("MyFirstFont"));
            ImGui.Text("I am using my first font");
            ImGui.PopFont();
            ImGui.PushFont(getFontByLabel("MySecondFont"));
            ImGui.Text("I am using my second font");
            ImGui.PopFont();
            ImGui.PushFont(getFontByLabel("IconFont"));
            ImGui.Text("Book:" + "\uf2b9");
            ImGui.PopFont();

something to notice is that it takes 1 frame to add the fonts since RunInfiniteLoop calls ReplaceFontIfRequired after rendering
so if you call InitializeFonts in render you'll need to account for it that the first time after calling this.getFontByLabel("Font") == ImGui.GetIO().FontDefault

[zaafar]

this is now completed.