Implementing viewport functionality into ImGui.NET

.gitignore

@@ -259,4 +259,7 @@ Session.vim
 .idea
 
 # download dir
-deps/
+deps/
+
+# VS Launch
+launchSettings.json

README.md

@@ -29,5 +29,5 @@ https://github.com/ocornut/imgui
 
 See the [official screenshot thread](https://github.com/ocornut/imgui/issues/123) for examples of many different kinds of interfaces created with Dear ImGui.
 
-https://github.com/Extrawurst/cimgui
+https://github.com/cimgui/cimgui
 > This is a thin c-api wrapper for the excellent C++ intermediate gui imgui. This library is intended as a intermediate layer to be able to use imgui from other languages that can interface with C .

src/CodeGenerator/CodeGenerator.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -8,6 +8,7 @@
   <ItemGroup>
     <Content Include="structs_and_enums.json" CopyToOutputDirectory="PreserveNewest" />
     <Content Include="definitions.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="variants.json" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
   <ItemGroup>

src/CodeGenerator/Program.cs

@@ -10,7 +10,7 @@
 
 namespace CodeGenerator
 {
-    class Program
+    internal static class Program
     {
         private static readonly Dictionary<string, string> s_wellKnownTypes = new Dictionary<string, string>()
         {
@@ -56,7 +56,7 @@ class Program
             "ImVector",
             "ImVec2",
             "ImVec4",
-            "Pair",
+            "ImGuiStoragePair",
         };
 
         private static readonly Dictionary<string, string> s_wellKnownDefaultValues = new Dictionary<string, string>()
@@ -70,8 +70,9 @@ class Program
             { "ImVec2(0,1)", "new Vector2(0, 1)" },
             { "ImVec4(0,0,0,0)", "new Vector4()" },
             { "ImVec4(1,1,1,1)", "new Vector4(1, 1, 1, 1)" },
-            { "ImDrawCornerFlags_All", "(int)ImDrawCornerFlags.All" },
+            { "ImDrawCornerFlags_All", "ImDrawCornerFlags.All" },
             { "FLT_MAX", "float.MaxValue" },
+            { "(((ImU32)(255)<<24)|((ImU32)(255)<<16)|((ImU32)(255)<<8)|((ImU32)(255)<<0))", "0xFFFFFFFF" }
         };
 
         private static readonly Dictionary<string, string> s_identifierReplacements = new Dictionary<string, string>()
@@ -129,6 +130,27 @@ static void Main(string[] args)
                 functionsJson = JObject.Load(jr);
             }
 
+            JObject variantsJson = null;
+            if (File.Exists(Path.Combine(AppContext.BaseDirectory, "variants.json")))
+            {
+                using (StreamReader fs = File.OpenText(Path.Combine(AppContext.BaseDirectory, "variants.json")))
+                using (JsonTextReader jr = new JsonTextReader(fs))
+                {
+                    variantsJson = JObject.Load(jr);
+                }
+            }
+
+            Dictionary<string, MethodVariant> variants = new Dictionary<string, MethodVariant>();
+            foreach (var jt in variantsJson.Children())
+            {
+                JProperty jp = (JProperty)jt;
+                ParameterVariant[] methodVariants = jp.Values().Select(jv =>
+                {
+                    return new ParameterVariant(jv["name"].ToString(), jv["type"].ToString(), jv["variants"].Select(s => s.ToString()).ToArray());
+                }).ToArray();
+                variants.Add(jp.Name, new MethodVariant(jp.Name, methodVariants));
+            }
+
             EnumDefinition[] enums = typesJson["enums"].Select(jt =>
             {
                 JProperty jp = (JProperty)jt;
@@ -168,6 +190,10 @@ static void Main(string[] args)
                     string ov_cimguiname = val["ov_cimguiname"]?.ToString();
                     string cimguiname = val["cimguiname"].ToString();
                     string friendlyName = val["funcname"]?.ToString();
+                    if (cimguiname.EndsWith("_destroy"))
+                    {
+                        friendlyName = "Destroy";
+                    }
                     if (friendlyName == null) { return null; }
 
                     string exportedName = ov_cimguiname;
@@ -190,11 +216,20 @@ static void Main(string[] args)
 
                     List<TypeReference> parameters = new List<TypeReference>();
 
+                    // find any variants that can be applied to the parameters of this method based on the method name
+                    MethodVariant methodVariants = null;
+                    variants.TryGetValue(jp.Name, out methodVariants);
+
                     foreach (JToken p in val["argsT"])
                     {
                         string pType = p["type"].ToString();
                         string pName = p["name"].ToString();
-                        parameters.Add(new TypeReference(pName, pType, enums));
+
+                        // if there are possible variants for this method then try to match them based on the parameter name and expected type
+                        ParameterVariant matchingVariant = methodVariants?.Parameters.Where(pv => pv.Name == pName && pv.OriginalType == pType).FirstOrDefault() ?? null;
+                        if (matchingVariant != null) matchingVariant.Used = true;
+
+                        parameters.Add(new TypeReference(pName, pType, enums, matchingVariant?.VariantTypes));
                     }
 
                     Dictionary<string, string> defaultValues = new Dictionary<string, string>();
@@ -207,6 +242,12 @@ static void Main(string[] args)
                     string comment = null;
 
                     string structName = val["stname"].ToString();
+                    bool isConstructor = val.Value<bool>("constructor");
+                    bool isDestructor = val.Value<bool>("destructor");
+                    if (isConstructor)
+                    {
+                        returnType = structName + "*";
+                    }
 
                     return new OverloadDefinition(
                         exportedName,
@@ -216,10 +257,11 @@ static void Main(string[] args)
                         returnType,
                         structName,
                         comment,
-                        enums);
+                        isConstructor,
+                        isDestructor);
                 }).Where(od => od != null).ToArray();
 
-                return new FunctionDefinition(name, overloads);
+                return new FunctionDefinition(name, overloads, enums);
             }).OrderBy(fd => fd.Name).ToArray();
 
             foreach (EnumDefinition ed in enums)
@@ -361,8 +403,10 @@ static void Main(string[] args)
                                 continue;
                             }
 
-                            if (overload.FriendlyName == overload.StructName)
+                            if (overload.IsConstructor)
                             {
+                                // TODO: Emit a static function on the type that invokes the native constructor.
+                                // Also, add a "Dispose" function or similar.
                                 continue;
                             }
 
@@ -423,6 +467,7 @@ static void Main(string[] args)
                     {
                         string exportedName = overload.ExportedName;
                         if (exportedName.Contains("~")) { continue; }
+                        if (exportedName.Contains("ImVector_")) { continue; }
                         if (overload.Parameters.Any(tr => tr.Type.Contains('('))) { continue; } // TODO: Parse function pointer parameters.
 
                         string ret = GetTypeString(overload.ReturnType, false);
@@ -530,6 +575,14 @@ static void Main(string[] args)
                 writer.PopBlock();
                 writer.PopBlock();
             }
+
+            foreach (var method in variants)
+            {
+                foreach (var variant in method.Value.Parameters)
+                {
+                    if (!variant.Used) Console.WriteLine($"Error: Variants targetting parameter {variant.Name} with type {variant.OriginalType} could not be applied to method {method.Key}.");
+                }
+            }
         }
 
         private static bool IsStringFieldName(string name)
@@ -636,7 +689,7 @@ private static void EmitOverload(
                         preCallLines.Add($"    }}");
                         preCallLines.Add($"    int {nativeArgName}_offset = Util.GetUtf8({textToEncode}, {nativeArgName}, {correctedIdentifier}_byteCount);");
                         preCallLines.Add($"    {nativeArgName}[{nativeArgName}_offset] = 0;");
-                        
+
                         if (!hasDefault)
                         {
                             preCallLines.Add("}");
@@ -948,6 +1001,38 @@ private static string CorrectIdentifier(string identifier)
         }
     }
 
+    class MethodVariant
+    {
+        public string Name { get; }
+
+        public ParameterVariant[] Parameters { get; }
+
+        public MethodVariant(string name, ParameterVariant[] parameters)
+        {
+            Name = name;
+            Parameters = parameters;
+        }
+    }
+
+    class ParameterVariant
+    {
+        public string Name { get; }
+
+        public string OriginalType { get; }
+
+        public string[] VariantTypes { get; }
+
+        public bool Used { get; set; }
+
+        public ParameterVariant(string name, string originalType, string[] variantTypes)
+        {
+            Name = name;
+            OriginalType = originalType;
+            VariantTypes = variantTypes;
+            Used = false;
+        }
+    }
+
     class EnumDefinition
     {
         private readonly Dictionary<string, string> _sanitizedNames;
@@ -1034,11 +1119,18 @@ class TypeReference
         public string TemplateType { get; }
         public int ArraySize { get; }
         public bool IsFunctionPointer { get; }
+        public string[] TypeVariants { get; }
 
         public TypeReference(string name, string type, EnumDefinition[] enums)
-            : this(name, type, null, enums) { }
+            : this(name, type, null, enums, null) { }
+
+        public TypeReference(string name, string type, EnumDefinition[] enums, string[] typeVariants)
+            : this(name, type, null, enums, typeVariants) { }
 
         public TypeReference(string name, string type, string templateType, EnumDefinition[] enums)
+            : this(name, type, templateType, enums, null) { }
+
+        public TypeReference(string name, string type, string templateType, EnumDefinition[] enums, string[] typeVariants)
         {
             Name = name;
             Type = type.Replace("const", string.Empty).Trim();
@@ -1067,6 +1159,8 @@ public TypeReference(string name, string type, string templateType, EnumDefiniti
             }
 
             IsFunctionPointer = Type.IndexOf('(') != -1;
+
+            TypeVariants = typeVariants;
         }
 
         private int ParseSizeString(string sizePart, EnumDefinition[] enums)
@@ -1102,17 +1196,76 @@ private int ParseSizeString(string sizePart, EnumDefinition[] enums)
 
             return ret;
         }
+
+        public TypeReference WithVariant(int variantIndex, EnumDefinition[] enums)
+        {
+            if (variantIndex == 0) return this;
+            else return new TypeReference(Name, TypeVariants[variantIndex - 1], TemplateType, enums);
+        }
     }
 
     class FunctionDefinition
     {
         public string Name { get; }
         public OverloadDefinition[] Overloads { get; }
 
-        public FunctionDefinition(string name, OverloadDefinition[] overloads)
+        public FunctionDefinition(string name, OverloadDefinition[] overloads, EnumDefinition[] enums)
         {
             Name = name;
-            Overloads = overloads;
+            Overloads = ExpandOverloadVariants(overloads, enums);
+        }
+
+        private OverloadDefinition[] ExpandOverloadVariants(OverloadDefinition[] overloads, EnumDefinition[] enums)
+        {
+            List<OverloadDefinition> newDefinitions = new List<OverloadDefinition>();
+
+            foreach (OverloadDefinition overload in overloads)
+            {
+                bool hasVariants = false;
+                int[] variantCounts = new int[overload.Parameters.Length];
+
+                for (int i = 0; i < overload.Parameters.Length; i++)
+                {
+                    if (overload.Parameters[i].TypeVariants != null)
+                    {
+                        hasVariants = true;
+                        variantCounts[i] = overload.Parameters[i].TypeVariants.Length + 1;
+                    }
+                    else
+                    {
+                        variantCounts[i] = 1;
+                    }
+                }
+
+                if (hasVariants)
+                {
+                    int totalVariants = variantCounts[0];
+                    for (int i = 1; i < variantCounts.Length; i++) totalVariants *= variantCounts[i];
+
+                    for (int i = 0; i < totalVariants; i++)
+                    {
+                        TypeReference[] parameters = new TypeReference[overload.Parameters.Length];
+                        int div = 1;
+
+                        for (int j = 0; j < parameters.Length; j++)
+                        {
+                            int k = (i / div) % variantCounts[j];
+
+                            parameters[j] = overload.Parameters[j].WithVariant(k, enums);
+
+                            if (j > 0) div *= variantCounts[j];
+                        }
+
+                        newDefinitions.Add(overload.WithParameters(parameters));
+                    }
+                }
+                else
+                {
+                    newDefinitions.Add(overload);
+                }
+            }
+
+            return newDefinitions.ToArray();
         }
     }
 
@@ -1126,6 +1279,8 @@ class OverloadDefinition
         public string StructName { get; }
         public bool IsMemberFunction { get; }
         public string Comment { get; }
+        public bool IsConstructor { get; }
+        public bool IsDestructor { get; }
 
         public OverloadDefinition(
             string exportedName,
@@ -1135,16 +1290,24 @@ public OverloadDefinition(
             string returnType,
             string structName,
             string comment,
-            EnumDefinition[] enums)
+            bool isConstructor,
+            bool isDestructor)
         {
             ExportedName = exportedName;
             FriendlyName = friendlyName;
             Parameters = parameters;
             DefaultValues = defaultValues;
             ReturnType = returnType.Replace("const", string.Empty).Replace("inline", string.Empty).Trim();
             StructName = structName;
-            IsMemberFunction = structName != "ImGui";
+            IsMemberFunction = !string.IsNullOrEmpty(structName);
             Comment = comment;
+            IsConstructor = isConstructor;
+            IsDestructor = isDestructor;
+        }
+
+        public OverloadDefinition WithParameters(TypeReference[] parameters)
+        {
+            return new OverloadDefinition(ExportedName, FriendlyName, parameters, DefaultValues, ReturnType, StructName, Comment, IsConstructor, IsDestructor);
         }
     }