{

public enum nk_anti_aliasing {

NK_ANTI_ALIASING_OFF,

NK_ANTI_ALIASING_ON

}

[Flags]

public enum nk_convert_result {

NK_CONVERT_SUCCESS = 0,

NK_CONVERT_INVALID_PARAM = 1,

NK_CONVERT_COMMAND_BUFFER_FULL = (1 << (1)),

NK_CONVERT_VERTEX_BUFFER_FULL = (1 << (2)),

NK_CONVERT_ELEMENT_BUFFER_FULL = (1 << (3))

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_draw_null_texture {

public nk_handle texture;

public nk_vec2 uv;

}

[StructLayout(LayoutKind.Sequential)]

public unsafe struct nk_convert_config {

public float global_alpha;

public nk_anti_aliasing line_AA;

public nk_anti_aliasing shape_AA;

public uint circle_segment_count;

public uint arc_segment_count;

public uint curve_segment_count;

public nk_draw_null_texture null_tex;

public nk_draw_vertex_layout_element* vertex_layout;

public IntPtr vertex_size;

public IntPtr vertex_alignment;

}

public enum nk_command_type {

NK_COMMAND_NOP,

NK_COMMAND_SCISSOR,

NK_COMMAND_LINE,

NK_COMMAND_CURVE,

NK_COMMAND_RECT,

NK_COMMAND_RECT_FILLED,

NK_COMMAND_RECT_MULTI_COLOR,

NK_COMMAND_CIRCLE,

NK_COMMAND_CIRCLE_FILLED,

NK_COMMAND_ARC,

NK_COMMAND_ARC_FILLED,

NK_COMMAND_TRIANGLE,

NK_COMMAND_TRIANGLE_FILLED,

NK_COMMAND_POLYGON,

NK_COMMAND_POLYGON_FILLED,

NK_COMMAND_POLYLINE,

NK_COMMAND_TEXT,

NK_COMMAND_IMAGE,

NK_COMMAND_CUSTOM

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command {

public nk_command_type ctype;

public IntPtr next_nksize;

public nk_handle userdata;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_scissor {

public nk_command header;

public short x;

public short y;

public ushort w;

public ushort h;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_line {

public nk_command header;

public ushort line_thickness;

public nk_vec2i begin;

public nk_vec2i end;

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_curve {

public nk_command header;

public ushort line_thickness;

public nk_vec2i begin;

public nk_vec2i end;

public nk_vec2i ctrlA;

public nk_vec2i ctrlB;

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_rect {

public nk_command header;

public ushort rounding;

public ushort line_thickness;

public short x;

public short y;

public ushort w;

public ushort h;

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_rect_filled {

public nk_command header;

public ushort rounding;

public short x;

public short y;

public ushort w;

public ushort h;

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_rect_multi_color {

public nk_command header;

public short x;

public short y;

public ushort w;

public ushort h;

public nk_color left;

public nk_color top;

public nk_color bottom;

public nk_color right;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_triangle {

public nk_command header;

public ushort line_thickness;

public nk_vec2i a;

public nk_vec2i b;

public nk_vec2i c;

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_triangle_filled {

public nk_command header;

public nk_vec2i a;

public nk_vec2i b;

public nk_vec2i c;

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_circle {

public nk_command header;

public short x;

public short y;

public ushort line_thickness;

public ushort w;

public ushort h;

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_circle_filled {

public nk_command header;

public short x;

public short y;

public ushort w;

public ushort h;

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public unsafe struct nk_command_arc {

public nk_command header;

public short cx;

public short cy;

public ushort r;

public ushort line_thickness;

public fixed float a[2];

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public unsafe struct nk_command_arc_filled {

public nk_command header;

public short cx;

public short cy;

public ushort r;

public fixed float a[2];

public nk_color color;

}

[StructLayout(LayoutKind.Sequential)]

public unsafe struct nk_command_polygon {

public nk_command header;

public nk_color color;

public ushort line_thickness;

public ushort point_count;

public nk_vec2i firstPoint; /* (fixed?) struct nk_vec2i points[1]; /* ????? * */

}

[StructLayout(LayoutKind.Sequential)]

public unsafe struct nk_command_polygon_filled {

public nk_command header;

public nk_color color;

public ushort point_count;

public nk_vec2i firstPoint;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_polyline {

public nk_command header;

public nk_color color;

public ushort line_thickness;

public ushort point_count;

public nk_vec2i firstPoint;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_image {

public nk_command header;

public short x;

public short y;

public ushort w;

public ushort h;

public nk_image img;

public nk_color col;

}

public delegate void nk_command_custom_callback(IntPtr canvas, short x, short y, ushort w, ushort h, nk_handle callback_data);

[StructLayout(LayoutKind.Sequential)]

public struct nk_command_custom {

public nk_command header;

public short x;

public short y;

public ushort w;

public ushort h;

public nk_handle callback_data;

public nk_command_custom_callback callback;

}

[StructLayout(LayoutKind.Sequential)]

public unsafe struct nk_command_text {

public nk_command header;

public nk_user_font* font;

public nk_color background;

public nk_color foreground;

public short x;

public short y;

public ushort w;

public ushort h;

public float height;

public int length;

public byte stringFirstByte;

}

public enum nk_command_clipping {

NK_CLIPPING_OFF = nk_bool.nk_false,

NK_CLIPPING_ON = nk_bool.nk_true

}

[StructLayout(LayoutKind.Sequential)]

public unsafe struct nk_command_buffer {

public nk_buffer* baseBuf;

public nk_rect clip;

public int use_clipping;

public nk_handle userdata;

public IntPtr begin_nksize;

public IntPtr end_nksize;

public IntPtr last_nksize;

}

/* nk_draw_index -> nk_ushort */

public enum nk_draw_list_stroke {

NK_STROKE_OPEN = nk_bool.nk_false,

NK_STROKE_CLOSED = nk_bool.nk_true

}

public enum nk_draw_vertex_layout_attribute {

NK_VERTEX_POSITION,

NK_VERTEX_COLOR,

NK_VERTEX_TEXCOORD,

NK_VERTEX_ATTRIBUTE_COUNT

}

public enum nk_draw_vertex_layout_format {

NK_FORMAT_SCHAR,

NK_FORMAT_SSHORT,

NK_FORMAT_SINT,

NK_FORMAT_UCHAR,

NK_FORMAT_USHORT,

NK_FORMAT_UINT,

NK_FORMAT_FLOAT,

NK_FORMAT_DOUBLE,

NK_FORMAT_COLOR_BEGIN,

NK_FORMAT_R8G8B8 = NK_FORMAT_COLOR_BEGIN,

NK_FORMAT_R16G15B16,

NK_FORMAT_R32G32B32,

NK_FORMAT_R8G8B8A8,

NK_FORMAT_B8G8R8A8,

NK_FORMAT_R16G15B16A16,

NK_FORMAT_R32G32B32A32,

NK_FORMAT_R32G32B32A32_FLOAT,

NK_FORMAT_R32G32B32A32_DOUBLE,

NK_FORMAT_RGB32,

NK_FORMAT_RGBA32,

NK_FORMAT_COLOR_END = NK_FORMAT_RGBA32,

NK_FORMAT_COUNT

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_draw_vertex_layout_element {

public nk_draw_vertex_layout_attribute attribute;

public nk_draw_vertex_layout_format format;

public IntPtr offset_nksize;

}

[StructLayout(LayoutKind.Sequential)]

public struct nk_draw_command {

public uint elem_count;

public nk_rect clip_rect;

public nk_handle texture;

public nk_handle userdata;

}

[StructLayout(LayoutKind.Sequential)]

public unsafe struct nk_draw_list {

public nk_rect clip_rect;

public fixed long circle_vtx_CastMeToVec2[12];

public nk_convert_config config;

public nk_buffer* buffer;

public nk_buffer* vertices;

public nk_buffer* elements;

public uint element_count;

public uint vertex_count;

public uint cmd_count;

public IntPtr cmd_offset_nksize;

public uint path_count;

public uint path_offset;

public nk_anti_aliasing line_AA;

public nk_anti_aliasing shape_AA;

public nk_handle userdata;

}

public static unsafe partial class NuklearNative

{

private delegate nk_command* nk__begin_t(nk_context* context);

private static nk__begin_t _nk__begin = LFT<nk__begin_t>();

public static nk_command* nk__begin(nk_context* context) => _nk__begin(context);

private delegate nk_command* nk__next_t(nk_context* context, nk_command* command);

private static nk__next_t _nk__next = LFT<nk__next_t>();

public static nk_command* nk__next(nk_context* context, nk_command* command) => _nk__next(context, command);

private delegate uint nk_convert_t(nk_context* context, nk_buffer* cmds, nk_buffer* vertices, nk_buffer* elements, nk_convert_config* ncc);

private static nk_convert_t _nk_convert = LFT<nk_convert_t>();

public static uint nk_convert(nk_context* context, nk_buffer* cmds, nk_buffer* vertices, nk_buffer* elements, nk_convert_config* ncc) => _nk_convert(context, cmds, vertices, elements, ncc);

private delegate nk_draw_command* nk__draw_begin_t(nk_context* context, nk_buffer* buf);

private static nk__draw_begin_t _nk__draw_begin = LFT<nk__draw_begin_t>();

public static nk_draw_command* nk__draw_begin(nk_context* context, nk_buffer* buf) => _nk__draw_begin(context, buf);

private delegate nk_draw_command* nk__draw_end_t(nk_context* context, nk_buffer* buf);

private static nk__draw_end_t _nk__draw_end = LFT<nk__draw_end_t>();

public static nk_draw_command* nk__draw_end(nk_context* context, nk_buffer* buf) => _nk__draw_end(context, buf);

private delegate nk_draw_command* nk__draw_next_t(nk_draw_command* drawc, nk_buffer* buf, nk_context* context);

private static nk__draw_next_t _nk__draw_next = LFT<nk__draw_next_t>();

public static nk_draw_command* nk__draw_next(nk_draw_command* drawc, nk_buffer* buf, nk_context* context) => _nk__draw_next(drawc, buf, context);

private delegate int nk_begin_t(nk_context* context, byte* title, nk_rect bounds, uint flags_nkflags);

private static nk_begin_t _nk_begin = LFT<nk_begin_t>();

public static int nk_begin(nk_context* context, byte* title, nk_rect bounds, uint flags_nkflags) => _nk_begin(context, title, bounds, flags_nkflags);

private delegate void nk_end_t(nk_context* context);

private static nk_end_t _nk_end = LFT<nk_end_t>();

public static void nk_end(nk_context* context) => _nk_end(context);

private delegate void nk_stroke_line_t(nk_command_buffer* cbuf, float x0, float y0, float x1, float y1, float line_thickness, nk_color color);

private delegate void nk_stroke_curve_t(nk_command_buffer* cbuf, float x, float y, float x1, float y1, float xa, float ya, float xb, float yb, float line_thickness, nk_color col);

private delegate void nk_stroke_rect_t(nk_command_buffer* cbuf, nk_rect r, float rounding, float line_thickness, nk_color col);

private delegate void nk_stroke_circle_t(nk_command_buffer* cbuf, nk_rect r, float line_thickness, nk_color col);

private delegate void nk_stroke_arc_t(nk_command_buffer* cbuf, float cx, float cy, float radius, float a_min, float a_max, float line_thickness, nk_color col);

private delegate void nk_stroke_triangle_t(nk_command_buffer* cbuf, float x0, float y0, float x1, float y1, float x2, float y2, float line_thickness, nk_color col);

private delegate void nk_stroke_polyline_t(nk_command_buffer* cbuf, float* points, int point_count, float line_thickness, nk_color col);

private delegate void nk_stroke_polygon_t(nk_command_buffer* cbuf, float* points, int point_count, float line_thickness, nk_color col);

private delegate void nk_fill_rect_t(nk_command_buffer* cbuf, nk_rect r, float rounding, nk_color col);

private delegate void nk_fill_rect_multi_color_t(nk_command_buffer* cbuf, nk_rect r, nk_color left, nk_color top, nk_color right, nk_color bottom);

private delegate void nk_fill_circle_t(nk_command_buffer* cbuf, nk_rect r, nk_color col);

private delegate void nk_fill_arc_t(nk_command_buffer* cbuf, float cx, float cy, float radius, float a_min, float a_max, nk_color col);

private delegate void nk_fill_triangle_t(nk_command_buffer* cbuf, float x0, float y0, float x1, float y1, float x2, float y2, nk_color col);

private delegate void nk_fill_polygon_t(nk_command_buffer* cbuf, float* pts, int point_count, nk_color col);

private delegate void nk_draw_image_t(nk_command_buffer* cbuf, nk_rect r, nk_image* img, nk_color col);

private delegate void nk_draw_text_t(nk_command_buffer* cbuf, nk_rect r, byte* text, int len, nk_user_font* userfont, nk_color col, nk_color col2);

private delegate void nk_push_scissor_t(nk_command_buffer* cbuf, nk_rect r);

private delegate void nk_push_custom_t(nk_command_buffer* cbuf, nk_rect r, nk_command_custom_callback cb, nk_handle userdata);

private static nk_stroke_line_t _nk_stroke_line = LFT<nk_stroke_line_t>();

private static nk_stroke_curve_t _nk_stroke_curve = LFT<nk_stroke_curve_t>();

private static nk_stroke_rect_t _nk_stroke_rect = LFT<nk_stroke_rect_t>();

private static nk_stroke_circle_t _nk_stroke_circle = LFT<nk_stroke_circle_t>();

private static nk_stroke_arc_t _nk_stroke_arc = LFT<nk_stroke_arc_t>();

private static nk_stroke_triangle_t _nk_stroke_triangle = LFT<nk_stroke_triangle_t>();

private static nk_stroke_polyline_t _nk_stroke_polyline = LFT<nk_stroke_polyline_t>();

private static nk_stroke_polygon_t _nk_stroke_polygon = LFT<nk_stroke_polygon_t>();

private static nk_fill_rect_t _nk_fill_rect = LFT<nk_fill_rect_t>();

private static nk_fill_rect_multi_color_t _nk_fill_rect_multi_color = LFT<nk_fill_rect_multi_color_t>();

private static nk_fill_circle_t _nk_fill_circle = LFT<nk_fill_circle_t>();

private static nk_fill_arc_t _nk_fill_arc = LFT<nk_fill_arc_t>();

private static nk_fill_triangle_t _nk_fill_triangle = LFT<nk_fill_triangle_t>();

private static nk_fill_polygon_t _nk_fill_polygon = LFT<nk_fill_polygon_t>();

private static nk_draw_image_t _nk_draw_image = LFT<nk_draw_image_t>();

private static nk_draw_text_t _nk_draw_text = LFT<nk_draw_text_t>();

private static nk_push_scissor_t _nk_push_scissor = LFT<nk_push_scissor_t>();

private static nk_push_custom_t _nk_push_custom = LFT<nk_push_custom_t>();

public static void nk_stroke_line(nk_command_buffer* cbuf, float x0, float y0, float x1, float y1, float line_thickness, nk_color color) => _nk_stroke_line(cbuf, x0, y0, x1, y1, line_thickness, color);

public static void nk_stroke_curve(nk_command_buffer* cbuf, float x, float y, float x1, float y1, float xa, float ya, float xb, float yb, float line_thickness, nk_color col) => _nk_stroke_curve(cbuf, x, y, x1, y1, xa, ya, xb, yb, line_thickness, col);

public static void nk_stroke_rect(nk_command_buffer* cbuf, nk_rect r, float rounding, float line_thickness, nk_color col) => _nk_stroke_rect(cbuf, r, rounding, line_thickness, col);

public static void nk_stroke_circle(nk_command_buffer* cbuf, nk_rect r, float line_thickness, nk_color col) => _nk_stroke_circle(cbuf, r, line_thickness, col);

public static void nk_stroke_arc(nk_command_buffer* cbuf, float cx, float cy, float radius, float a_min, float a_max, float line_thickness, nk_color col) => _nk_stroke_arc(cbuf, cx, cy, radius, a_min, a_max, line_thickness, col);

public static void nk_stroke_triangle(nk_command_buffer* cbuf, float x0, float y0, float x1, float y1, float x2, float y2, float line_thickness, nk_color col) => _nk_stroke_triangle(cbuf, x0, y0, x1, y1, x2, y2, line_thickness, col);

public static void nk_stroke_polyline(nk_command_buffer* cbuf, float* points, int point_count, float line_thickness, nk_color col) => _nk_stroke_polyline(cbuf, points, point_count, line_thickness, col);

public static void nk_stroke_polygon(nk_command_buffer* cbuf, float* points, int point_count, float line_thickness, nk_color col) => _nk_stroke_polygon(cbuf, points, point_count, line_thickness, col);

public static void nk_fill_rect(nk_command_buffer* cbuf, nk_rect r, float rounding, nk_color col) => _nk_fill_rect(cbuf, r, rounding, col);

public static void nk_fill_rect_multi_color(nk_command_buffer* cbuf, nk_rect r, nk_color left, nk_color top, nk_color right, nk_color bottom) => _nk_fill_rect_multi_color(cbuf, r, left, top, right, bottom);

public static void nk_fill_circle(nk_command_buffer* cbuf, nk_rect r, nk_color col) => _nk_fill_circle(cbuf, r, col);

public static void nk_fill_arc(nk_command_buffer* cbuf, float cx, float cy, float radius, float a_min, float a_max, nk_color col) => _nk_fill_arc(cbuf, cx, cy, radius, a_min, a_max, col);

public static void nk_fill_triangle(nk_command_buffer* cbuf, float x0, float y0, float x1, float y1, float x2, float y2, nk_color col) => _nk_fill_triangle(cbuf, x0, y0, x1, y1, x2, y2, col);

public static void nk_fill_polygon(nk_command_buffer* cbuf, float* pts, int point_count, nk_color col) => _nk_fill_polygon(cbuf, pts, point_count, col);

public static void nk_draw_image(nk_command_buffer* cbuf, nk_rect r, nk_image* img, nk_color col) => _nk_draw_image(cbuf, r, img, col);

public static void nk_draw_text(nk_command_buffer* cbuf, nk_rect r, byte* text, int len, nk_user_font* userfont, nk_color col, nk_color col2) => _nk_draw_text(cbuf, r, text, len, userfont, col, col2);

public static void nk_push_scissor(nk_command_buffer* cbuf, nk_rect r) => _nk_push_scissor(cbuf, r);

public static void nk_push_custom(nk_command_buffer* cbuf, nk_rect r, nk_command_custom_callback cb, nk_handle userdata) => _nk_push_custom(cbuf, r, cb, userdata);

private delegate void nk_draw_list_init_t(nk_draw_list* dl);

private delegate void nk_draw_list_setup_t(nk_draw_list* dl, nk_convert_config* ncc, nk_buffer* cmds, nk_buffer* vertices, nk_buffer* elements, nk_anti_aliasing line_aa, nk_anti_aliasing shape_aa);

// private delegate void nk_draw_list_clear_t(nk_draw_list* dl);

private delegate nk_draw_command* nk__draw_list_begin_t(nk_draw_list* dl, nk_buffer* buf);

private delegate nk_draw_command* nk__draw_list_next_t(nk_draw_command* drawcmd, nk_buffer* buf, nk_draw_list* dl);

private delegate nk_draw_command* nk__draw_list_end_t(nk_draw_list* dl, nk_buffer* buf);

private delegate void nk_draw_list_path_clear_t(nk_draw_list* dl);

private delegate void nk_draw_list_path_line_to_t(nk_draw_list* dl, nk_vec2 pos);

private delegate void nk_draw_list_path_arc_to_fast_t(nk_draw_list* dl, nk_vec2 center, float radius, int a_min, int a_max);

private delegate void nk_draw_list_path_arc_to_t(nk_draw_list* dl, nk_vec2 center, float radius, float a_min, float a_max, uint segments);

private delegate void nk_draw_list_path_rect_to_t(nk_draw_list* dl, nk_vec2 a, nk_vec2 b, float rounding);

private delegate void nk_draw_list_path_curve_to_t(nk_draw_list* dl, nk_vec2 p2, nk_vec2 p3, nk_vec2 p4, uint num_segments);

private delegate void nk_draw_list_path_fill_t(nk_draw_list* dl, nk_color col);

private delegate void nk_draw_list_path_stroke_t(nk_draw_list* dl, nk_color col, nk_draw_list_stroke closed, float thickness);

private delegate void nk_draw_list_stroke_line_t(nk_draw_list* dl, nk_vec2 a, nk_vec2 b, nk_color col, float thickness);

private delegate void nk_draw_list_stroke_rect_t(nk_draw_list* dl, nk_rect rect, nk_color col, float rounding, float thickness);

private delegate void nk_draw_list_stroke_triangle_t(nk_draw_list* dl, nk_vec2 a, nk_vec2 b, nk_vec2 c, nk_color col, float thickness);

private delegate void nk_draw_list_stroke_circle_t(nk_draw_list* dl, nk_vec2 center, float radius, nk_color col, uint segs, float thickness);

private delegate void nk_draw_list_stroke_curve_t(nk_draw_list* dl, nk_vec2 p0, nk_vec2 cp0, nk_vec2 cp1, nk_vec2 p1, nk_color col, uint segments, float thickness);

private delegate void nk_draw_list_stroke_poly_line_t(nk_draw_list* dl, nk_vec2* pnts, uint cnt, nk_color col, nk_draw_list_stroke stroke, float thickness, nk_anti_aliasing aa);

private delegate void nk_draw_list_fill_rect_t(nk_draw_list* dl, nk_rect rect, nk_color col, float rounding);

private delegate void nk_draw_list_fill_rect_multi_color_t(nk_draw_list* dl, nk_rect rect, nk_color left, nk_color top, nk_color right, nk_color bottom);

private delegate void nk_draw_list_fill_triangle_t(nk_draw_list* dl, nk_vec2 a, nk_vec2 b, nk_vec2 c, nk_color col);

private delegate void nk_draw_list_fill_circle_t(nk_draw_list* dl, nk_vec2 center, float radius, nk_color col, uint segs);

private delegate void nk_draw_list_fill_poly_convex_t(nk_draw_list* dl, nk_vec2* points, uint count, nk_color col, nk_anti_aliasing aa);

private delegate void nk_draw_list_add_image_t(nk_draw_list* dl, nk_image texture, nk_rect rect, nk_color col);

private delegate void nk_draw_list_add_text_t(nk_draw_list* dl, nk_user_font* userfont, nk_rect rect, byte* text, int len, float font_height, nk_color col);

private delegate void nk_draw_list_push_userdata_t(nk_draw_list* dl, nk_handle userdata);

private static nk_draw_list_init_t _nk_draw_list_init = LFT<nk_draw_list_init_t>();

private static nk_draw_list_setup_t _nk_draw_list_setup = LFT<nk_draw_list_setup_t>();

// private static nk_draw_list_clear_t _nk_draw_list_clear = LFT<nk_draw_list_clear_t>();

private static nk__draw_list_begin_t _nk__draw_list_begin = LFT<nk__draw_list_begin_t>();

private static nk__draw_list_next_t _nk__draw_list_next = LFT<nk__draw_list_next_t>();

private static nk__draw_list_end_t _nk__draw_list_end = LFT<nk__draw_list_end_t>();

private static nk_draw_list_path_clear_t _nk_draw_list_path_clear = LFT<nk_draw_list_path_clear_t>();

private static nk_draw_list_path_line_to_t _nk_draw_list_path_line_to = LFT<nk_draw_list_path_line_to_t>();

private static nk_draw_list_path_arc_to_fast_t _nk_draw_list_path_arc_to_fast = LFT<nk_draw_list_path_arc_to_fast_t>();

private static nk_draw_list_path_arc_to_t _nk_draw_list_path_arc_to = LFT<nk_draw_list_path_arc_to_t>();

private static nk_draw_list_path_rect_to_t _nk_draw_list_path_rect_to = LFT<nk_draw_list_path_rect_to_t>();

private static nk_draw_list_path_curve_to_t _nk_draw_list_path_curve_to = LFT<nk_draw_list_path_curve_to_t>();

private static nk_draw_list_path_fill_t _nk_draw_list_path_fill = LFT<nk_draw_list_path_fill_t>();

private static nk_draw_list_path_stroke_t _nk_draw_list_path_stroke = LFT<nk_draw_list_path_stroke_t>();

private static nk_draw_list_stroke_line_t _nk_draw_list_stroke_line = LFT<nk_draw_list_stroke_line_t>();

private static nk_draw_list_stroke_rect_t _nk_draw_list_stroke_rect = LFT<nk_draw_list_stroke_rect_t>();

private static nk_draw_list_stroke_triangle_t _nk_draw_list_stroke_triangle = LFT<nk_draw_list_stroke_triangle_t>();

private static nk_draw_list_stroke_circle_t _nk_draw_list_stroke_circle = LFT<nk_draw_list_stroke_circle_t>();

private static nk_draw_list_stroke_curve_t _nk_draw_list_stroke_curve = LFT<nk_draw_list_stroke_curve_t>();

private static nk_draw_list_stroke_poly_line_t _nk_draw_list_stroke_poly_line = LFT<nk_draw_list_stroke_poly_line_t>();

private static nk_draw_list_fill_rect_t _nk_draw_list_fill_rect = LFT<nk_draw_list_fill_rect_t>();

private static nk_draw_list_fill_rect_multi_color_t _nk_draw_list_fill_rect_multi_color = LFT<nk_draw_list_fill_rect_multi_color_t>();

private static nk_draw_list_fill_triangle_t _nk_draw_list_fill_triangle = LFT<nk_draw_list_fill_triangle_t>();

private static nk_draw_list_fill_circle_t _nk_draw_list_fill_circle = LFT<nk_draw_list_fill_circle_t>();

private static nk_draw_list_fill_poly_convex_t _nk_draw_list_fill_poly_convex = LFT<nk_draw_list_fill_poly_convex_t>();

private static nk_draw_list_add_image_t _nk_draw_list_add_image = LFT<nk_draw_list_add_image_t>();

private static nk_draw_list_add_text_t _nk_draw_list_add_text = LFT<nk_draw_list_add_text_t>();

private static nk_draw_list_push_userdata_t _nk_draw_list_push_userdata = LFT<nk_draw_list_push_userdata_t>();

public static void nk_draw_list_init(nk_draw_list* dl) => _nk_draw_list_init(dl);

public static void nk_draw_list_setup(nk_draw_list* dl, nk_convert_config* ncc, nk_buffer* cmds, nk_buffer* vertices, nk_buffer* elements, nk_anti_aliasing line_aa, nk_anti_aliasing shape_aa) => _nk_draw_list_setup(dl, ncc, cmds, vertices, elements, line_aa, shape_aa);

// public static void nk_draw_list_clear(nk_draw_list* dl) => _nk_draw_list_clear(dl);

public static nk_draw_command* nk__draw_list_begin(nk_draw_list* dl, nk_buffer* buf) => _nk__draw_list_begin(dl, buf);

public static nk_draw_command* nk__draw_list_next(nk_draw_command* drawcmd, nk_buffer* buf, nk_draw_list* dl) => _nk__draw_list_next(drawcmd, buf, dl);

public static nk_draw_command* nk__draw_list_end(nk_draw_list* dl, nk_buffer* buf) => _nk__draw_list_end(dl, buf);

public static void nk_draw_list_path_clear(nk_draw_list* dl) => _nk_draw_list_path_clear(dl);

public static void nk_draw_list_path_line_to(nk_draw_list* dl, nk_vec2 pos) => _nk_draw_list_path_line_to(dl, pos);

public static void nk_draw_list_path_arc_to_fast(nk_draw_list* dl, nk_vec2 center, float radius, int a_min, int a_max) => _nk_draw_list_path_arc_to_fast(dl, center, radius, a_min, a_max);

public static void nk_draw_list_path_arc_to(nk_draw_list* dl, nk_vec2 center, float radius, float a_min, float a_max, uint segments) => _nk_draw_list_path_arc_to(dl, center, radius, a_min, a_max, segments);

public static void nk_draw_list_path_rect_to(nk_draw_list* dl, nk_vec2 a, nk_vec2 b, float rounding) => _nk_draw_list_path_rect_to(dl, a, b, rounding);

public static void nk_draw_list_path_curve_to(nk_draw_list* dl, nk_vec2 p2, nk_vec2 p3, nk_vec2 p4, uint num_segments) => _nk_draw_list_path_curve_to(dl, p2, p3, p4, num_segments);

public static void nk_draw_list_path_fill(nk_draw_list* dl, nk_color col) => _nk_draw_list_path_fill(dl, col);

public static void nk_draw_list_path_stroke(nk_draw_list* dl, nk_color col, nk_draw_list_stroke closed, float thickness) => _nk_draw_list_path_stroke(dl, col, closed, thickness);

public static void nk_draw_list_stroke_line(nk_draw_list* dl, nk_vec2 a, nk_vec2 b, nk_color col, float thickness) => _nk_draw_list_stroke_line(dl, a, b, col, thickness);

public static void nk_draw_list_stroke_rect(nk_draw_list* dl, nk_rect rect, nk_color col, float rounding, float thickness) => _nk_draw_list_stroke_rect(dl, rect, col, rounding, thickness);

public static void nk_draw_list_stroke_triangle(nk_draw_list* dl, nk_vec2 a, nk_vec2 b, nk_vec2 c, nk_color col, float thickness) => _nk_draw_list_stroke_triangle(dl, a, b, c, col, thickness);

public static void nk_draw_list_stroke_circle(nk_draw_list* dl, nk_vec2 center, float radius, nk_color col, uint segs, float thickness) => _nk_draw_list_stroke_circle(dl, center, radius, col, segs, thickness);

public static void nk_draw_list_stroke_curve(nk_draw_list* dl, nk_vec2 p0, nk_vec2 cp0, nk_vec2 cp1, nk_vec2 p1, nk_color col, uint segments, float thickness) => _nk_draw_list_stroke_curve(dl, p0, cp0, cp1, p1, col, segments, thickness);

public static void nk_draw_list_stroke_poly_line(nk_draw_list* dl, nk_vec2* pnts, uint cnt, nk_color col, nk_draw_list_stroke stroke, float thickness, nk_anti_aliasing aa) => _nk_draw_list_stroke_poly_line(dl, pnts, cnt, col, stroke, thickness, aa);

public static void nk_draw_list_fill_rect(nk_draw_list* dl, nk_rect rect, nk_color col, float rounding) => _nk_draw_list_fill_rect(dl, rect, col, rounding);

public static void nk_draw_list_fill_rect_multi_color(nk_draw_list* dl, nk_rect rect, nk_color left, nk_color top, nk_color right, nk_color bottom) => _nk_draw_list_fill_rect_multi_color(dl, rect, left, top, right, bottom);

public static void nk_draw_list_fill_triangle(nk_draw_list* dl, nk_vec2 a, nk_vec2 b, nk_vec2 c, nk_color col) => _nk_draw_list_fill_triangle(dl, a, b, c, col);

public static void nk_draw_list_fill_circle(nk_draw_list* dl, nk_vec2 center, float radius, nk_color col, uint segs) => _nk_draw_list_fill_circle(dl, center, radius, col, segs);

public static void nk_draw_list_fill_poly_convex(nk_draw_list* dl, nk_vec2* points, uint count, nk_color col, nk_anti_aliasing aa) => _nk_draw_list_fill_poly_convex(dl, points, count, col, aa);

public static void nk_draw_list_add_image(nk_draw_list* dl, nk_image texture, nk_rect rect, nk_color col) => _nk_draw_list_add_image(dl, texture, rect, col);

public static void nk_draw_list_add_text(nk_draw_list* dl, nk_user_font* userfont, nk_rect rect, byte* text, int len, float font_height, nk_color col) => _nk_draw_list_add_text(dl, userfont, rect, text, len, font_height, col);

public static void nk_draw_list_push_userdata(nk_draw_list* dl, nk_handle userdata) => _nk_draw_list_push_userdata(dl, userdata);

}