Godot4 c# Support through C# Bindings for GDMP.GDExtension

[GeorgeS2019]

I search for GDExtension using c#, it would be interesting to check if this is possible :-)

Update 5th June 2023

Possible to create C# binding for GDExtension?

Given an Addon: Addon1 with Addon1.gdextension with windows binary: addons/Addon1/libs/x86_64/Addon1.dll

In this project Addon1 = GDMP

• GDMP.gdextension
• addons/GDMP/libs/x86_64/GDMP.dll

Here are the possible steps => WIP

[j20001970]

According to official Godot's article about C# on 4.0, it would be possible to use API provided by GDExtension in future 4.x releases.

Consuming APIs provided by a GDExtension is also currently unsupported. We’ll keep working on bridging the gap between GDExtension and C# in future 4.x releases.

If using GDMP on C# is really a high-demand use case, the best we can do currently is to provide glue code between C# and GDScript AFAIK, which plugin users can easily write one when needed. From my standpoint, I would rather waiting for Godot(heh) to provide some sort of support for using GDExtension API on C#, instead of maintaining such glue.

[j20001970]

@j20001970 Please read

* https://github.com/godotengine/godot-docs/pull/6740/files

* [PR](https://github.com/godotengine/godot/pull/72619#issuecomment-1567124861)

If I understand this PR correctly, it is about allowing C# classes to be registered as global classes (similar to Autoload in GDScript), not using GDExtension classes in C#

[GeorgeS2019]

@j20001970
The next step is to figure out how to generate Addon1.GDExtension.json in a format that can be consumed by the existing Binding Generator into GDExtension C# Binding for Addon1.GDExtension

Once this is done, provide an Addon => GDExtensionCS for provider of c++ GDExtension to contribute the C# binding version to Nuget.

[GeorgeS2019]

@j20001970
I have gone through your latest demo. Excellent.

I revisit GDExtension C# Binding as for .NET users, your demo is the MOST promising for .NET users open to non-Unity like Mediapipe.NET

I have preliminary tested. it is possible to use Classdb to extract all methods, properties exposed by e.g. GDMP.dll to create GDMPSharp.GDExtension.json

==> The next step is to figure out What is the right json format that can be ingested by Godot SourceCodeGenerator. There are a few versions out there, not sure what are the differences with respect to the official one.

Then use Godot Csharp SourceCodeGenerator or BindingGenerator to create the wrapper (Native interoperability c# class)

Interested your view if my understanding is correct.

While the technology is still in beta for this release, GDExtension is now even closer to GDScript and C# in terms of scripting capabilities.
https://godotengine.org/article/godot-4-1-is-here/#gdextension

@dsnopek <= could you share your latest information for the GDExtension C# Binding?

[dsnopek]

@dsnopek <= could you share your latest information for the GDExtension C# Binding?

Unfortunately, I have no information to share. I'm on the GDExtension team working on GDExtension itself and the godot-cpp binding, but I'm not aware of an active effort to make a C# binding. If someone is working on that, it'd be great for them to come over the #gdextension channel on RocketChat or one of the GDExtension meetings!

[GeorgeS2019]

@j20001970
@dsnopek

NativeStructs and Pointers in C#

Add NativeStructs and Pointers in C# for GDExtension interoperability

Please check if the latest PR (involving the use of Global Class) could lead to C# and GDExtension interoperability

AudioStreamPlaybackMyTone

using Godot;
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

[GlobalClass]
public partial class AudioStreamPlaybackMyTone : AudioStreamPlayback
{
    public const int MIX_FRAC_BITS = 13;
    public const int MIX_FRAC_LEN = (1 << MIX_FRAC_BITS);
    public const int MIX_FRAC_MASK = MIX_FRAC_LEN - 1;

    public AudioStreamMyTone parrent;
    bool active;

    public unsafe override void _Start(double fromPos)
    {
        _Seek(fromPos);
        active = true;
    }

    public override void _Stop()
    {
        active = false;
        parrent.Reset();
    }

    public override bool _IsPlaying()
    {
        return active;
    }

    public override int _GetLoopCount()
    {
        return 0;
    }

    public override double _GetPlaybackPosition()
    {
        return 0.0;
    }

    public override void _Seek(double position)
    {
        if (position < 0)
        {
            position = 0;
        }
        parrent.SetPosition((long)(position * parrent.mix_rate) << MIX_FRAC_BITS);
    }

    public unsafe override int _Mix(ref AudioFrame buffer, float rateScale, int frames)
    {
        var p_buffer = (AudioFrame*)Unsafe.AsPointer(ref buffer);
        if (!active)
        {
            return 0;
        }


        for (int i = 0; i < frames; i++)
        {
            float sample = (float)Math.Sin(2.0 * Math.PI * (((double)(parrent.pos + i)) / (((double)(parrent.mix_rate)) / ((double)(parrent.hz)))));
            p_buffer[i] = new AudioFrame { Left = sample, Right = sample };
        }
        parrent.pos += frames;

        return frames;
    }

}

AudioStreamMyTone

using Godot;
using System;

[GlobalClass]
public partial class AudioStreamMyTone : AudioStream
{
    public long pos;
    public int mix_rate = 44100;
    public bool stereo = false;
    [Export]
    public double hz = 639;

    public void Reset()
    {
        SetPosition(0);
    }
    public void SetPosition(long p)
    {
        pos = p;
    }
    public override AudioStreamPlayback _InstantiatePlayback()
    {
        return new AudioStreamPlaybackMyTone() { 
            parrent = this
        };
    }

    public override string _GetStreamName()
    {
        return "MyTone";
    }

    public override double _GetLength()
    {
        return 0;
    }
}

[GeorgeS2019]

@j20001970

GDextension for C#

Using GodotObject.Call, Set, Get

DmitriySalnikov/godot_debug_draw_3d#10 (comment)

[j20001970]

Add NativeStructs and Pointers in C# for GDExtension interoperability

If I understand this correctly, this proposal is for interoperability between C# and GDExtension interface itself.

GDMP is a set of classes registered to Godot through GDExtension, in order to use them in C#, some work need to be done on generating C# source code for registered GDExtension classes, that is, interoperability between C# and custom classes registered through GDExtension.

Sorry if I didn't clarify in the previous comments, hope this will help you understand the situation better.

[GeorgeS2019]

@j20001970

I am updating you the thinking progress of getting GDMP to eventually work for c# in addition to GDScript.

Once the GDMP GDExtension is loaded. It is possible to use c# to load the custom classes registered through the GDMP GDExtension.

Manual way

By using ClassDB in c#, it is possible to list all properties and methods from these GDMP custom classes

By using [Method] GodotObject.Call , [Properties] GodotObject.Set, GodotObject.Get, it is possible to manually write c# wrappers to have access to the properties and methods exposed by the custom classes

https://github.com/DmitriySalnikov/godot_debug_draw_3

Future Automated way

I will wait for the official generator for GDExtension <=> C#

Ideal proposal

Define the User experience on how to "Officially" generate the nuget of the GDExtension C# wrappers

Godot 4.2 dev4 has many fixes to support the GDExtension proposal (for other languages other than GDScript and c++). I am updating you so you are aware the progress.

[GeorgeS2019]

@j20001970
@dsnopek

DmitriySalnikov/godot_debug_draw_3d#10
How to add a menu item to generate GDExtension C# Bindings within the distributed c++ GDExtension

[GeorgeS2019]

Generated GDExtension C# Bindings

/// 1.2.0
/// ////////////////////////////////////////////////
/// THIS FILE HAS BEEN GENERATED.
/// THE CHANGES IN THIS FILE WILL BE OVERWRITTEN
/// AFTER THE UPDATE OR AFTER THE RESTART!
/// ////////////////////////////////////////////////

using Godot;
using System;

static internal class DebugDraw2D
{
    private static GodotObject _instance;
    public static GodotObject Instance
    {
        get
        {
            if (!GodotObject.IsInstanceValid(_instance))
            {
                _instance = Engine.GetSingleton("DebugDraw2D");
            }
            return _instance;
        }
    }
    
    private static readonly StringName __set_empty_color = "set_empty_color";
    private static readonly StringName __get_empty_color = "get_empty_color";
    private static readonly StringName __set_debug_enabled = "set_debug_enabled";
    private static readonly StringName __is_debug_enabled = "is_debug_enabled";
    private static readonly StringName __set_config = "set_config";
    private static readonly StringName __get_config = "get_config";
    private static readonly StringName __set_custom_canvas = "set_custom_canvas";
    private static readonly StringName __get_custom_canvas = "get_custom_canvas";
    private static readonly StringName __clear_2d_objects = "clear_2d_objects";
    private static readonly StringName __begin_text_group = "begin_text_group";
    private static readonly StringName __end_text_group = "end_text_group";
    private static readonly StringName __set_text = "set_text";
    private static readonly StringName __create_graph = "create_graph";
    private static readonly StringName __create_fps_graph = "create_fps_graph";
    private static readonly StringName __graph_update_data = "graph_update_data";
    private static readonly StringName __remove_graph = "remove_graph";
    private static readonly StringName __clear_graphs = "clear_graphs";
    private static readonly StringName __get_graph = "get_graph";
    private static readonly StringName __get_graph_names = "get_graph_names";
    private static readonly StringName __get_render_stats = "get_render_stats";
    
    private static void prop_SetEmptyColor(Color value)
    {
        Instance?.Call(__set_empty_color, value);
    }
    
    private static Color prop_GetEmptyColor()
    {
        return (Color)(Instance?.Call(__get_empty_color));
    }
    
    private static void prop_SetDebugEnabled(bool value)
    {
        Instance?.Call(__set_debug_enabled, value);
    }
    
    private static bool prop_IsDebugEnabled()
    {
        return (bool)(Instance?.Call(__is_debug_enabled));
    }
    
    private static void prop_SetConfig(DebugDrawConfig2D value)
    {
        Instance?.Call(__set_config, value.Instance);
    }
    
    private static DebugDrawConfig2D prop_GetConfig()
    {
        return (DebugDrawConfig2D)_DebugDrawUtils_.CreateWrapperFromObject((GodotObject)Instance?.Call(__get_config));
    }
    
    private static void prop_SetCustomCanvas(Control value)
    {
        Instance?.Call(__set_custom_canvas, value);
    }
    
    private static Control prop_GetCustomCanvas()
    {
        return (Control)(Instance?.Call(__get_custom_canvas));
    }
    
    public static void Clear2dObjects()
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__clear_2d_objects);
#endif
    }
    
    public static void BeginTextGroup(string group_title, int group_priority = 0, Color? group_color = null, bool show_title = true, int title_size = -1, int text_size = -1)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__begin_text_group, group_title, group_priority, group_color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, show_title, title_size, text_size);
#endif
    }
    
    public static void EndTextGroup()
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__end_text_group);
#endif
    }
    
    public static void SetText(string key, Variant value = default, int priority = 0, Color? color_of_value = null, float duration = -1f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__set_text, key, value, priority, color_of_value ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static DebugDrawGraph CreateGraph(StringName title)
    {
#if DEBUG || FORCED_DD3D
        return (DebugDrawGraph)_DebugDrawUtils_.CreateWrapperFromObject((GodotObject)Instance?.Call(__create_graph, title));
#else
        return default;
#endif
    }
    
    public static DebugDrawGraph CreateFpsGraph(StringName title)
    {
#if DEBUG || FORCED_DD3D
        return (DebugDrawGraph)_DebugDrawUtils_.CreateWrapperFromObject((GodotObject)Instance?.Call(__create_fps_graph, title));
#else
        return default;
#endif
    }
    
    public static void GraphUpdateData(StringName title, float data)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__graph_update_data, title, data);
#endif
    }
    
    public static void RemoveGraph(StringName title)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__remove_graph, title);
#endif
    }
    
    public static void ClearGraphs()
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__clear_graphs);
#endif
    }
    
    public static DebugDrawGraph GetGraph(StringName title)
    {
#if DEBUG || FORCED_DD3D
        return (DebugDrawGraph)_DebugDrawUtils_.CreateWrapperFromObject((GodotObject)Instance?.Call(__get_graph, title));
#else
        return default;
#endif
    }
    
    public static string[] GetGraphNames()
    {
#if DEBUG || FORCED_DD3D
        return (string[])(Instance?.Call(__get_graph_names));
#else
        return default;
#endif
    }
    
    public static DebugDrawStats2D GetRenderStats()
    {
#if DEBUG || FORCED_DD3D
        return (DebugDrawStats2D)_DebugDrawUtils_.CreateWrapperFromObject((GodotObject)Instance?.Call(__get_render_stats));
#else
        return default;
#endif
    }
    
    public static Color EmptyColor
    {
        get => prop_GetEmptyColor();
        set => prop_SetEmptyColor(value);
    }
    
    public static bool DebugEnabled
    {
        get => prop_IsDebugEnabled();
        set => prop_SetDebugEnabled(value);
    }
    
    public static DebugDrawConfig2D Config
    {
        get => prop_GetConfig();
        set => prop_SetConfig(value);
    }
    
    public static Control CustomCanvas
    {
        get => prop_GetCustomCanvas();
        set => prop_SetCustomCanvas(value);
    }
    
}

internal class DebugDrawStats2D : IDisposable
{
    public GodotObject Instance { get; private set; }
    public DebugDrawStats2D(GodotObject _instance)
    {
        if (_instance == null) throw new ArgumentNullException("_instance");
        if (!ClassDB.IsParentClass(_instance.GetClass(), GetType().Name)) throw new ArgumentException("\"_instance\" has the wrong type.");
        Instance = _instance;
    }
    
    public void Dispose()
    {
        Instance.Dispose();
        Instance = null;
    }
    
    public DebugDrawStats2D() : this((GodotObject)ClassDB.Instantiate("DebugDrawStats2D")) { }
    
    private static readonly StringName __get_instances = "get_instances";
    private static readonly StringName __set_instances = "set_instances";
    private static readonly StringName __get_lines = "get_lines";
    private static readonly StringName __set_lines = "set_lines";
    private static readonly StringName __get_total_geometry = "get_total_geometry";
    private static readonly StringName __set_total_geometry = "set_total_geometry";
    private static readonly StringName __get_visible_instances = "get_visible_instances";
    private static readonly StringName __set_visible_instances = "set_visible_instances";
    private static readonly StringName __get_visible_lines = "get_visible_lines";
    private static readonly StringName __set_visible_lines = "set_visible_lines";
    private static readonly StringName __get_total_visible = "get_total_visible";
    private static readonly StringName __set_total_visible = "set_total_visible";
    private static readonly StringName __get_time_filling_buffers_instances_usec = "get_time_filling_buffers_instances_usec";
    private static readonly StringName __set_time_filling_buffers_instances_usec = "set_time_filling_buffers_instances_usec";
    private static readonly StringName __get_time_filling_buffers_lines_usec = "get_time_filling_buffers_lines_usec";
    private static readonly StringName __set_time_filling_buffers_lines_usec = "set_time_filling_buffers_lines_usec";
    private static readonly StringName __get_total_time_filling_buffers_usec = "get_total_time_filling_buffers_usec";
    private static readonly StringName __set_total_time_filling_buffers_usec = "set_total_time_filling_buffers_usec";
    private static readonly StringName __get_time_culling_instant_usec = "get_time_culling_instant_usec";
    private static readonly StringName __set_time_culling_instant_usec = "set_time_culling_instant_usec";
    private static readonly StringName __get_time_culling_delayed_usec = "get_time_culling_delayed_usec";
    private static readonly StringName __set_time_culling_delayed_usec = "set_time_culling_delayed_usec";
    private static readonly StringName __get_total_time_culling_usec = "get_total_time_culling_usec";
    private static readonly StringName __set_total_time_culling_usec = "set_total_time_culling_usec";
    private static readonly StringName __get_total_time_spent_usec = "get_total_time_spent_usec";
    private static readonly StringName __set_total_time_spent_usec = "set_total_time_spent_usec";
    
    private int prop_GetInstances()
    {
        return (int)(Instance?.Call(__get_instances));
    }
    
    private void prop_SetInstances(int value)
    {
        Instance?.Call(__set_instances, value);
    }
    
    private int prop_GetLines()
    {
        return (int)(Instance?.Call(__get_lines));
    }
    
    private void prop_SetLines(int value)
    {
        Instance?.Call(__set_lines, value);
    }
    
    private int prop_GetTotalGeometry()
    {
        return (int)(Instance?.Call(__get_total_geometry));
    }
    
    private void prop_SetTotalGeometry(int value)
    {
        Instance?.Call(__set_total_geometry, value);
    }
    
    private int prop_GetVisibleInstances()
    {
        return (int)(Instance?.Call(__get_visible_instances));
    }
    
    private void prop_SetVisibleInstances(int value)
    {
        Instance?.Call(__set_visible_instances, value);
    }
    
    private int prop_GetVisibleLines()
    {
        return (int)(Instance?.Call(__get_visible_lines));
    }
    
    private void prop_SetVisibleLines(int value)
    {
        Instance?.Call(__set_visible_lines, value);
    }
    
    private int prop_GetTotalVisible()
    {
        return (int)(Instance?.Call(__get_total_visible));
    }
    
    private void prop_SetTotalVisible(int value)
    {
        Instance?.Call(__set_total_visible, value);
    }
    
    private int prop_GetTimeFillingBuffersInstancesUsec()
    {
        return (int)(Instance?.Call(__get_time_filling_buffers_instances_usec));
    }
    
    private void prop_SetTimeFillingBuffersInstancesUsec(int value)
    {
        Instance?.Call(__set_time_filling_buffers_instances_usec, value);
    }
    
    private int prop_GetTimeFillingBuffersLinesUsec()
    {
        return (int)(Instance?.Call(__get_time_filling_buffers_lines_usec));
    }
    
    private void prop_SetTimeFillingBuffersLinesUsec(int value)
    {
        Instance?.Call(__set_time_filling_buffers_lines_usec, value);
    }
    
    private int prop_GetTotalTimeFillingBuffersUsec()
    {
        return (int)(Instance?.Call(__get_total_time_filling_buffers_usec));
    }
    
    private void prop_SetTotalTimeFillingBuffersUsec(int value)
    {
        Instance?.Call(__set_total_time_filling_buffers_usec, value);
    }
    
    private int prop_GetTimeCullingInstantUsec()
    {
        return (int)(Instance?.Call(__get_time_culling_instant_usec));
    }
    
    private void prop_SetTimeCullingInstantUsec(int value)
    {
        Instance?.Call(__set_time_culling_instant_usec, value);
    }
    
    private int prop_GetTimeCullingDelayedUsec()
    {
        return (int)(Instance?.Call(__get_time_culling_delayed_usec));
    }
    
    private void prop_SetTimeCullingDelayedUsec(int value)
    {
        Instance?.Call(__set_time_culling_delayed_usec, value);
    }
    
    private int prop_GetTotalTimeCullingUsec()
    {
        return (int)(Instance?.Call(__get_total_time_culling_usec));
    }
    
    private void prop_SetTotalTimeCullingUsec(int value)
    {
        Instance?.Call(__set_total_time_culling_usec, value);
    }
    
    private int prop_GetTotalTimeSpentUsec()
    {
        return (int)(Instance?.Call(__get_total_time_spent_usec));
    }
    
    private void prop_SetTotalTimeSpentUsec(int value)
    {
        Instance?.Call(__set_total_time_spent_usec, value);
    }
    
    public int Instances
    {
        get => prop_GetInstances();
        set => prop_SetInstances(value);
    }
    
    public int Lines
    {
        get => prop_GetLines();
        set => prop_SetLines(value);
    }
    
    public int TotalGeometry
    {
        get => prop_GetTotalGeometry();
        set => prop_SetTotalGeometry(value);
    }
    
    public int VisibleInstances
    {
        get => prop_GetVisibleInstances();
        set => prop_SetVisibleInstances(value);
    }
    
    public int VisibleLines
    {
        get => prop_GetVisibleLines();
        set => prop_SetVisibleLines(value);
    }
    
    public int TotalVisible
    {
        get => prop_GetTotalVisible();
        set => prop_SetTotalVisible(value);
    }
    
    public int TimeFillingBuffersInstancesUsec
    {
        get => prop_GetTimeFillingBuffersInstancesUsec();
        set => prop_SetTimeFillingBuffersInstancesUsec(value);
    }
    
    public int TimeFillingBuffersLinesUsec
    {
        get => prop_GetTimeFillingBuffersLinesUsec();
        set => prop_SetTimeFillingBuffersLinesUsec(value);
    }
    
    public int TotalTimeFillingBuffersUsec
    {
        get => prop_GetTotalTimeFillingBuffersUsec();
        set => prop_SetTotalTimeFillingBuffersUsec(value);
    }
    
    public int TimeCullingInstantUsec
    {
        get => prop_GetTimeCullingInstantUsec();
        set => prop_SetTimeCullingInstantUsec(value);
    }
    
    public int TimeCullingDelayedUsec
    {
        get => prop_GetTimeCullingDelayedUsec();
        set => prop_SetTimeCullingDelayedUsec(value);
    }
    
    public int TotalTimeCullingUsec
    {
        get => prop_GetTotalTimeCullingUsec();
        set => prop_SetTotalTimeCullingUsec(value);
    }
    
    public int TotalTimeSpentUsec
    {
        get => prop_GetTotalTimeSpentUsec();
        set => prop_SetTotalTimeSpentUsec(value);
    }
    
}

internal class DebugDrawConfig2D : IDisposable
{
    public GodotObject Instance { get; private set; }
    public DebugDrawConfig2D(GodotObject _instance)
    {
        if (_instance == null) throw new ArgumentNullException("_instance");
        if (!ClassDB.IsParentClass(_instance.GetClass(), GetType().Name)) throw new ArgumentException("\"_instance\" has the wrong type.");
        Instance = _instance;
    }
    
    public void Dispose()
    {
        Instance.Dispose();
        Instance = null;
    }
    
    public DebugDrawConfig2D() : this((GodotObject)ClassDB.Instantiate("DebugDrawConfig2D")) { }
    
    public enum BlockPosition : long
    {
        LeftTop = 0,
        RightTop = 1,
        LeftBottom = 2,
        RightBottom = 3,
    }
    
    private static readonly StringName __set_graphs_base_offset = "set_graphs_base_offset";
    private static readonly StringName __get_graphs_base_offset = "get_graphs_base_offset";
    private static readonly StringName __set_text_block_position = "set_text_block_position";
    private static readonly StringName __get_text_block_position = "get_text_block_position";
    private static readonly StringName __set_text_block_offset = "set_text_block_offset";
    private static readonly StringName __get_text_block_offset = "get_text_block_offset";
    private static readonly StringName __set_text_padding = "set_text_padding";
    private static readonly StringName __get_text_padding = "get_text_padding";
    private static readonly StringName __set_text_default_duration = "set_text_default_duration";
    private static readonly StringName __get_text_default_duration = "get_text_default_duration";
    private static readonly StringName __set_text_default_size = "set_text_default_size";
    private static readonly StringName __get_text_default_size = "get_text_default_size";
    private static readonly StringName __set_text_foreground_color = "set_text_foreground_color";
    private static readonly StringName __get_text_foreground_color = "get_text_foreground_color";
    private static readonly StringName __set_text_background_color = "set_text_background_color";
    private static readonly StringName __get_text_background_color = "get_text_background_color";
    private static readonly StringName __set_text_custom_font = "set_text_custom_font";
    private static readonly StringName __get_text_custom_font = "get_text_custom_font";
    
    private void prop_SetGraphsBaseOffset(Vector2I value)
    {
        Instance?.Call(__set_graphs_base_offset, value);
    }
    
    private Vector2I prop_GetGraphsBaseOffset()
    {
        return (Vector2I)(Instance?.Call(__get_graphs_base_offset));
    }
    
    private void prop_SetTextBlockPosition(DebugDrawConfig2D.BlockPosition value)
    {
        Instance?.Call(__set_text_block_position, (long)value);
    }
    
    private DebugDrawConfig2D.BlockPosition prop_GetTextBlockPosition()
    {
        return (DebugDrawConfig2D.BlockPosition)((long)Instance?.Call(__get_text_block_position));
    }
    
    private void prop_SetTextBlockOffset(Vector2I value)
    {
        Instance?.Call(__set_text_block_offset, value);
    }
    
    private Vector2I prop_GetTextBlockOffset()
    {
        return (Vector2I)(Instance?.Call(__get_text_block_offset));
    }
    
    private void prop_SetTextPadding(Vector2I value)
    {
        Instance?.Call(__set_text_padding, value);
    }
    
    private Vector2I prop_GetTextPadding()
    {
        return (Vector2I)(Instance?.Call(__get_text_padding));
    }
    
    private void prop_SetTextDefaultDuration(float value)
    {
        Instance?.Call(__set_text_default_duration, value);
    }
    
    private float prop_GetTextDefaultDuration()
    {
        return (float)(Instance?.Call(__get_text_default_duration));
    }
    
    private void prop_SetTextDefaultSize(int value)
    {
        Instance?.Call(__set_text_default_size, value);
    }
    
    private int prop_GetTextDefaultSize()
    {
        return (int)(Instance?.Call(__get_text_default_size));
    }
    
    private void prop_SetTextForegroundColor(Color value)
    {
        Instance?.Call(__set_text_foreground_color, value);
    }
    
    private Color prop_GetTextForegroundColor()
    {
        return (Color)(Instance?.Call(__get_text_foreground_color));
    }
    
    private void prop_SetTextBackgroundColor(Color value)
    {
        Instance?.Call(__set_text_background_color, value);
    }
    
    private Color prop_GetTextBackgroundColor()
    {
        return (Color)(Instance?.Call(__get_text_background_color));
    }
    
    private void prop_SetTextCustomFont(Font value)
    {
        Instance?.Call(__set_text_custom_font, value);
    }
    
    private Font prop_GetTextCustomFont()
    {
        return (Font)(Instance?.Call(__get_text_custom_font));
    }
    
    public Vector2I GraphsBaseOffset
    {
        get => prop_GetGraphsBaseOffset();
        set => prop_SetGraphsBaseOffset(value);
    }
    
    public DebugDrawConfig2D.BlockPosition TextBlockPosition
    {
        get => prop_GetTextBlockPosition();
        set => prop_SetTextBlockPosition(value);
    }
    
    public Vector2I TextBlockOffset
    {
        get => prop_GetTextBlockOffset();
        set => prop_SetTextBlockOffset(value);
    }
    
    public Vector2I TextPadding
    {
        get => prop_GetTextPadding();
        set => prop_SetTextPadding(value);
    }
    
    public float TextDefaultDuration
    {
        get => prop_GetTextDefaultDuration();
        set => prop_SetTextDefaultDuration(value);
    }
    
    public int TextDefaultSize
    {
        get => prop_GetTextDefaultSize();
        set => prop_SetTextDefaultSize(value);
    }
    
    public Color TextForegroundColor
    {
        get => prop_GetTextForegroundColor();
        set => prop_SetTextForegroundColor(value);
    }
    
    public Color TextBackgroundColor
    {
        get => prop_GetTextBackgroundColor();
        set => prop_SetTextBackgroundColor(value);
    }
    
    public Font TextCustomFont
    {
        get => prop_GetTextCustomFont();
        set => prop_SetTextCustomFont(value);
    }
    
}

internal class DebugDrawGraph : IDisposable
{
    public GodotObject Instance { get; private set; }
    public DebugDrawGraph(GodotObject _instance)
    {
        if (_instance == null) throw new ArgumentNullException("_instance");
        if (!ClassDB.IsParentClass(_instance.GetClass(), GetType().Name)) throw new ArgumentException("\"_instance\" has the wrong type.");
        Instance = _instance;
    }
    
    public void Dispose()
    {
        Instance.Dispose();
        Instance = null;
    }
    
    public DebugDrawGraph() : this((GodotObject)ClassDB.Instantiate("DebugDrawGraph")) { }
    
    public enum GraphPosition : long
    {
        LeftTop = 0,
        RightTop = 1,
        LeftBottom = 2,
        RightBottom = 3,
    }
    
    public enum GraphSide : long
    {
        Left = 0,
        Top = 1,
        Right = 2,
        Bottom = 3,
    }
    
    public enum TextFlags : long
    {
        Current = 1,
        Avg = 2,
        Max = 4,
        Min = 8,
        All = 15,
    }
    
    private static readonly StringName __get_title = "get_title";
    private static readonly StringName __set_parent = "set_parent";
    private static readonly StringName __set_enabled = "set_enabled";
    private static readonly StringName __is_enabled = "is_enabled";
    private static readonly StringName __set_upside_down = "set_upside_down";
    private static readonly StringName __is_upside_down = "is_upside_down";
    private static readonly StringName __set_show_title = "set_show_title";
    private static readonly StringName __is_show_title = "is_show_title";
    private static readonly StringName __set_show_text_flags = "set_show_text_flags";
    private static readonly StringName __get_show_text_flags = "get_show_text_flags";
    private static readonly StringName __set_size = "set_size";
    private static readonly StringName __get_size = "get_size";
    private static readonly StringName __set_buffer_size = "set_buffer_size";
    private static readonly StringName __get_buffer_size = "get_buffer_size";
    private static readonly StringName __set_offset = "set_offset";
    private static readonly StringName __get_offset = "get_offset";
    private static readonly StringName __set_corner = "set_corner";
    private static readonly StringName __get_corner = "get_corner";
    private static readonly StringName __set_line_width = "set_line_width";
    private static readonly StringName __get_line_width = "get_line_width";
    private static readonly StringName __set_line_color = "set_line_color";
    private static readonly StringName __get_line_color = "get_line_color";
    private static readonly StringName __set_background_color = "set_background_color";
    private static readonly StringName __get_background_color = "get_background_color";
    private static readonly StringName __set_border_color = "set_border_color";
    private static readonly StringName __get_border_color = "get_border_color";
    private static readonly StringName __set_text_suffix = "set_text_suffix";
    private static readonly StringName __get_text_suffix = "get_text_suffix";
    private static readonly StringName __set_custom_font = "set_custom_font";
    private static readonly StringName __get_custom_font = "get_custom_font";
    private static readonly StringName __set_title_size = "set_title_size";
    private static readonly StringName __get_title_size = "get_title_size";
    private static readonly StringName __set_text_size = "set_text_size";
    private static readonly StringName __get_text_size = "get_text_size";
    private static readonly StringName __set_title_color = "set_title_color";
    private static readonly StringName __get_title_color = "get_title_color";
    private static readonly StringName __set_text_color = "set_text_color";
    private static readonly StringName __get_text_color = "get_text_color";
    private static readonly StringName __set_text_precision = "set_text_precision";
    private static readonly StringName __get_text_precision = "get_text_precision";
    private static readonly StringName __set_parent_graph = "set_parent_graph";
    private static readonly StringName __get_parent_graph = "get_parent_graph";
    private static readonly StringName __set_parent_graph_side = "set_parent_graph_side";
    private static readonly StringName __get_parent_graph_side = "get_parent_graph_side";
    private static readonly StringName __set_data_getter = "set_data_getter";
    private static readonly StringName __get_data_getter = "get_data_getter";
    
    public StringName GetTitle()
    {
#if DEBUG || FORCED_DD3D
        return (StringName)(Instance?.Call(__get_title));
#else
        return default;
#endif
    }
    
    public void SetParent(StringName parent, DebugDrawGraph.GraphSide side = (DebugDrawGraph.GraphSide)3)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__set_parent, parent, (long)side);
#endif
    }
    
    private void prop_SetEnabled(bool value)
    {
        Instance?.Call(__set_enabled, value);
    }
    
    private bool prop_IsEnabled()
    {
        return (bool)(Instance?.Call(__is_enabled));
    }
    
    private void prop_SetUpsideDown(bool value)
    {
        Instance?.Call(__set_upside_down, value);
    }
    
    private bool prop_IsUpsideDown()
    {
        return (bool)(Instance?.Call(__is_upside_down));
    }
    
    private void prop_SetShowTitle(bool value)
    {
        Instance?.Call(__set_show_title, value);
    }
    
    private bool prop_IsShowTitle()
    {
        return (bool)(Instance?.Call(__is_show_title));
    }
    
    private void prop_SetShowTextFlags(DebugDrawGraph.TextFlags value)
    {
        Instance?.Call(__set_show_text_flags, (long)value);
    }
    
    private DebugDrawGraph.TextFlags prop_GetShowTextFlags()
    {
        return (DebugDrawGraph.TextFlags)((long)Instance?.Call(__get_show_text_flags));
    }
    
    private void prop_SetSize(Vector2I value)
    {
        Instance?.Call(__set_size, value);
    }
    
    private Vector2I prop_GetSize()
    {
        return (Vector2I)(Instance?.Call(__get_size));
    }
    
    private void prop_SetBufferSize(int value)
    {
        Instance?.Call(__set_buffer_size, value);
    }
    
    private int prop_GetBufferSize()
    {
        return (int)(Instance?.Call(__get_buffer_size));
    }
    
    private void prop_SetOffset(Vector2I value)
    {
        Instance?.Call(__set_offset, value);
    }
    
    private Vector2I prop_GetOffset()
    {
        return (Vector2I)(Instance?.Call(__get_offset));
    }
    
    private void prop_SetCorner(DebugDrawGraph.GraphPosition value)
    {
        Instance?.Call(__set_corner, (long)value);
    }
    
    private DebugDrawGraph.GraphPosition prop_GetCorner()
    {
        return (DebugDrawGraph.GraphPosition)((long)Instance?.Call(__get_corner));
    }
    
    private void prop_SetLineWidth(float value)
    {
        Instance?.Call(__set_line_width, value);
    }
    
    private float prop_GetLineWidth()
    {
        return (float)(Instance?.Call(__get_line_width));
    }
    
    private void prop_SetLineColor(Color value)
    {
        Instance?.Call(__set_line_color, value);
    }
    
    private Color prop_GetLineColor()
    {
        return (Color)(Instance?.Call(__get_line_color));
    }
    
    private void prop_SetBackgroundColor(Color value)
    {
        Instance?.Call(__set_background_color, value);
    }
    
    private Color prop_GetBackgroundColor()
    {
        return (Color)(Instance?.Call(__get_background_color));
    }
    
    private void prop_SetBorderColor(Color value)
    {
        Instance?.Call(__set_border_color, value);
    }
    
    private Color prop_GetBorderColor()
    {
        return (Color)(Instance?.Call(__get_border_color));
    }
    
    private void prop_SetTextSuffix(string value)
    {
        Instance?.Call(__set_text_suffix, value);
    }
    
    private string prop_GetTextSuffix()
    {
        return (string)(Instance?.Call(__get_text_suffix));
    }
    
    private void prop_SetCustomFont(Font value)
    {
        Instance?.Call(__set_custom_font, value);
    }
    
    private Font prop_GetCustomFont()
    {
        return (Font)(Instance?.Call(__get_custom_font));
    }
    
    private void prop_SetTitleSize(int value)
    {
        Instance?.Call(__set_title_size, value);
    }
    
    private int prop_GetTitleSize()
    {
        return (int)(Instance?.Call(__get_title_size));
    }
    
    private void prop_SetTextSize(int value)
    {
        Instance?.Call(__set_text_size, value);
    }
    
    private int prop_GetTextSize()
    {
        return (int)(Instance?.Call(__get_text_size));
    }
    
    private void prop_SetTitleColor(Color value)
    {
        Instance?.Call(__set_title_color, value);
    }
    
    private Color prop_GetTitleColor()
    {
        return (Color)(Instance?.Call(__get_title_color));
    }
    
    private void prop_SetTextColor(Color value)
    {
        Instance?.Call(__set_text_color, value);
    }
    
    private Color prop_GetTextColor()
    {
        return (Color)(Instance?.Call(__get_text_color));
    }
    
    private void prop_SetTextPrecision(int value)
    {
        Instance?.Call(__set_text_precision, value);
    }
    
    private int prop_GetTextPrecision()
    {
        return (int)(Instance?.Call(__get_text_precision));
    }
    
    private void prop_SetParentGraph(StringName value)
    {
        Instance?.Call(__set_parent_graph, value);
    }
    
    private StringName prop_GetParentGraph()
    {
        return (StringName)(Instance?.Call(__get_parent_graph));
    }
    
    private void prop_SetParentGraphSide(DebugDrawGraph.GraphSide value)
    {
        Instance?.Call(__set_parent_graph_side, (long)value);
    }
    
    private DebugDrawGraph.GraphSide prop_GetParentGraphSide()
    {
        return (DebugDrawGraph.GraphSide)((long)Instance?.Call(__get_parent_graph_side));
    }
    
    private void prop_SetDataGetter(Callable value)
    {
        Instance?.Call(__set_data_getter, value);
    }
    
    private Callable prop_GetDataGetter()
    {
        return (Callable)(Instance?.Call(__get_data_getter));
    }
    
    public bool Enabled
    {
        get => prop_IsEnabled();
        set => prop_SetEnabled(value);
    }
    
    public bool UpsideDown
    {
        get => prop_IsUpsideDown();
        set => prop_SetUpsideDown(value);
    }
    
    public bool ShowTitle
    {
        get => prop_IsShowTitle();
        set => prop_SetShowTitle(value);
    }
    
    public DebugDrawGraph.TextFlags ShowTextFlags
    {
        get => prop_GetShowTextFlags();
        set => prop_SetShowTextFlags(value);
    }
    
    public Vector2I Size
    {
        get => prop_GetSize();
        set => prop_SetSize(value);
    }
    
    public int BufferSize
    {
        get => prop_GetBufferSize();
        set => prop_SetBufferSize(value);
    }
    
    public Vector2I Offset
    {
        get => prop_GetOffset();
        set => prop_SetOffset(value);
    }
    
    public DebugDrawGraph.GraphPosition Corner
    {
        get => prop_GetCorner();
        set => prop_SetCorner(value);
    }
    
    public float LineWidth
    {
        get => prop_GetLineWidth();
        set => prop_SetLineWidth(value);
    }
    
    public Color LineColor
    {
        get => prop_GetLineColor();
        set => prop_SetLineColor(value);
    }
    
    public Color BackgroundColor
    {
        get => prop_GetBackgroundColor();
        set => prop_SetBackgroundColor(value);
    }
    
    public Color BorderColor
    {
        get => prop_GetBorderColor();
        set => prop_SetBorderColor(value);
    }
    
    public string TextSuffix
    {
        get => prop_GetTextSuffix();
        set => prop_SetTextSuffix(value);
    }
    
    public Font CustomFont
    {
        get => prop_GetCustomFont();
        set => prop_SetCustomFont(value);
    }
    
    public int TitleSize
    {
        get => prop_GetTitleSize();
        set => prop_SetTitleSize(value);
    }
    
    public int TextSize
    {
        get => prop_GetTextSize();
        set => prop_SetTextSize(value);
    }
    
    public Color TitleColor
    {
        get => prop_GetTitleColor();
        set => prop_SetTitleColor(value);
    }
    
    public Color TextColor
    {
        get => prop_GetTextColor();
        set => prop_SetTextColor(value);
    }
    
    public int TextPrecision
    {
        get => prop_GetTextPrecision();
        set => prop_SetTextPrecision(value);
    }
    
    public StringName ParentGraph
    {
        get => prop_GetParentGraph();
        set => prop_SetParentGraph(value);
    }
    
    public DebugDrawGraph.GraphSide ParentGraphSide
    {
        get => prop_GetParentGraphSide();
        set => prop_SetParentGraphSide(value);
    }
    
    public Callable DataGetter
    {
        get => prop_GetDataGetter();
        set => prop_SetDataGetter(value);
    }
    
}

internal class DebugDrawFPSGraph : DebugDrawGraph
{
    
    public DebugDrawFPSGraph(GodotObject _instance) : base (_instance) {}
    
    public DebugDrawFPSGraph() : this((GodotObject)ClassDB.Instantiate("DebugDrawFPSGraph")) { }
    
    private static readonly StringName __set_frame_time_mode = "set_frame_time_mode";
    private static readonly StringName __is_frame_time_mode = "is_frame_time_mode";
    
    private void prop_SetFrameTimeMode(bool value)
    {
        Instance?.Call(__set_frame_time_mode, value);
    }
    
    private bool prop_IsFrameTimeMode()
    {
        return (bool)(Instance?.Call(__is_frame_time_mode));
    }
    
    public bool FrameTimeMode
    {
        get => prop_IsFrameTimeMode();
        set => prop_SetFrameTimeMode(value);
    }
    
}

static internal class DebugDraw3D
{
    private static GodotObject _instance;
    public static GodotObject Instance
    {
        get
        {
            if (!GodotObject.IsInstanceValid(_instance))
            {
                _instance = Engine.GetSingleton("DebugDraw3D");
            }
            return _instance;
        }
    }
    
    private static readonly StringName __set_empty_color = "set_empty_color";
    private static readonly StringName __get_empty_color = "get_empty_color";
    private static readonly StringName __set_debug_enabled = "set_debug_enabled";
    private static readonly StringName __is_debug_enabled = "is_debug_enabled";
    private static readonly StringName __set_config = "set_config";
    private static readonly StringName __get_config = "get_config";
    private static readonly StringName __set_custom_viewport = "set_custom_viewport";
    private static readonly StringName __get_custom_viewport = "get_custom_viewport";
    private static readonly StringName __clear_3d_objects = "clear_3d_objects";
    private static readonly StringName __draw_sphere = "draw_sphere";
    private static readonly StringName __draw_sphere_xf = "draw_sphere_xf";
    private static readonly StringName __draw_sphere_hd = "draw_sphere_hd";
    private static readonly StringName __draw_sphere_hd_xf = "draw_sphere_hd_xf";
    private static readonly StringName __draw_cylinder = "draw_cylinder";
    private static readonly StringName __draw_box = "draw_box";
    private static readonly StringName __draw_box_xf = "draw_box_xf";
    private static readonly StringName __draw_aabb = "draw_aabb";
    private static readonly StringName __draw_aabb_ab = "draw_aabb_ab";
    private static readonly StringName __draw_line_hit = "draw_line_hit";
    private static readonly StringName __draw_line_hit_offset = "draw_line_hit_offset";
    private static readonly StringName __draw_line = "draw_line";
    private static readonly StringName __draw_lines = "draw_lines";
    private static readonly StringName __draw_ray = "draw_ray";
    private static readonly StringName __draw_line_path = "draw_line_path";
    private static readonly StringName __draw_arrow = "draw_arrow";
    private static readonly StringName __draw_arrow_line = "draw_arrow_line";
    private static readonly StringName __draw_arrow_ray = "draw_arrow_ray";
    private static readonly StringName __draw_arrow_path = "draw_arrow_path";
    private static readonly StringName __draw_point_path = "draw_point_path";
    private static readonly StringName __draw_square = "draw_square";
    private static readonly StringName __draw_points = "draw_points";
    private static readonly StringName __draw_camera_frustum = "draw_camera_frustum";
    private static readonly StringName __draw_camera_frustum_planes = "draw_camera_frustum_planes";
    private static readonly StringName __draw_position = "draw_position";
    private static readonly StringName __draw_gizmo = "draw_gizmo";
    private static readonly StringName __draw_grid = "draw_grid";
    private static readonly StringName __draw_grid_xf = "draw_grid_xf";
    private static readonly StringName __get_render_stats = "get_render_stats";
    
    private static void prop_SetEmptyColor(Color value)
    {
        Instance?.Call(__set_empty_color, value);
    }
    
    private static Color prop_GetEmptyColor()
    {
        return (Color)(Instance?.Call(__get_empty_color));
    }
    
    private static void prop_SetDebugEnabled(bool value)
    {
        Instance?.Call(__set_debug_enabled, value);
    }
    
    private static bool prop_IsDebugEnabled()
    {
        return (bool)(Instance?.Call(__is_debug_enabled));
    }
    
    private static void prop_SetConfig(DebugDrawConfig3D value)
    {
        Instance?.Call(__set_config, value.Instance);
    }
    
    private static DebugDrawConfig3D prop_GetConfig()
    {
        return (DebugDrawConfig3D)_DebugDrawUtils_.CreateWrapperFromObject((GodotObject)Instance?.Call(__get_config));
    }
    
    private static void prop_SetCustomViewport(Viewport value)
    {
        Instance?.Call(__set_custom_viewport, value);
    }
    
    private static Viewport prop_GetCustomViewport()
    {
        return (Viewport)(Instance?.Call(__get_custom_viewport));
    }
    
    public static void Clear3dObjects()
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__clear_3d_objects);
#endif
    }
    
    public static void DrawSphere(Vector3 position, float radius = 0.5f, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_sphere, position, radius, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawSphereXf(Transform3D transform, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_sphere_xf, transform, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawSphereHd(Vector3 position, float radius = 0.5f, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_sphere_hd, position, radius, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawSphereHdXf(Transform3D transform, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_sphere_hd_xf, transform, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawCylinder(Transform3D transform, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_cylinder, transform, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawBox(Vector3 position, Vector3 size, Color? color = null, bool is_box_centered = false, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_box, position, size, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, is_box_centered, duration);
#endif
    }
    
    public static void DrawBoxXf(Transform3D transform, Color? color = null, bool is_box_centered = true, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_box_xf, transform, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, is_box_centered, duration);
#endif
    }
    
    public static void DrawAabb(Aabb aabb, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_aabb, aabb, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawAabbAb(Vector3 a, Vector3 b, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_aabb_ab, a, b, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawLineHit(Vector3 start, Vector3 end, Vector3 hit, bool is_hit, float hit_size = 0.25f, Color? hit_color = null, Color? after_hit_color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_line_hit, start, end, hit, is_hit, hit_size, hit_color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, after_hit_color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawLineHitOffset(Vector3 start, Vector3 end, bool is_hit, float unit_offset_of_hit = 0.5f, float hit_size = 0.25f, Color? hit_color = null, Color? after_hit_color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_line_hit_offset, start, end, is_hit, unit_offset_of_hit, hit_size, hit_color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, after_hit_color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawLine(Vector3 a, Vector3 b, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_line, a, b, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawLines(Vector3[] lines, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_lines, lines, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawRay(Vector3 origin, Vector3 direction, float length, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_ray, origin, direction, length, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawLinePath(Vector3[] path, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_line_path, path, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawArrow(Transform3D transform, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_arrow, transform, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawArrowLine(Vector3 a, Vector3 b, Color? color = null, float arrow_size = 0.5f, bool is_absolute_size = false, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_arrow_line, a, b, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, arrow_size, is_absolute_size, duration);
#endif
    }
    
    public static void DrawArrowRay(Vector3 origin, Vector3 direction, float length, Color? color = null, float arrow_size = 0.5f, bool is_absolute_size = false, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_arrow_ray, origin, direction, length, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, arrow_size, is_absolute_size, duration);
#endif
    }
    
    public static void DrawArrowPath(Vector3[] path, Color? color = null, float arrow_size = 0.75f, bool is_absolute_size = true, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_arrow_path, path, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, arrow_size, is_absolute_size, duration);
#endif
    }
    
    public static void DrawPointPath(Vector3[] path, float size = 0.25f, Color? points_color = null, Color? lines_color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_point_path, path, size, points_color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, lines_color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawSquare(Vector3 position, float size = 0.20000000298023f, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_square, position, size, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawPoints(Vector3[] points, float size = 0.20000000298023f, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_points, points, size, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawCameraFrustum(Camera3D camera, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_camera_frustum, camera, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawCameraFrustumPlanes(Godot.Collections.Array camera_frustum, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_camera_frustum_planes, camera_frustum, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawPosition(Transform3D transform, Color? color = null, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_position, transform, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, duration);
#endif
    }
    
    public static void DrawGizmo(Transform3D transform, Color? color = null, bool is_centered = false, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_gizmo, transform, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, is_centered, duration);
#endif
    }
    
    public static void DrawGrid(Vector3 origin, Vector3 x_size, Vector3 y_size, Vector2I subdivision, Color? color = null, bool is_centered = true, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_grid, origin, x_size, y_size, subdivision, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, is_centered, duration);
#endif
    }
    
    public static void DrawGridXf(Transform3D transform, Vector2I subdivision, Color? color = null, bool is_centered = true, float duration = 0f)
    {
#if DEBUG || FORCED_DD3D
        Instance?.Call(__draw_grid_xf, transform, subdivision, color ?? _DebugDrawUtils_.DefaultArgumentsData.arg_0, is_centered, duration);
#endif
    }
    
    public static DebugDrawStats3D GetRenderStats()
    {
#if DEBUG || FORCED_DD3D
        return (DebugDrawStats3D)_DebugDrawUtils_.CreateWrapperFromObject((GodotObject)Instance?.Call(__get_render_stats));
#else
        return default;
#endif
    }
    
    public static Color EmptyColor
    {
        get => prop_GetEmptyColor();
        set => prop_SetEmptyColor(value);
    }
    
    public static bool DebugEnabled
    {
        get => prop_IsDebugEnabled();
        set => prop_SetDebugEnabled(value);
    }
    
    public static DebugDrawConfig3D Config
    {
        get => prop_GetConfig();
        set => prop_SetConfig(value);
    }
    
    public static Viewport CustomViewport
    {
        get => prop_GetCustomViewport();
        set => prop_SetCustomViewport(value);
    }
    
}

internal class DebugDrawStats3D : IDisposable
{
    public GodotObject Instance { get; private set; }
    public DebugDrawStats3D(GodotObject _instance)
    {
        if (_instance == null) throw new ArgumentNullException("_instance");
        if (!ClassDB.IsParentClass(_instance.GetClass(), GetType().Name)) throw new ArgumentException("\"_instance\" has the wrong type.");
        Instance = _instance;
    }
    
    public void Dispose()
    {
        Instance.Dispose();
        Instance = null;
    }
    
    public DebugDrawStats3D() : this((GodotObject)ClassDB.Instantiate("DebugDrawStats3D")) { }
    
    private static readonly StringName __get_instances = "get_instances";
    private static readonly StringName __set_instances = "set_instances";
    private static readonly StringName __get_lines = "get_lines";
    private static readonly StringName __set_lines = "set_lines";
    private static readonly StringName __get_total_geometry = "get_total_geometry";
    private static readonly StringName __set_total_geometry = "set_total_geometry";
    private static readonly StringName __get_visible_instances = "get_visible_instances";
    private static readonly StringName __set_visible_instances = "set_visible_instances";
    private static readonly StringName __get_visible_lines = "get_visible_lines";
    private static readonly StringName __set_visible_lines = "set_visible_lines";
    private static readonly StringName __get_total_visible = "get_total_visible";
    private static readonly StringName __set_total_visible = "set_total_visible";
    private static readonly StringName __get_time_filling_buffers_instances_usec = "get_time_filling_buffers_instances_usec";
    private static readonly StringName __set_time_filling_buffers_instances_usec = "set_time_filling_buffers_instances_usec";
    private static readonly StringName __get_time_filling_buffers_lines_usec = "get_time_filling_buffers_lines_usec";
    private static readonly StringName __set_time_filling_buffers_lines_usec = "set_time_filling_buffers_lines_usec";
    private static readonly StringName __get_total_time_filling_buffers_usec = "get_total_time_filling_buffers_usec";
    private static readonly StringName __set_total_time_filling_buffers_usec = "set_total_time_filling_buffers_usec";
    private static readonly StringName __get_time_culling_instant_usec = "get_time_culling_instant_usec";
    private static readonly StringName __set_time_culling_instant_usec = "set_time_culling_instant_usec";
    private static readonly StringName __get_time_culling_delayed_usec = "get_time_culling_delayed_usec";
    private static readonly StringName __set_time_culling_delayed_usec = "set_time_culling_delayed_usec";
    private static readonly StringName __get_total_time_culling_usec = "get_total_time_culling_usec";
    private static readonly StringName __set_total_time_culling_usec = "set_total_time_culling_usec";
    private static readonly StringName __get_total_time_spent_usec = "get_total_time_spent_usec";
    private static readonly StringName __set_total_time_spent_usec = "set_total_time_spent_usec";
    
    private int prop_GetInstances()
    {
        return (int)(Instance?.Call(__get_instances));
    }
    
    private void prop_SetInstances(int value)
    {
        Instance?.Call(__set_instances, value);
    }
    
    private int prop_GetLines()
    {
        return (int)(Instance?.Call(__get_lines));
    }
    
    private void prop_SetLines(int value)
    {
        Instance?.Call(__set_lines, value);
    }
    
    private int prop_GetTotalGeometry()
    {
        return (int)(Instance?.Call(__get_total_geometry));
    }
    
    private void prop_SetTotalGeometry(int value)
    {
        Instance?.Call(__set_total_geometry, value);
    }
    
    private int prop_GetVisibleInstances()
    {
        return (int)(Instance?.Call(__get_visible_instances));
    }
    
    private void prop_SetVisibleInstances(int value)
    {
        Instance?.Call(__set_visible_instances, value);
    }
    
    private int prop_GetVisibleLines()
    {
        return (int)(Instance?.Call(__get_visible_lines));
    }
    
    private void prop_SetVisibleLines(int value)
    {
        Instance?.Call(__set_visible_lines, value);
    }
    
    private int prop_GetTotalVisible()
    {
        return (int)(Instance?.Call(__get_total_visible));
    }
    
    private void prop_SetTotalVisible(int value)
    {
        Instance?.Call(__set_total_visible, value);
    }
    
    private int prop_GetTimeFillingBuffersInstancesUsec()
    {
        return (int)(Instance?.Call(__get_time_filling_buffers_instances_usec));
    }
    
    private void prop_SetTimeFillingBuffersInstancesUsec(int value)
    {
        Instance?.Call(__set_time_filling_buffers_instances_usec, value);
    }
    
    private int prop_GetTimeFillingBuffersLinesUsec()
    {
        return (int)(Instance?.Call(__get_time_filling_buffers_lines_usec));
    }
    
    private void prop_SetTimeFillingBuffersLinesUsec(int value)
    {
        Instance?.Call(__set_time_filling_buffers_lines_usec, value);
    }
    
    private int prop_GetTotalTimeFillingBuffersUsec()
    {
        return (int)(Instance?.Call(__get_total_time_filling_buffers_usec));
    }
    
    private void prop_SetTotalTimeFillingBuffersUsec(int value)
    {
        Instance?.Call(__set_total_time_filling_buffers_usec, value);
    }
    
    private int prop_GetTimeCullingInstantUsec()
    {
        return (int)(Instance?.Call(__get_time_culling_instant_usec));
    }
    
    private void prop_SetTimeCullingInstantUsec(int value)
    {
        Instance?.Call(__set_time_culling_instant_usec, value);
    }
    
    private int prop_GetTimeCullingDelayedUsec()
    {
        return (int)(Instance?.Call(__get_time_culling_delayed_usec));
    }
    
    private void prop_SetTimeCullingDelayedUsec(int value)
    {
        Instance?.Call(__set_time_culling_delayed_usec, value);
    }
    
    private int prop_GetTotalTimeCullingUsec()
    {
        return (int)(Instance?.Call(__get_total_time_culling_usec));
    }
    
    private void prop_SetTotalTimeCullingUsec(int value)
    {
        Instance?.Call(__set_total_time_culling_usec, value);
    }
    
    private int prop_GetTotalTimeSpentUsec()
    {
        return (int)(Instance?.Call(__get_total_time_spent_usec));
    }
    
    private void prop_SetTotalTimeSpentUsec(int value)
    {
        Instance?.Call(__set_total_time_spent_usec, value);
    }
    
    public int Instances
    {
        get => prop_GetInstances();
        set => prop_SetInstances(value);
    }
    
    public int Lines
    {
        get => prop_GetLines();
        set => prop_SetLines(value);
    }
    
    public int TotalGeometry
    {
        get => prop_GetTotalGeometry();
        set => prop_SetTotalGeometry(value);
    }
    
    public int VisibleInstances
    {
        get => prop_GetVisibleInstances();
        set => prop_SetVisibleInstances(value);
    }
    
    public int VisibleLines
    {
        get => prop_GetVisibleLines();
        set => prop_SetVisibleLines(value);
    }
    
    public int TotalVisible
    {
        get => prop_GetTotalVisible();
        set => prop_SetTotalVisible(value);
    }
    
    public int TimeFillingBuffersInstancesUsec
    {
        get => prop_GetTimeFillingBuffersInstancesUsec();
        set => prop_SetTimeFillingBuffersInstancesUsec(value);
    }
    
    public int TimeFillingBuffersLinesUsec
    {
        get => prop_GetTimeFillingBuffersLinesUsec();
        set => prop_SetTimeFillingBuffersLinesUsec(value);
    }
    
    public int TotalTimeFillingBuffersUsec
    {
        get => prop_GetTotalTimeFillingBuffersUsec();
        set => prop_SetTotalTimeFillingBuffersUsec(value);
    }
    
    public int TimeCullingInstantUsec
    {
        get => prop_GetTimeCullingInstantUsec();
        set => prop_SetTimeCullingInstantUsec(value);
    }
    
    public int TimeCullingDelayedUsec
    {
        get => prop_GetTimeCullingDelayedUsec();
        set => prop_SetTimeCullingDelayedUsec(value);
    }
    
    public int TotalTimeCullingUsec
    {
        get => prop_GetTotalTimeCullingUsec();
        set => prop_SetTotalTimeCullingUsec(value);
    }
    
    public int TotalTimeSpentUsec
    {
        get => prop_GetTotalTimeSpentUsec();
        set => prop_SetTotalTimeSpentUsec(value);
    }
    
}

internal class DebugDrawConfig3D : IDisposable
{
    public GodotObject Instance { get; private set; }
    public DebugDrawConfig3D(GodotObject _instance)
    {
        if (_instance == null) throw new ArgumentNullException("_instance");
        if (!ClassDB.IsParentClass(_instance.GetClass(), GetType().Name)) throw new ArgumentException("\"_instance\" has the wrong type.");
        Instance = _instance;
    }
    
    public void Dispose()
    {
        Instance.Dispose();
        Instance = null;
    }
    
    public DebugDrawConfig3D() : this((GodotObject)ClassDB.Instantiate("DebugDrawConfig3D")) { }
    
    private static readonly StringName __set_freeze_3d_render = "set_freeze_3d_render";
    private static readonly StringName __is_freeze_3d_render = "is_freeze_3d_render";
    private static readonly StringName __set_visible_instance_bounds = "set_visible_instance_bounds";
    private static readonly StringName __is_visible_instance_bounds = "is_visible_instance_bounds";
    private static readonly StringName __set_use_frustum_culling = "set_use_frustum_culling";
    private static readonly StringName __is_use_frustum_culling = "is_use_frustum_culling";
    private static readonly StringName __set_cull_by_distance = "set_cull_by_distance";
    private static readonly StringName __get_cull_by_distance = "get_cull_by_distance";
    private static readonly StringName __set_force_use_camera_from_scene = "set_force_use_camera_from_scene";
    private static readonly StringName __is_force_use_camera_from_scene = "is_force_use_camera_from_scene";
    private static readonly StringName __set_geometry_render_layers = "set_geometry_render_layers";
    private static readonly StringName __get_geometry_render_layers = "get_geometry_render_layers";
    private static readonly StringName __set_line_hit_color = "set_line_hit_color";
    private static readonly StringName __get_line_hit_color = "get_line_hit_color";
    private static readonly StringName __set_line_after_hit_color = "set_line_after_hit_color";
    private static readonly StringName __get_line_after_hit_color = "get_line_after_hit_color";
    
    private void prop_SetFreeze3dRender(bool value)
    {
        Instance?.Call(__set_freeze_3d_render, value);
    }
    
    private bool prop_IsFreeze3dRender()
    {
        return (bool)(Instance?.Call(__is_freeze_3d_render));
    }
    
    private void prop_SetVisibleInstanceBounds(bool value)
    {
        Instance?.Call(__set_visible_instance_bounds, value);
    }
    
    private bool prop_IsVisibleInstanceBounds()
    {
        return (bool)(Instance?.Call(__is_visible_instance_bounds));
    }
    
    private void prop_SetUseFrustumCulling(bool value)
    {
        Instance?.Call(__set_use_frustum_culling, value);
    }
    
    private bool prop_IsUseFrustumCulling()
    {
        return (bool)(Instance?.Call(__is_use_frustum_culling));
    }
    
    private void prop_SetCullByDistance(float value)
    {
        Instance?.Call(__set_cull_by_distance, value);
    }
    
    private float prop_GetCullByDistance()
    {
        return (float)(Instance?.Call(__get_cull_by_distance));
    }
    
    private void prop_SetForceUseCameraFromScene(bool value)
    {
        Instance?.Call(__set_force_use_camera_from_scene, value);
    }
    
    private bool prop_IsForceUseCameraFromScene()
    {
        return (bool)(Instance?.Call(__is_force_use_camera_from_scene));
    }
    
    private void prop_SetGeometryRenderLayers(int value)
    {
        Instance?.Call(__set_geometry_render_layers, value);
    }
    
    private int prop_GetGeometryRenderLayers()
    {
        return (int)(Instance?.Call(__get_geometry_render_layers));
    }
    
    private void prop_SetLineHitColor(Color value)
    {
        Instance?.Call(__set_line_hit_color, value);
    }
    
    private Color prop_GetLineHitColor()
    {
        return (Color)(Instance?.Call(__get_line_hit_color));
    }
    
    private void prop_SetLineAfterHitColor(Color value)
    {
        Instance?.Call(__set_line_after_hit_color, value);
    }
    
    private Color prop_GetLineAfterHitColor()
    {
        return (Color)(Instance?.Call(__get_line_after_hit_color));
    }
    
    public bool Freeze3dRender
    {
        get => prop_IsFreeze3dRender();
        set => prop_SetFreeze3dRender(value);
    }
    
    public bool VisibleInstanceBounds
    {
        get => prop_IsVisibleInstanceBounds();
        set => prop_SetVisibleInstanceBounds(value);
    }
    
    public bool UseFrustumCulling
    {
        get => prop_IsUseFrustumCulling();
        set => prop_SetUseFrustumCulling(value);
    }
    
    public float CullByDistance
    {
        get => prop_GetCullByDistance();
        set => prop_SetCullByDistance(value);
    }
    
    public bool ForceUseCameraFromScene
    {
        get => prop_IsForceUseCameraFromScene();
        set => prop_SetForceUseCameraFromScene(value);
    }
    
    public int GeometryRenderLayers
    {
        get => prop_GetGeometryRenderLayers();
        set => prop_SetGeometryRenderLayers(value);
    }
    
    public Color LineHitColor
    {
        get => prop_GetLineHitColor();
        set => prop_SetLineHitColor(value);
    }
    
    public Color LineAfterHitColor
    {
        get => prop_GetLineAfterHitColor();
        set => prop_SetLineAfterHitColor(value);
    }
    
}

static internal class DebugDrawManager
{
    private static GodotObject _instance;
    public static GodotObject Instance
    {
        get
        {
            if (!GodotObject.IsInstanceValid(_instance))
            {
                _instance = Engine.GetSingleton("DebugDrawManager");
            }
            return _instance;
        }
    }
    
}

internal static class _DebugDrawUtils_
{
    public static class DefaultArgumentsData
    {
        public static readonly Color arg_0 = new Color(0f, 0f, 0f, 0f);
    }
    
    public static object CreateWrapperFromObject(GodotObject _instance)
    {
        if (_instance == null)
        {
            return null;
        }
        switch(_instance.GetClass())
        {
            case "DebugDrawStats2D":
            {
                return new DebugDrawStats2D(_instance);
            }
            case "DebugDrawConfig2D":
            {
                return new DebugDrawConfig2D(_instance);
            }
            case "DebugDrawGraph":
            {
                return new DebugDrawGraph(_instance);
            }
            case "DebugDrawFPSGraph":
            {
                return new DebugDrawFPSGraph(_instance);
            }
            case "DebugDrawStats3D":
            {
                return new DebugDrawStats3D(_instance);
            }
            case "DebugDrawConfig3D":
            {
                return new DebugDrawConfig3D(_instance);
            }
        }
        throw new NotImplementedException();
    }
}

[j20001970]

Looks like this is the most feasible way to generate C# bindings for now, I'll try this when I got some time.

[GeorgeS2019]

@j20001970
2024 Attempt!
godotengine/godot-proposals#8191 (comment)

[GeorgeS2019]

@j20001970

Why a coordinated effort between GDextension for c++, rust, and csharp is needed?
https://chat.godotengine.org/channel/dotnet?msg=Kyvjpbutadr2bnzvG

[GeorgeS2019]

@j20001970

Finally this is Happening!

https://github.com/Delsin-Yu/CSharp-Wrapper-Generator-for-GDExtension

[j20001970]

Hi, thanks for the heads up, if I understand this project correctly, this is what exactly needed for enabling C# support for GDExtension plugins like GDMP, I'll try that when I got time.

Since this C# wrapper generator is intended to work on Godot projects with needed plugins enabled, I think it's better to keep the topic here. I'll close duplicated issues/discussions if there are any in favour of this discussion in the meantime, and update you if there are progress regarding C# usage of GDMP.

[GeorgeS2019]

The current wrapper can automatically generate the 37 Mediapipe classes registered through classDB, complete with properties and methods and enum

I hope U are interested to test is the generated classes make sense

[GeorgeS2019]

@j20001970
@dsnopek

Using this automated c# GDExtension wrapper generator

I manage to port the GDscript version of FaceLandmark example to c#

The demo works but the performance is yet to be optimized.

This branch is no longer needed

https://github.com/j20001970/GDMP/tree/csharp-bindings

Here is the same code of a working .NET wrapper. The performance is almost as good as the GDScript

What started almost 11 months ago is NOW DONE

Thank you to all supported and contributed