Created
June 26, 2016 05:08
-
-
Save vaiorabbit/dfff40408c1b3ff36974827723dd43b0 to your computer and use it in GitHub Desktop.
(Experimental) Ruby bindings for the Nuklear GUI toolkit ( https://github.com/vurtun/nuklear )
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
require 'ffi' | |
module Nuklear | |
extend FFI::Library | |
NK_UTF_INVALID = 0xFFFD | |
NK_UTF_SIZE = 4 | |
NK_INPUT_MAX = 16 | |
NK_MAX_NUMBER_BUFFER = 64 | |
typedef :int16, :nk_short | |
typedef :uint16, :nk_ushort | |
typedef :int32, :nk_int | |
typedef :uint32, :nk_uint | |
typedef :uint32, :nk_hash | |
typedef :uintptr_t, :nk_size | |
typedef :uintptr_t, :nk_ptr | |
typedef :uint32, :nk_flags | |
typedef :uint32, :nk_rune | |
typedef :uint8, :nk_byte | |
NK_FALSE = 0 | |
NK_TRUE = 1 | |
class NK_COLOR < FFI::Struct | |
layout :r, :nk_byte, | |
:g, :nk_byte, | |
:b, :nk_byte, | |
:a, :nk_byte | |
end | |
class NK_VEC2 < FFI::Struct | |
layout :x, :float, | |
:y, :float | |
end | |
class NK_VEC2I < FFI::Struct | |
layout :x, :short, | |
:y, :short | |
end | |
class NK_RECT < FFI::Struct | |
layout :x, :float, | |
:y, :float, | |
:w, :float, | |
:h, :float | |
end | |
class NK_RECTI < FFI::Struct | |
layout :x, :short, | |
:y, :short, | |
:w, :short, | |
:h, :short | |
end | |
class NK_GLYPH < FFI::Struct | |
layout :val, [:char, 8] | |
def [](index) # Note | |
val[index] | |
end | |
end | |
class NK_HANDLE < FFI::Union | |
layout :ptr, :pointer, | |
:id, :int | |
end | |
class NK_IMAGE < FFI::Struct | |
layout :handle, NK_HANDLE, | |
:w, :ushort, | |
:h, :ushort, | |
:region, [:ushort, 4] | |
end | |
class NK_SCROLL < FFI::Struct | |
layout :x, :ushort, | |
:y, :ushort | |
end | |
NK_HEADING = enum :nk_up, :nk_right, :nk_down, :nk_left | |
callback :nk_filter, [:pointer, :nk_rune], :int32 | |
callback :nk_paste_f, [NK_HANDLE, :pointer], :void | |
callback :nk_copy_f, [NK_HANDLE, :pointer, :int32], :void | |
NK_BUTTON_BEHAVIOR = enum :NK_BUTTON_DEFAULT, :NK_BUTTON_REPEATER | |
NK_MODIFY = enum :NK_FIXED, 0, :NK_MODIFIABLE, 1 | |
NK_ORIENTATION = enum :NK_VERTICAL, :NK_HORIZONTAL | |
NK_COLLAPSE_STATES = enum :NK_MINIMIZED, 0, :NK_MAXIMIZED, 1 | |
NK_SHOW_STATES = enum :NK_HIDDEN, 0, :NK_SHOWN, 1 | |
NK_CHART_TYPE = enum :NK_CHART_LINES, :NK_CHART_COLUMN, :NK_CHART_MAX | |
NK_CHART_EVENT = enum :NK_CHART_HOVERING, 0x01, :NK_CHART_CLICKED, 0x02 | |
NK_COLOR_FORMAT = enum :NK_RGB, :NK_RGBA | |
NK_POPUP_TYPE = enum :NK_POPUP_STATIC, :NK_POPUP_DYNAMIC | |
NK_LAYOUT_FORMAT = enum :NK_DYNAMIC, :NK_STATIC | |
NK_TREE_TYPE = enum :NK_TREE_NODE, :NK_TREE_TAB | |
NK_ANTI_ALIASING = enum :NK_ANTI_ALIASING_OFF, :NK_ANTI_ALIASING_ON | |
callback :nk_alloc_f, [NK_HANDLE, :pointer, :nk_size], :pointer # Added for Ruby | |
callback :nk_free_f, [NK_HANDLE, :pointer], :void # Added for Ruby | |
class NK_ALLOCATOR < FFI::Struct | |
layout :userdata, NK_HANDLE, | |
:alloc, :nk_alloc_f, | |
:free, :nk_free_f | |
end | |
class NK_DRAW_NULL_TEXTURE < FFI::Struct | |
layout :texture, NK_HANDLE, | |
:uv, NK_VEC2 | |
end | |
class NK_CONVERT_CONFIG < FFI::Struct | |
layout :global_alpha, :float, | |
:line_AA, NK_ANTI_ALIASING, | |
:shape_AA, NK_ANTI_ALIASING, | |
:circle_segment_count, :uint32, | |
:arc_segment_count, :uint32, | |
:curve_segment_count, :uint32, | |
:null, NK_DRAW_NULL_TEXTURE | |
end | |
NK_SYMBOL_TYPE = enum :NK_SYMBOL_NONE, | |
:NK_SYMBOL_X, | |
:NK_SYMBOL_UNDERSCORE, | |
:NK_SYMBOL_CIRCLE, | |
:NK_SYMBOL_CIRCLE_FILLED, | |
:NK_SYMBOL_RECT, | |
:NK_SYMBOL_RECT_FILLED, | |
:NK_SYMBOL_TRIANGLE_UP, | |
:NK_SYMBOL_TRIANGLE_DOWN, | |
:NK_SYMBOL_TRIANGLE_LEFT, | |
:NK_SYMBOL_TRIANGLE_RIGHT, | |
:NK_SYMBOL_PLUS, | |
:NK_SYMBOL_MINUS, | |
:NK_SYMBOL_MAX | |
NK_KEYS = enum :NK_KEY_NONE, | |
:NK_KEY_SHIFT, | |
:NK_KEY_CTRL, | |
:NK_KEY_DEL, | |
:NK_KEY_ENTER, | |
:NK_KEY_TAB, | |
:NK_KEY_BACKSPACE, | |
:NK_KEY_COPY, | |
:NK_KEY_CUT, | |
:NK_KEY_PASTE, | |
:NK_KEY_UP, | |
:NK_KEY_DOWN, | |
:NK_KEY_LEFT, | |
:NK_KEY_RIGHT, | |
# | |
:NK_KEY_TEXT_INSERT_MODE, | |
:NK_KEY_TEXT_REPLACE_MODE, | |
:NK_KEY_TEXT_RESET_MODE, | |
:NK_KEY_TEXT_LINE_START, | |
:NK_KEY_TEXT_LINE_END, | |
:NK_KEY_TEXT_START, | |
:NK_KEY_TEXT_END, | |
:NK_KEY_TEXT_UNDO, | |
:NK_KEY_TEXT_REDO, | |
:NK_KEY_TEXT_WORD_LEFT, | |
:NK_KEY_TEXT_WORD_RIGHT, | |
# | |
:NK_KEY_SCROLL_START, | |
:NK_KEY_SCROLL_END, | |
:NK_KEY_SCROLL_DOWN, | |
:NK_KEY_SCROLL_UP, | |
# | |
:NK_KEY_MAX | |
NK_BUTTONS = enum :NK_BUTTON_LEFT, | |
:NK_BUTTON_MIDDLE, | |
:NK_BUTTON_RIGHT, | |
:NK_BUTTON_MAX | |
NK_STYLE_COLORS = enum :NK_COLOR_TEXT, | |
:NK_COLOR_WINDOW, | |
:NK_COLOR_HEADER, | |
:NK_COLOR_BORDER, | |
:NK_COLOR_BUTTON, | |
:NK_COLOR_BUTTON_HOVER, | |
:NK_COLOR_BUTTON_ACTIVE, | |
:NK_COLOR_TOGGLE, | |
:NK_COLOR_TOGGLE_HOVER, | |
:NK_COLOR_TOGGLE_CURSOR, | |
:NK_COLOR_SELECT, | |
:NK_COLOR_SELECT_ACTIVE, | |
:NK_COLOR_SLIDER, | |
:NK_COLOR_SLIDER_CURSOR, | |
:NK_COLOR_SLIDER_CURSOR_HOVER, | |
:NK_COLOR_SLIDER_CURSOR_ACTIVE, | |
:NK_COLOR_PROPERTY, | |
:NK_COLOR_EDIT, | |
:NK_COLOR_EDIT_CURSOR, | |
:NK_COLOR_COMBO, | |
:NK_COLOR_CHART, | |
:NK_COLOR_CHART_COLOR, | |
:NK_COLOR_CHART_COLOR_HIGHLIGHT, | |
:NK_COLOR_SCROLLBAR, | |
:NK_COLOR_SCROLLBAR_CURSOR, | |
:NK_COLOR_SCROLLBAR_CURSOR_HOVER, | |
:NK_COLOR_SCROLLBAR_CURSOR_ACTIVE, | |
:NK_COLOR_TAB_HEADER, | |
:NK_COLOR_COUNT | |
NK_WIDGET_LAYOUT_STATES = enum :NK_WIDGET_INVALID, | |
:NK_WIDGET_VALID, | |
:NK_WIDGET_ROM | |
NK_WIDGET_STATES = enum :NK_WIDGET_STATE_MODIFIED, (1 << 1), | |
:NK_WIDGET_STATE_INACTIVE, (1 << 2), | |
:NK_WIDGET_STATE_ENTERED, (1 << 3), | |
:NK_WIDGET_STATE_HOVER, (1 << 4), | |
:NK_WIDGET_STATE_ACTIVED, (1 << 5), | |
:NK_WIDGET_STATE_LEFT, (1 << 6), | |
:NK_WIDGET_STATE_HOVERED, ((1 << 4)|(1 << 1)), # (NK_WIDGET_STATE_HOVER|NK_WIDGET_STATE_MODIFIED), | |
:NK_WIDGET_STATE_ACTIVE, ((1 << 5)|(1 << 1)) # (:NK_WIDGET_STATE_ACTIVED|:NK_WIDGET_STATE_MODIFIED) | |
NK_TEXT_ALIGN = enum :NK_TEXT_ALIGN_LEFT, 0x01, | |
:NK_TEXT_ALIGN_CENTERED, 0x02, | |
:NK_TEXT_ALIGN_RIGHT, 0x04, | |
:NK_TEXT_ALIGN_TOP, 0x08, | |
:NK_TEXT_ALIGN_MIDDLE, 0x10, | |
:NK_TEXT_ALIGN_BOTTOM, 0x20 | |
NK_TEXT_ALIGNMENT = enum :NK_TEXT_LEFT, 0x10|0x01, # :NK_TEXT_ALIGN_MIDDLE|:NK_TEXT_ALIGN_LEFT, | |
:NK_TEXT_CENTERED, 0x10|0x02, # :NK_TEXT_ALIGN_MIDDLE|:NK_TEXT_ALIGN_CENTERED, | |
:NK_TEXT_RIGHT, 0x10|0x04 # :NK_TEXT_ALIGN_MIDDLE|:NK_TEXT_ALIGN_RIGHT | |
NK_EDIT_FLAGS = enum :NK_EDIT_DEFAULT, 0, | |
:NK_EDIT_READ_ONLY, (1 << 0), | |
:NK_EDIT_AUTO_SELECT, (1 << 1), | |
:NK_EDIT_SIG_ENTER, (1 << 2), | |
:NK_EDIT_ALLOW_TAB, (1 << 3), | |
:NK_EDIT_NO_CURSOR, (1 << 4), | |
:NK_EDIT_SELECTABLE, (1 << 5), | |
:NK_EDIT_CLIPBOARD, (1 << 6), | |
:NK_EDIT_CTRL_ENTER_NEWLINE, (1 << 7), | |
:NK_EDIT_NO_HORIZONTAL_SCROLL, (1 << 8), | |
:NK_EDIT_ALWAYS_INSERT_MODE, (1 << 9), | |
:NK_EDIT_MULTILINE, (1 << 11) | |
NK_EDIT_TYPES = enum :NK_EDIT_SIMPLE, (1 << 9), # :NK_EDIT_ALWAYS_INSERT_MODE, | |
:NK_EDIT_FIELD, (1 << 9)|(1 << 5), # :NK_EDIT_SIMPLE|:NK_EDIT_SELECTABLE, | |
:NK_EDIT_BOX, (1 << 9)|(1 << 5)|(1 << 11)|(1 << 3), # :NK_EDIT_ALWAYS_INSERT_MODE| :NK_EDIT_SELECTABLE|:NK_EDIT_MULTILINE|:NK_EDIT_ALLOW_TAB, | |
:NK_EDIT_EDITOR, (1 << 5)|(1 << 11)|(1 << 3)|(1 << 6) # :NK_EDIT_SELECTABLE|:NK_EDIT_MULTILINE|:NK_EDIT_ALLOW_TAB|:NK_EDIT_CLIPBOARD | |
NK_EDIT_EVENTS = enum :NK_EDIT_ACTIVE, (1 << 0), | |
:NK_EDIT_INACTIVE, (1 << 1), | |
:NK_EDIT_ACTIVATED, (1 << 2), | |
:NK_EDIT_DEACTIVATED, (1 << 3), | |
:NK_EDIT_COMMITED, (1 << 4) | |
NK_PANEL_FLAGS = enum :NK_WINDOW_BORDER, (1 << 0), | |
:NK_WINDOW_BORDER_HEADER, (1 << 1), | |
:NK_WINDOW_MOVABLE, (1 << 2), | |
:NK_WINDOW_SCALABLE, (1 << 3), | |
:NK_WINDOW_CLOSABLE, (1 << 4), | |
:NK_WINDOW_MINIMIZABLE, (1 << 5), | |
:NK_WINDOW_DYNAMIC, (1 << 6), | |
:NK_WINDOW_NO_SCROLLBAR, (1 << 7), | |
:NK_WINDOW_TITLE, (1 << 8) | |
def nk_foreach(ctx, &blk) | |
cmd = nk__begin(ctx) | |
while cmd.null? == false | |
blk.call(ctx, cmd) | |
cmd = nk__next(ctx, cmd) | |
end | |
end | |
def nk_draw_foreach(ctx, buf, &blk) | |
cmd = nk__draw_begin(ctx, buf) | |
while cmd.null? == false | |
blk.call(cmd) | |
cmd = nk__draw_next(cmd, buf, ctx) | |
end | |
end | |
# | |
# MEMORY BUFFER | |
# | |
class NK_MEMORY_STATUS < FFI::Struct | |
layout :memory, :pointer, | |
:type, :uint32, | |
:size, :nk_size, | |
:allocated, :nk_size, | |
:needed, :nk_size, | |
:calls, :nk_size | |
end | |
NK_ALLOCATION_TYPE = enum :NK_BUFFER_FIXED, | |
:NK_BUFFER_DYNAMIC | |
NK_BUFFER_ALLOCATION_TYPE = enum :NK_BUFFER_FRONT, | |
:NK_BUFFER_BACK, | |
:NK_BUFFER_MAX | |
class NK_BUFFER_MARKER < FFI::Struct | |
layout :active, :int32, | |
:offset, :nk_size | |
end | |
class NK_MEMORY < FFI::Struct | |
layout :ptr, :pointer, | |
:size, :nk_size | |
end | |
class NK_BUFFER < FFI::Struct | |
layout :marker, [NK_BUFFER_MARKER, NK_BUFFER_ALLOCATION_TYPE[:NK_BUFFER_MAX]], | |
:pool, NK_ALLOCATOR, | |
:type, NK_ALLOCATION_TYPE, | |
:memory, NK_MEMORY, | |
:grow_factor, :float, | |
:allocated, :nk_size, | |
:needed, :nk_size, | |
:calls, :nk_size, | |
:size, :nk_size | |
end | |
# | |
# STRING | |
# | |
class NK_STR < FFI::Struct | |
layout :buffer, NK_BUFFER, | |
:len, :int32 | |
end | |
# | |
# TEXT EDITOR | |
# | |
NK_TEXTEDIT_UNDOSTATECOUNT = 99 | |
NK_TEXTEDIT_UNDOCHARCOUNT = 999 | |
class NK_CLIPBOARD < FFI::Struct | |
layout :userdata, NK_HANDLE, | |
:paste, :nk_paste_f, | |
:copy, :nk_copy_f | |
end | |
class NK_TEXT_UNDO_RECORD < FFI::Struct | |
layout :where, :int32, | |
:insert_length, :short, | |
:delete_length, :short, | |
:char_storage, :short | |
end | |
class NK_TEXT_UNDO_STATE < FFI::Struct | |
layout :undo_rec, [NK_TEXT_UNDO_RECORD, NK_TEXTEDIT_UNDOSTATECOUNT], | |
:undo_char, [:nk_rune, NK_TEXTEDIT_UNDOCHARCOUNT], | |
:undo_point, :short, | |
:redo_point, :short, | |
:undo_char_point, :short, | |
:redo_char_point, :short | |
end | |
NK_TEXT_EDIT_TYPE = enum :NK_TEXT_EDIT_SINGLE_LINE, | |
:NK_TEXT_EDIT_MULTI_LINE | |
NK_TEXT_EDIT_MODE = enum :NK_TEXT_EDIT_MODE_VIEW, | |
:NK_TEXT_EDIT_MODE_INSERT, | |
:NK_TEXT_EDIT_MODE_REPLACE | |
class NK_TEXT_EDIT < FFI::Struct | |
layout :clip, NK_CLIPBOARD, | |
:string, NK_STR, | |
:filter, :nk_filter, | |
:scrollbar, NK_VEC2, | |
:cursor, :int32, | |
:select_start, :int32, | |
:select_end, :int32, | |
:mode, :uint8, | |
:cursor_at_end_of_line, :uint8, | |
:initialized, :uint8, | |
:has_preferred_x, :uint8, | |
:single_line, :uint8, | |
:active, :uint8, | |
:padding1, :uint8, | |
:preferred_x, :float, | |
:undo, NK_TEXT_UNDO_STATE | |
end | |
# | |
# FONT | |
# | |
callback :nk_text_width_f, [NK_HANDLE, :float, :pointer, :int32], :float | |
callback :nk_query_font_glyph_f, [NK_HANDLE, :float, :pointer, :nk_rune, :nk_rune], :float | |
class NK_USER_FONT_GLYPH < FFI::Struct | |
layout :uv, [NK_VEC2, 2], | |
:offset, NK_VEC2, | |
:width, :float, | |
:height, :float, | |
:xadvance, :float | |
end | |
class NK_USER_FONT < FFI::Struct | |
layout :userdata, NK_HANDLE, | |
:height, :float, | |
:width, :nk_text_width_f, | |
:query, :nk_query_font_glyph_f, # NOTE : available only if NK_INCLUDE_VERTEX_BUFFER_OUTPUT is defined. | |
:texture, NK_HANDLE # NOTE : available only if NK_INCLUDE_VERTEX_BUFFER_OUTPUT is defined. | |
end | |
# /// NOTE : The section below is available only if NK_INCLUDE_FONT_BAKING is defined. \\\ | |
NK_FONT_COORD_TYPE = enum :NK_COORD_UV, | |
:NK_COORD_PIXEL | |
class NK_BAKED_FONT < FFI::Struct | |
layout :height, :float, | |
:ascent, :float, | |
:descent, :float, | |
:glyph_offset, :nk_rune, | |
:glyph_count, :nk_rune, | |
:ranges, :pointer # const nk_rune *ranges; | |
end | |
class NK_FONT_CONFIG < FFI::Struct | |
layout :ttf_blob, :pointer, | |
:ttf_size, :nk_size, | |
:ttf_data_owned_by_atlas, :uint8, | |
:merge_mode, :uint8, | |
:pixel_snap, :uint8, | |
:oversample_v, :uint8, | |
:oversample_h, :uint8, | |
:padding, [:uint8, 3], | |
:size, :float, | |
:coord_type, NK_FONT_COORD_TYPE, | |
:sapcing, NK_VEC2, | |
:range, :pointer, # const nk_rune *range; | |
:font, :pointer, # struct nk_baked_font *font; | |
:fallback_glyph, :nk_rune | |
end | |
class NK_FONT_GLYPH < FFI::Struct | |
layout :codepoint, :nk_rune, | |
:xadvance, :float, | |
:x0, :float, | |
:y0, :float, | |
:x1, :float, | |
:y1, :float, | |
:w, :float, | |
:h, :float, | |
:u0, :float, | |
:v0, :float, | |
:u1, :float, | |
:v1, :float | |
end | |
class NK_FONT < FFI::Struct | |
layout :handle, NK_USER_FONT, | |
:info, NK_BAKED_FONT, | |
:scale, :float, | |
:glyphs, :pointer, # struct nk_font_glyph *glyphs; | |
:fallback, :pointer, # const struct nk_font_glyph *fallback; | |
:fallback_codepoint, :nk_rune, | |
:texture, NK_HANDLE, | |
:config, :int32 | |
end | |
NK_FONT_ATLAS_FORMAT = enum :NK_FONT_ATLAS_ALPHA8, | |
:NK_FONT_ATLAS_RGBA32 | |
class NK_FONT_ATLAS < FFI::Struct | |
layout :pixel, :pointer, | |
:tex_width, :int32, | |
:tex_height, :int32, | |
:permanent, NK_ALLOCATOR, | |
:temporary, NK_ALLOCATOR, | |
:custom, NK_RECTI, | |
:glyph_count, :int32, | |
:default_font, :pointer, # struct nk_font *default_font; | |
:glyphs, :pointer, # struct nk_font_glyph *glyphs; | |
:fonts, :pointer, # struct nk_font **fonts; | |
:config, :pointer, # struct nk_font_config *config; | |
:font_num, :int32, | |
:font_cap, :int32 | |
end | |
# Font Atlas | |
# Font | |
# Font Baking | |
# \\\ NOTE : The section above is available only if NK_INCLUDE_FONT_BAKING is defined. /// | |
# | |
# DRAWING | |
# | |
NK_COMMAND_TYPE = enum :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 | |
class NK_COMMAND < FFI::Struct | |
layout :type, NK_COMMAND_TYPE, | |
:next, :nk_size, | |
:userdata, NK_HANDLE # NOTE : available only if NK_INCLUDE_COMMAND_USERDATA is defined. | |
end | |
class NK_COMMAND_SCISSOR < FFI::Struct | |
layout :header, NK_COMMAND, | |
:x, :short, | |
:y, :short, | |
:w, :ushort, | |
:h, :ushort | |
end | |
class NK_COMMAND_LINE < FFI::Struct | |
layout :header, NK_COMMAND, | |
:line_thickness, :ushort, | |
:begin, NK_VEC2I, | |
:end, NK_VEC2I, | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_CURVE < FFI::Struct | |
layout :header, NK_COMMAND, | |
:line_thickness, :ushort, | |
:begin, NK_VEC2I, | |
:end, NK_VEC2I, | |
:ctrl, [NK_VEC2I, 2], | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_RECT < FFI::Struct | |
layout :header, NK_COMMAND, | |
:rounding, :ushort, | |
:line_thickness, :ushort, | |
:x, :short, | |
:y, :short, | |
:w, :ushort, | |
:h, :ushort, | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_RECT_FILLED < FFI::Struct | |
layout :header, NK_COMMAND, | |
:rounding, :ushort, | |
:x, :short, | |
:y, :short, | |
:w, :ushort, | |
:h, :ushort, | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_RECT_MULTI_COLOR < FFI::Struct | |
layout :header, NK_COMMAND, | |
:x, :short, | |
:y, :short, | |
:w, :ushort, | |
:h, :ushort, | |
:left, NK_COLOR, | |
:top, NK_COLOR, | |
:bottom, NK_COLOR, | |
:right, NK_COLOR | |
end | |
class NK_COMMAND_TRIANGLE < FFI::Struct | |
layout :header, NK_COMMAND, | |
:line_thickness, :ushort, | |
:a, NK_VEC2I, | |
:b, NK_VEC2I, | |
:c, NK_VEC2I, | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_TRIANGLE_FILLED < FFI::Struct | |
layout :header, NK_COMMAND, | |
:a, NK_VEC2I, | |
:b, NK_VEC2I, | |
:c, NK_VEC2I, | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_CIRCLE < FFI::Struct | |
layout :header, NK_COMMAND, | |
:x, :short, | |
:y, :short, | |
:line_thickness, :ushort, | |
:w, :ushort, | |
:h, :ushort, | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_CIRCLE_FILLED < FFI::Struct | |
layout :header, NK_COMMAND, | |
:x, :short, | |
:y, :short, | |
:w, :ushort, | |
:h, :ushort, | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_ARC < FFI::Struct | |
layout :header, NK_COMMAND, | |
:cx, :short, | |
:cy, :short, | |
:r, :ushort, | |
:line_thickness, :ushort, | |
:a, [:float, 2], | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_ARC_FILLED < FFI::Struct | |
layout :header, NK_COMMAND, | |
:cx, :short, | |
:cy, :short, | |
:r, :ushort, | |
:a, [:float, 2], | |
:color, NK_COLOR | |
end | |
class NK_COMMAND_POLYGON < FFI::Struct | |
layout :header, NK_COMMAND, | |
:color, NK_COLOR, | |
:line_thickness, :ushort, | |
:point_count, :ushort, | |
:points, :pointer # NOTE : Originally defined here is 'struct nk_vec2i points[1];'. | |
end | |
class NK_COMMAND_POLYGON_FILLED < FFI::Struct | |
layout :header, NK_COMMAND, | |
:color, NK_COLOR, | |
:point_count, :ushort, | |
:points, :pointer # NOTE : Originally defined here is 'struct nk_vec2i points[1];'. | |
end | |
class NK_COMMAND_POLYLINE < FFI::Struct | |
layout :header, NK_COMMAND, | |
:color, NK_COLOR, | |
:line_thickness, :ushort, | |
:point_count, :ushort, | |
:points, :pointer # NOTE : Originally defined here is 'struct nk_vec2i points[1];'. | |
end | |
class NK_COMMAND_IMAGE < FFI::Struct | |
layout :header, NK_COMMAND, | |
:x, :short, | |
:y, :short, | |
:w, :ushort, | |
:h, :ushort, | |
:img, NK_IMAGE | |
end | |
class NK_COMMAND_TEXT < FFI::Struct | |
layout :header, NK_COMMAND, | |
:font, :pointer, # const struct nk_user_font *font; | |
:background, NK_COLOR, | |
:foreground, NK_COLOR, | |
:x, :short, | |
:y, :short, | |
:w, :ushort, | |
:h, :ushort, | |
:height, :float, | |
:length, :int32, | |
:strng, :pointer # NOTE : Originally defined here is 'char string[1];'. | |
end | |
NK_COMMAND_CLIPPING = enum :NK_CLIPPING_OFF, NK_FALSE, | |
:NK_CLIPPING_ON, NK_TRUE | |
class NK_COMMAND_BUFFER < FFI::Struct | |
layout :base, :pointer, # struct nk_buffer *base; | |
:clip, NK_RECT, | |
:use_clipping, :int32, | |
:userdata, NK_HANDLE, | |
:begin, :nk_size, | |
:end, :nk_size, | |
:last, :nk_size | |
end | |
# | |
# INPUT | |
# | |
class NK_MOUSE_BUTTON < FFI::Struct | |
layout :down, :int32, | |
:clicked, :uint32, | |
:clicked_pos, NK_VEC2 | |
end | |
class NK_MOUSE < FFI::Struct | |
layout :buttons, [NK_MOUSE_BUTTON, NK_BUTTONS[:NK_BUTTON_MAX]], | |
:pos, NK_VEC2, | |
:prev, NK_VEC2, | |
:delta, NK_VEC2, | |
:scroll_delta, :float, | |
:grab, :uint8, | |
:grabbed, :uint8, | |
:ungrab, :uint8 | |
end | |
class NK_KEY < FFI::Struct | |
layout :down, :int32, | |
:clicked, :uint32 | |
end | |
class NK_KEYBOARD < FFI::Struct | |
layout :keys, [NK_KEY, NK_KEYS[:NK_KEY_MAX]], | |
:text, [:int8, NK_INPUT_MAX], | |
:text_en, :int32 | |
end | |
class NK_INPUT < FFI::Struct | |
layout :keyboard, NK_KEYBOARD, | |
:mouse, NK_MOUSE | |
end | |
# | |
# DRAW LIST | |
# | |
# /// NOTE : The section below is available only if NK_INCLUDE_FONT_BAKING is defined. \\\ | |
typedef :ushort, :nk_draw_index | |
typedef :nk_uint, :nk_draw_vertex_color | |
NK_DRAW_LIST_STROKE = enum :NK_STROKE_OPEN, NK_FALSE, | |
:NK_STROKE_CLOSED, NK_TRUE | |
class NK_DRAW_VERTEX < FFI::Struct | |
layout :position, NK_VEC2, | |
:uv, NK_VEC2, | |
:col, :nk_draw_vertex_color | |
end | |
class NK_DRAW_COMMAND < FFI::Struct | |
layout :elem_count, :uint32, | |
:clip_rect, NK_RECT, | |
:texture, NK_HANDLE | |
end | |
class NK_DRAW_LIST < FFI::Struct | |
layout :global_alpha, :float, | |
:shape_AA, NK_ANTI_ALIASING, | |
:line_AA, NK_ANTI_ALIASING, | |
:null, NK_DRAW_NULL_TEXTURE, | |
:clip_rect, NK_RECT, | |
:buffer, :pointer, # NK_BUFFER | |
:vertices, :pointer, # NK_BUFFER | |
:elements, :pointer, # NK_BUFFER | |
:element_count, :uint32, | |
:vertex_count, :uint32, | |
:cmd_offset, :nk_size, | |
:cmd_count, :uint32, | |
:path_count, :uint32, | |
:path_offset, :uint32, | |
:circle_vtx, [NK_VEC2, 12] | |
end | |
# \\\ NOTE : The section above is available only if NK_INCLUDE_FONT_BAKING is defined. /// | |
# | |
# GUI | |
# | |
NK_STYLE_ITEM_TYPE = enum :NK_STYLE_ITEM_COLOR, | |
:NK_STYLE_ITEM_IMAGE | |
class NK_STYLE_ITEM_DATA < FFI::Union | |
layout :image, NK_IMAGE, | |
:color, NK_COLOR | |
end | |
class NK_STYLE_ITEM < FFI::Struct | |
layout :type, NK_STYLE_ITEM_TYPE, | |
:data, NK_STYLE_ITEM_DATA | |
end | |
class NK_STYLE_TEXT < FFI::Struct | |
layout :color, NK_COLOR, | |
:padding, NK_VEC2 | |
end | |
callback :nk_draw_begin_f, [:pointer, NK_HANDLE], :void # Added for Ruby | |
callback :nk_draw_end_f, [:pointer, NK_HANDLE], :void # Added for Ruby | |
class NK_STYLE_BUTTON < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:active, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
# | |
:text_background, NK_COLOR, | |
:text_normal, NK_COLOR, | |
:text_hover, NK_COLOR, | |
:text_active, NK_COLOR, | |
:text_alignment, :nk_flags, | |
# | |
:border, :float, | |
:rounding, :float, | |
:padding, NK_VEC2, | |
:image_padding, NK_VEC2, | |
:touch_padding, NK_VEC2, | |
# | |
:userdata, NK_HANDLE, | |
:draw_begin, :nk_draw_begin_f, | |
:draw_end, :nk_draw_end_f | |
end | |
class NK_STYLE_TOGGLE < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:active, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
# | |
:cursor_normal, NK_STYLE_ITEM, | |
:cursor_hover, NK_STYLE_ITEM, | |
# | |
:text_normal, NK_COLOR, | |
:text_hover, NK_COLOR, | |
:text_active, NK_COLOR, | |
:text_background, NK_COLOR, | |
:text_alignment, :nk_flags, | |
# | |
:padding, NK_VEC2, | |
:touch_padding, NK_VEC2, | |
:spacing, :float, | |
:border, :float, | |
# | |
:userdata, NK_HANDLE, | |
:draw_begin, :nk_draw_begin_f, | |
:draw_end, :nk_draw_end_f | |
end | |
class NK_STYLE_SELECTABLE < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:pressed, NK_STYLE_ITEM, | |
# | |
:normal_active, NK_STYLE_ITEM, | |
:hover_active, NK_STYLE_ITEM, | |
:pressed_active, NK_STYLE_ITEM, | |
# | |
:text_normal, NK_COLOR, | |
:text_hover, NK_COLOR, | |
:text_pressed, NK_COLOR, | |
# | |
:text_normal_active, NK_COLOR, | |
:text_hover_active, NK_COLOR, | |
:text_pressed_active, NK_COLOR, | |
:text_background, NK_COLOR, | |
:text_alignment, :nk_flags, | |
# | |
:rounding, :float, | |
:padding, NK_VEC2, | |
:touch_padding, NK_VEC2, | |
:image_padding, NK_VEC2, | |
# | |
:userdata, NK_HANDLE, | |
:draw_begin, :nk_draw_begin_f, | |
:draw_end, :nk_draw_end_f | |
end | |
class NK_STYLE_SLIDER < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:active, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
# | |
:bar_normal, NK_COLOR, | |
:bar_hover, NK_COLOR, | |
:bar_active, NK_COLOR, | |
:bar_filled, NK_COLOR, | |
# | |
:cursor_normal, NK_STYLE_ITEM, | |
:cursor_hover, NK_STYLE_ITEM, | |
:cursor_active, NK_STYLE_ITEM, | |
# | |
:border, :float, | |
:rounding, :float, | |
:bar_height, :float, | |
:padding, NK_VEC2, | |
:spacing, NK_VEC2, | |
:cursor_size, NK_VEC2, | |
# | |
:show_buttons, :int32, | |
:inc_button, NK_STYLE_BUTTON, | |
:dec_button, NK_STYLE_BUTTON, | |
:inc_symbol, NK_SYMBOL_TYPE, | |
:dec_symbol, NK_SYMBOL_TYPE, | |
# | |
:userdata, NK_HANDLE, | |
:draw_begin, :nk_draw_begin_f, | |
:draw_end, :nk_draw_end_f | |
end | |
class NK_STYLE_PROGRESS < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:active, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
# | |
:cursor_normal, NK_STYLE_ITEM, | |
:cursor_hover, NK_STYLE_ITEM, | |
:cursor_active, NK_STYLE_ITEM, | |
:cursor_border_color, NK_COLOR, | |
# | |
:rounding, :float, | |
:border, :float, | |
:cursor_border, :float, | |
:cursor_rounding, :float, | |
:padding, NK_VEC2, | |
# | |
:userdata, NK_HANDLE, | |
:draw_begin, :nk_draw_begin_f, | |
:draw_end, :nk_draw_end_f | |
end | |
class NK_STYLE_SCROLLBAR < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:active, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
# | |
:cursor_normal, NK_STYLE_ITEM, | |
:cursor_hover, NK_STYLE_ITEM, | |
:cursor_active, NK_STYLE_ITEM, | |
:cursor_border_color, NK_COLOR, | |
# | |
:border, :float, | |
:rounding, :float, | |
:border_cursor, :float, | |
:rounding_cursor, :float, | |
:padding, NK_VEC2, | |
# | |
:show_buttons, :int32, | |
:inc_button, NK_STYLE_BUTTON, | |
:dec_button, NK_STYLE_BUTTON, | |
:inc_symbol, NK_SYMBOL_TYPE, | |
:dec_symbol, NK_SYMBOL_TYPE, | |
# | |
:userdata, NK_HANDLE, | |
:draw_begin, :nk_draw_begin_f, | |
:draw_end, :nk_draw_end_f | |
end | |
class NK_STYLE_EDIT < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:active, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
:scrollbar, NK_STYLE_SCROLLBAR, | |
# | |
:cursor_normal, NK_COLOR, | |
:cursor_hover, NK_COLOR, | |
:cursor_text_normal, NK_COLOR, | |
:cursor_text_hover, NK_COLOR, | |
# | |
:text_normal, NK_COLOR, | |
:text_hover, NK_COLOR, | |
:text_active, NK_COLOR, | |
# | |
:selected_normal, NK_COLOR, | |
:selected_hover, NK_COLOR, | |
:selected_text_normal, NK_COLOR, | |
:selected_text_hover, NK_COLOR, | |
# | |
:border, :float, | |
:rounding, :float, | |
:cursor_size, :float, | |
:scrollbar_size, NK_VEC2, | |
:padding, NK_VEC2, | |
:row_padding, :float | |
end | |
class NK_STYLE_PROPERTY < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:active, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
# | |
:label_normal, NK_COLOR, | |
:label_hover, NK_COLOR, | |
:label_active, NK_COLOR, | |
# | |
:sym_left, NK_SYMBOL_TYPE, | |
:sym_right, NK_SYMBOL_TYPE, | |
# | |
:border, :float, | |
:rounding, :float, | |
:padding, NK_VEC2, | |
# | |
:edit, NK_STYLE_EDIT, | |
:inc_button, NK_STYLE_BUTTON, | |
:dec_button, NK_STYLE_BUTTON, | |
# | |
:userdata, NK_HANDLE, | |
:draw_begin, :nk_draw_begin_f, | |
:draw_end, :nk_draw_end_f | |
end | |
class NK_STYLE_CHART < FFI::Struct | |
layout :background, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
:selected_color, NK_COLOR, | |
:color, NK_COLOR, | |
# | |
:border, :float, | |
:rounding, :float, | |
:padding, NK_VEC2 | |
end | |
class NK_STYLE_COMBO < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:active, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
# | |
:label_normal, NK_COLOR, | |
:label_hover, NK_COLOR, | |
:label_active, NK_COLOR, | |
# | |
:symbol_normal, NK_COLOR, | |
:symbol_hover, NK_COLOR, | |
:symbol_active, NK_COLOR, | |
# | |
:button, NK_STYLE_BUTTON, | |
:sym_normal, NK_SYMBOL_TYPE, | |
:sym_hover, NK_SYMBOL_TYPE, | |
:sym_active, NK_SYMBOL_TYPE, | |
# | |
:border, :float, | |
:rounding, :float, | |
:content_padding, NK_VEC2, | |
:border_padding, NK_VEC2, | |
:spacing, NK_VEC2 | |
end | |
class NK_STYLE_TAB < FFI::Struct | |
layout :background, NK_STYLE_ITEM, | |
:border_color, NK_COLOR, | |
:text, NK_COLOR, | |
# | |
:tab_maximize_button, NK_STYLE_BUTTON, | |
:tab_minimize_button, NK_STYLE_BUTTON, | |
:node_maximize_button, NK_STYLE_BUTTON, | |
:node_minimize_button, NK_STYLE_BUTTON, | |
:sym_minimize, NK_SYMBOL_TYPE, | |
:sym_maximize, NK_SYMBOL_TYPE, | |
# | |
:border, :float, | |
:rounding, :float, | |
:indent, :float, | |
:padding, NK_VEC2, | |
:spacing, NK_VEC2 | |
end | |
NK_STYLE_HEADER_ALIGN = enum :NK_HEADER_LEFT, | |
:NK_HEADER_RIGHT | |
class NK_STYLE_WINDOW_HEADER < FFI::Struct | |
layout :normal, NK_STYLE_ITEM, | |
:hover, NK_STYLE_ITEM, | |
:active, NK_STYLE_ITEM, | |
# | |
:close_button, NK_STYLE_BUTTON, | |
:minimize_button, NK_STYLE_BUTTON, | |
:close_symbol, NK_SYMBOL_TYPE, | |
:minimize_symbol, NK_SYMBOL_TYPE, | |
:maximize_symbol, NK_SYMBOL_TYPE, | |
# | |
:label_normal, NK_COLOR, | |
:label_hover, NK_COLOR, | |
:label_active, NK_COLOR, | |
# | |
:align, NK_STYLE_HEADER_ALIGN, | |
:padding, NK_VEC2, | |
:label_padding, NK_VEC2, | |
:spacing, NK_VEC2 | |
end | |
class NK_STYLE_WINDOW < FFI::Struct | |
layout :header, NK_STYLE_WINDOW_HEADER, | |
:fixed_background, NK_STYLE_ITEM, | |
:background, NK_COLOR, | |
# | |
:border_color, NK_COLOR, | |
:combo_border_color, NK_COLOR, | |
:contextual_border_color, NK_COLOR, | |
:menu_border_color, NK_COLOR, | |
:group_border_color, NK_COLOR, | |
:tooltip_border_color, NK_COLOR, | |
# | |
:scaler, NK_STYLE_ITEM, | |
:footer_padding, NK_VEC2, | |
# | |
:border, :float, | |
:combo_border, :float, | |
:contextual_border, :float, | |
:menu_border, :float, | |
:group_border, :float, | |
:tooltip_border, :float, | |
# | |
:rounding, :float, | |
:scaler_size, NK_VEC2, | |
:padding, NK_VEC2, | |
:spacing, NK_VEC2, | |
:scrollbar_size, NK_VEC2, | |
:min_size, NK_VEC2 | |
end | |
class NK_STYLE < FFI::Struct | |
layout :font , NK_USER_FONT, | |
:text , NK_STYLE_TEXT, | |
:button , NK_STYLE_BUTTON, | |
:contextual_button , NK_STYLE_BUTTON, | |
:menu_button , NK_STYLE_BUTTON, | |
:option , NK_STYLE_TOGGLE, | |
:checkbox , NK_STYLE_TOGGLE, | |
:selectable , NK_STYLE_SELECTABLE, | |
:slider , NK_STYLE_SLIDER, | |
:progress , NK_STYLE_PROGRESS, | |
:property , NK_STYLE_PROPERTY, | |
:edit , NK_STYLE_EDIT, | |
:chart , NK_STYLE_CHART, | |
:scrollh , NK_STYLE_SCROLLBAR, | |
:scrollv , NK_STYLE_SCROLLBAR, | |
:tab , NK_STYLE_TAB, | |
:combo , NK_STYLE_COMBO, | |
:window , NK_STYLE_WINDOW | |
end | |
# | |
# PANEL | |
# | |
NK_CHART_MAX_SLOT = 4 | |
class NK_CHART_SLOT < FFI::Struct | |
layout :type, NK_CHART_TYPE, | |
:color, NK_COLOR, | |
:highlight, NK_COLOR, | |
:min, :float, | |
:max, :float, | |
:range, :float, | |
:count, :int32, | |
:last, NK_VEC2, | |
:index, :int32 | |
end | |
class NK_CHART < FFI::Struct | |
layout :slots, [NK_CHART_SLOT, NK_CHART_MAX_SLOT], | |
:slot, :int32, | |
:x, :float, | |
:y, :float, | |
:w, :float, | |
:h, :float | |
end | |
class NK_ROW_LAYOUT < FFI::Struct | |
layout :type, :int32, | |
:index, :int32, | |
:height, :float, | |
:columns, :int32, | |
:ratio, :pointer, | |
:item_width, :float, | |
:item_height,:float, | |
:item_offset, :float, | |
:filled, :float, | |
:item, NK_RECT, | |
:tree_depth, :int32 | |
end | |
class NK_POPUP_BUFFER < FFI::Struct | |
layout :begin, :nk_size, | |
:parent, :nk_size, | |
:last, :nk_size, | |
:end, :nk_size, | |
:active, :int32 | |
end | |
class NK_MENU_STATE < FFI::Struct | |
layout :x, :float, | |
:y, :float, | |
:w, :float, | |
:h, :float, | |
:offset, NK_SCROLL | |
end | |
class NK_PANEL < FFI::Struct | |
layout :flags, :nk_flags, | |
:bounds, NK_RECT, | |
:offset, :pointer, # struct nk_scroll *offset; | |
:at_x, :float, | |
:at_y, :float, | |
:max_x, :float, | |
:width, :float, | |
:height, :float, | |
:footer_h, :float, | |
:header_h, :float, | |
:border, :float, | |
:has_scrolling, :uint32, | |
:clip, NK_RECT, | |
:menu, NK_MENU_STATE, | |
:row, NK_ROW_LAYOUT, | |
:chart, NK_CHART, | |
:popup_buffer, NK_POPUP_BUFFER, | |
:buffer, :pointer, # struct nk_command_buffer *buffer; | |
:parent, :pointer # struct nk_panel *parent; | |
end | |
# | |
# WINDOW | |
# | |
# | |
# CONTEXT | |
# | |
class NK_CONTEXT < FFI::Struct | |
layout :input, NK_INPUT, | |
:style, NK_STYLE, | |
:memory, NK_BUFFER, | |
:clip, NK_CLIPBOARD, | |
:last_widget_state, :nk_flags, | |
# | |
:draw_list, NK_DRAW_LIST, # NOTE : available only if NK_INCLUDE_VERTEX_BUFFER_OUTPUT is defined. | |
:text_edit, NK_TEXT_EDIT, | |
# | |
:build, :int32, | |
:pool, :pointer, | |
:begin, :pointer, # struct nk_window * | |
:end, :pointer, # struct nk_window * | |
:active, :pointer, # struct nk_window * | |
:current, :pointer, # struct nk_window * | |
:freelist, :pointer, # struct nk_page_element * | |
:count, :uint32, | |
:seq, :uint32 | |
end | |
# | |
# Load native library. | |
# | |
@@nuklear_import_done = false | |
def self.load_lib(libpath = './libnuklear.dylib') | |
# ffi_lib_flags :now, :global # to force FFI to access nvgCreateInternal from nvgCreateGL2 | |
ffi_lib libpath | |
import_symbols() unless @@nuklear_import_done | |
end | |
def self.import_symbols() | |
# | |
# API | |
# | |
# context | |
attach_function :nk_init_default, [:pointer, :pointer], :int # Note : NK_INCLUDE_DEFAULT_ALLOCATOR | |
attach_function :nk_init_fixed, [:pointer, :pointer, :nk_size, :pointer], :int32 | |
attach_function :nk_init_custom, [:pointer, :pointer, :pointer, :pointer], :int32 | |
attach_function :nk_init, [:pointer, :pointer, :pointer], :int32 | |
attach_function :nk_clear, [:pointer], :void | |
attach_function :nk_free, [:pointer], :void | |
# window | |
attach_function :nk_begin, [:pointer, :pointer, :pointer, NK_RECT.by_value, :nk_flags], :int32 | |
attach_function :nk_end, [:pointer], :void | |
# Layout | |
# Layout: Group | |
# Layout: Tree | |
# Widgets | |
# Widgets: Buttons | |
# Widgets: Checkbox | |
# Widgets: Radio | |
# Widgets: Selectable | |
# Widgets: Slider | |
# Widgets: Prograssbar | |
# Widgets: Color picker | |
# Widgets: Property | |
# Widgets: TextEdit | |
# Chart | |
# Popups | |
# Combobox | |
# Combobox: abstract | |
# Contextual | |
# Tooltip | |
# Menu | |
# Drawing | |
attach_function :nk_convert, [:pointer, :pointer, :pointer, :pointer, :pointer], :void # Note : NK_INCLUDE_VERTEX_BUFFER_OUTPUT | |
# User Input | |
# Style | |
attach_function :nk_style_default, [:pointer], :void | |
attach_function :nk_style_from_table, [:pointer, :pointer], :void | |
attach_function :nk_style_color_name, [NK_STYLE_COLORS], :pointer | |
attach_function :nk_style_set_font, [:pointer, :pointer], :void | |
# Utilities | |
# base widget function | |
# color (conversion user --> nuklear) | |
# color (conversion nuklear --> user) | |
# image | |
attach_function :nk_handle_ptr, [:pointer], NK_HANDLE | |
attach_function :nk_handle_id, [:int32], NK_HANDLE | |
# math | |
# string | |
# UTF-8 | |
# | |
# MEMORY BUFFER | |
# | |
attach_function :nk_buffer_init_default, [:pointer], :void | |
attach_function :nk_buffer_init, [:pointer, :pointer, :nk_size], :void | |
attach_function :nk_buffer_init_fixed, [:pointer, :pointer, :nk_size], :void | |
attach_function :nk_buffer_info, [:pointer, :pointer], :void | |
attach_function :nk_buffer_push, [:pointer, NK_BUFFER_ALLOCATION_TYPE, :pointer, :nk_size, :nk_size], :void | |
attach_function :nk_buffer_mark, [:pointer, NK_BUFFER_ALLOCATION_TYPE], :void | |
attach_function :nk_buffer_reset, [:pointer, NK_BUFFER_ALLOCATION_TYPE], :void | |
attach_function :nk_buffer_clear, [:pointer], :void | |
attach_function :nk_buffer_free, [:pointer], :void | |
attach_function :nk_buffer_memory, [:pointer], :pointer | |
attach_function :nk_buffer_memory_const, [:pointer], :pointer | |
attach_function :nk_buffer_total, [:pointer], :nk_size | |
# | |
# STRING | |
# | |
# | |
# TEXT EDITOR | |
# | |
# | |
# FONT | |
# | |
attach_function :nk_font_atlas_init_default, [:pointer], :void # Note : NK_INCLUDE_DEFAULT_ALLOCATOR | |
attach_function :nk_font_atlas_init, [:pointer, :pointer], :void | |
attach_function :nk_font_atlas_init_custom, [:pointer, :pointer, :pointer], :void | |
attach_function :nk_font_atlas_begin, [:pointer], :void | |
attach_function :nk_font_config, [:float], NK_FONT_CONFIG | |
attach_function :nk_font_atlas_add, [:pointer, :pointer], :pointer | |
attach_function :nk_font_atlas_add_default, [:pointer, :float, :pointer], :pointer # Note : NK_INCLUDE_DEFAULT_FONT | |
attach_function :nk_font_atlas_add_from_memory, [:pointer, :pointer, :nk_size, :float, :pointer], :pointer | |
attach_function :nk_font_atlas_add_compressed, [:pointer, :pointer, :nk_size, :float, :pointer], :pointer | |
attach_function :nk_font_atlas_add_compressed_base85, [:pointer, :pointer, :float, :pointer], :pointer | |
attach_function :nk_font_atlas_bake, [:pointer, :pointer, :pointer, NK_FONT_ATLAS_FORMAT], :pointer | |
attach_function :nk_font_atlas_end, [:pointer, NK_HANDLE, :pointer], :void | |
attach_function :nk_font_atlas_clear, [:pointer], :void | |
# | |
# DRAWING | |
# | |
# misc | |
attach_function :nk_push_scissor, [:pointer, NK_RECT.by_value], :void | |
attach_function :nk_draw_image, [:pointer, NK_RECT.by_value, :pointer], :void | |
attach_function :nk_draw_text, [:pointer, NK_RECT.by_value, :pointer, :int32, :pointer, NK_COLOR.by_value, NK_COLOR.by_value], :void | |
attach_function :nk__next, [:pointer, :pointer], :pointer | |
attach_function :nk__begin, [:pointer], :pointer | |
# | |
# INPUT | |
# | |
# | |
# DRAW LIST | |
# | |
# draw list | |
attach_function :nk_draw_list_init, [:pointer], :void | |
attach_function :nk_draw_list_setup, [:pointer, :float, NK_ANTI_ALIASING, NK_ANTI_ALIASING, NK_DRAW_NULL_TEXTURE, :pointer, :pointer, :pointer], :void | |
attach_function :nk_draw_list_clear, [:pointer], :void | |
# drawing | |
attach_function :nk__draw_list_begin, [:pointer, :pointer], :pointer | |
attach_function :nk__draw_list_next, [:pointer, :pointer, :pointer], :pointer | |
attach_function :nk__draw_begin, [:pointer, :pointer], :pointer | |
attach_function :nk__draw_next, [:pointer, :pointer, :pointer], :pointer | |
# path | |
attach_function :nk_draw_list_path_clear, [:pointer], :void | |
attach_function :nk_draw_list_path_line_to, [:pointer, NK_VEC2.by_value], :void | |
attach_function :nk_draw_list_path_arc_to_fast, [:pointer, NK_VEC2.by_value, :float, :int32, :int32], :void | |
attach_function :nk_draw_list_path_arc_to, [:pointer, NK_VEC2.by_value, :float, :float, :float, :uint32], :void | |
attach_function :nk_draw_list_path_rect_to, [:pointer, NK_VEC2.by_value, NK_VEC2.by_value, :float], :void | |
attach_function :nk_draw_list_path_curve_to, [:pointer, NK_VEC2.by_value, NK_VEC2.by_value, NK_VEC2.by_value, :uint32], :void | |
attach_function :nk_draw_list_path_fill, [:pointer, NK_COLOR.by_value], :void | |
attach_function :nk_draw_list_path_stroke, [:pointer, NK_COLOR.by_value, NK_DRAW_LIST_STROKE, :float], :void | |
# stroke | |
attach_function :nk_draw_list_stroke_line, [:pointer, NK_VEC2.by_value, NK_VEC2.by_value, NK_COLOR.by_value, :float], :void | |
attach_function :nk_draw_list_stroke_rect, [:pointer, NK_RECT.by_value, NK_COLOR.by_value, :float, :float], :void | |
attach_function :nk_draw_list_stroke_triangle, [:pointer, NK_VEC2.by_value, NK_VEC2.by_value, NK_VEC2.by_value, NK_COLOR.by_value, :float], :void | |
attach_function :nk_draw_list_stroke_circle, [:pointer, NK_VEC2.by_value, :float, NK_COLOR.by_value, :uint32, :float], :void | |
attach_function :nk_draw_list_stroke_curve, [:pointer, NK_VEC2.by_value, NK_VEC2.by_value, NK_VEC2.by_value, NK_VEC2.by_value, NK_COLOR.by_value, :uint32, :float], :void | |
attach_function :nk_draw_list_stroke_poly_line, [:pointer, NK_VEC2.by_value, :uint32, NK_COLOR.by_value, NK_DRAW_LIST_STROKE, :float, NK_ANTI_ALIASING], :void | |
# fill | |
attach_function :nk_draw_list_fill_rect, [:pointer, NK_RECT.by_value, NK_COLOR.by_value, :float], :void | |
attach_function :nk_draw_list_fill_rect_multi_color, [:pointer, NK_RECT.by_value, NK_COLOR.by_value, NK_COLOR.by_value, NK_COLOR.by_value, NK_COLOR.by_value], :void | |
attach_function :nk_draw_list_fill_triangle, [:pointer, NK_VEC2.by_value, NK_VEC2.by_value, NK_VEC2.by_value, NK_COLOR.by_value], :void | |
attach_function :nk_draw_list_fill_circle, [:pointer, NK_VEC2.by_value, :float, NK_COLOR.by_value, :uint32], :void | |
attach_function :nk_draw_list_fill_poly_convex, [:pointer, NK_VEC2.by_value, :uint32, NK_COLOR.by_value, NK_ANTI_ALIASING], :void | |
# misc | |
attach_function :nk_draw_list_add_image, [:pointer, NK_IMAGE.by_value, NK_RECT.by_value, NK_COLOR.by_value], :void | |
attach_function :nk_draw_list_add_text, [:pointer, :pointer, NK_RECT.by_value, :pointer, :int32, :float, NK_COLOR.by_value], :void | |
# | |
# GUI | |
# | |
@@nuklear_import_done = true | |
end | |
end | |
=begin | |
Nuklear-Bindings : A Ruby bindings of Nuklear | |
Copyright (c) 2016 vaiorabbit | |
This software is provided 'as-is', without any express or implied | |
warranty. In no event will the authors be held liable for any damages | |
arising from the use of this software. | |
Permission is granted to anyone to use this software for any purpose, | |
including commercial applications, and to alter it and redistribute it | |
freely, subject to the following restrictions: | |
1. The origin of this software must not be misrepresented; you must not | |
claim that you wrote the original software. If you use this software | |
in a product, an acknowledgment in the product documentation would be | |
appreciated but is not required. | |
2. Altered source versions must be plainly marked as such, and must not be | |
misrepresented as being the original software. | |
3. This notice may not be removed or altered from any source | |
distribution. | |
=end |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
require 'opengl' | |
require 'glfw' | |
require_relative '../nuklear' | |
OpenGL.load_lib() | |
GLFW.load_lib() | |
Nuklear.load_lib('libnuklear.dylib') | |
include OpenGL | |
include GLFW | |
include Nuklear | |
# Press ESC to exit. | |
key_callback = GLFW::create_callback(:GLFWkeyfun) do |window_handle, key, scancode, action, mods| | |
if key == GLFW_KEY_ESCAPE && action == GLFW_PRESS | |
glfwSetWindowShouldClose(window_handle, 1) | |
end | |
end | |
if __FILE__ == $0 | |
glfwInit() | |
window = glfwCreateWindow( 640, 480, "Simple example", nil, nil ) | |
glfwMakeContextCurrent( window ) | |
glfwSetKeyCallback( window, key_callback ) | |
nulldev = NK_DRAW_NULL_TEXTURE.new | |
ctx = NK_CONTEXT.new | |
nk_init_default(ctx, nil) | |
cmds = NK_BUFFER.new | |
nk_buffer_init_default(cmds) | |
atlas = NK_FONT_ATLAS.new | |
nk_font_atlas_init_default(atlas) | |
nk_font_atlas_begin(atlas) | |
w = ' ' * 4 | |
h = ' ' * 4 | |
image = nk_font_atlas_bake(atlas, w, h, NK_FONT_ATLAS_FORMAT[:NK_FONT_ATLAS_RGBA32]) | |
font_tex = ' ' * 4 | |
glGenTextures(1, font_tex) | |
glBindTexture(GL_TEXTURE_2D, font_tex.unpack('L')[0]) | |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) | |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) | |
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w.unpack('L')[0], h.unpack('L')[0], 0, GL_RGBA, GL_UNSIGNED_BYTE, image) | |
nk_font_atlas_end(atlas, nk_handle_id(font_tex.unpack('L')[0]), nulldev) | |
if atlas[:default_font].null? == false | |
fnt = NK_FONT.new(atlas[:default_font]) | |
nk_style_set_font(ctx, fnt[:handle]) | |
end | |
glClearColor( 0.25, 0.55, 0.85, 0.0 ) | |
while glfwWindowShouldClose( window ) == 0 | |
glfwPollEvents() | |
# 3D | |
width_ptr = ' ' * 8 | |
height_ptr = ' ' * 8 | |
glfwGetFramebufferSize(window, width_ptr, height_ptr) | |
width = width_ptr.unpack('L')[0] | |
height = height_ptr.unpack('L')[0] | |
ratio = width.to_f / height.to_f | |
glViewport(0, 0, width, height) | |
glClear(GL_COLOR_BUFFER_BIT) | |
glMatrixMode(GL_PROJECTION) | |
glLoadIdentity() | |
glOrtho(-ratio, ratio, -1.0, 1.0, 1.0, -1.0) | |
glMatrixMode(GL_MODELVIEW) | |
glLoadIdentity() | |
glRotatef(glfwGetTime() * 50.0, 0.0, 0.0, 1.0) | |
glBegin(GL_TRIANGLES) | |
glColor3f(1.0, 0.0, 0.0) | |
glVertex3f(-0.6, -0.4, 0.0) | |
glColor3f(0.0, 1.0, 0.0) | |
glVertex3f(0.6, -0.4, 0.0) | |
glColor3f(0.0, 0.0, 1.0) | |
glVertex3f(0.0, 0.6, 0.0) | |
glEnd() | |
# 2D | |
rect = NK_RECT.new | |
rect[:x] = 50.0 | |
rect[:y] = 50.0 | |
rect[:w] = 230.0 | |
rect[:h] = 250.0 | |
begin | |
# Setup widgets | |
layout = NK_PANEL.new | |
r = nk_begin(ctx, layout, "Nuklear Ruby Bindings", rect, | |
NK_PANEL_FLAGS[:NK_WINDOW_BORDER]| | |
NK_PANEL_FLAGS[:NK_WINDOW_MOVABLE]| | |
NK_PANEL_FLAGS[:NK_WINDOW_SCALABLE]| | |
NK_PANEL_FLAGS[:NK_WINDOW_MINIMIZABLE]| | |
NK_PANEL_FLAGS[:NK_WINDOW_TITLE]) | |
if r != 0 | |
# Setup Widgets Here | |
end | |
nk_end(ctx) | |
end | |
begin | |
# Render | |
glPushAttrib(GL_ENABLE_BIT|GL_COLOR_BUFFER_BIT|GL_TRANSFORM_BIT) | |
glDisable(GL_CULL_FACE) | |
glDisable(GL_DEPTH_TEST) | |
glEnable(GL_SCISSOR_TEST) | |
glEnable(GL_BLEND) | |
glEnable(GL_TEXTURE_2D) | |
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) | |
glViewport(0,0,width,height) | |
glMatrixMode(GL_PROJECTION) | |
glPushMatrix() | |
glLoadIdentity() | |
glOrtho(0.0, width, height, 0.0, -1.0, 1.0) | |
glMatrixMode(GL_MODELVIEW) | |
glPushMatrix() | |
glLoadIdentity() | |
glEnableClientState(GL_VERTEX_ARRAY) | |
glEnableClientState(GL_TEXTURE_COORD_ARRAY) | |
glEnableClientState(GL_COLOR_ARRAY) | |
begin | |
vs = NK_DRAW_VERTEX.size | |
vp = NK_DRAW_VERTEX.offset_of(:position) | |
vt = NK_DRAW_VERTEX.offset_of(:uv) | |
vc = NK_DRAW_VERTEX.offset_of(:col) | |
config = NK_CONVERT_CONFIG.new | |
config[:global_alpha] = 1.0 | |
config[:shape_AA] = NK_ANTI_ALIASING[:NK_ANTI_ALIASING_ON] | |
config[:line_AA] = NK_ANTI_ALIASING[:NK_ANTI_ALIASING_ON] | |
config[:circle_segment_count] = 22 | |
config[:curve_segment_count] = 22 | |
config[:arc_segment_count] = 22 | |
config[:null] = nulldev | |
vbuf = NK_BUFFER.new | |
ebuf = NK_BUFFER.new | |
nk_buffer_init_default(vbuf) | |
nk_buffer_init_default(ebuf) | |
nk_convert(ctx, cmds, vbuf, ebuf, config) | |
vertices = nk_buffer_memory_const(vbuf) | |
glVertexPointer(2, GL_FLOAT, vs, (vertices+vp)) | |
glTexCoordPointer(2, GL_FLOAT, vs, (vertices+vt)) | |
glColorPointer(4, GL_UNSIGNED_BYTE, vs, (vertices+vc)) | |
offset = nk_buffer_memory_const(ebuf) | |
begin | |
# draw widgets here | |
nk_draw_foreach(ctx, cmds) do |cmd_ptr| | |
window_height = 480.0 | |
fb_scale_x = 1.0 | |
fb_scale_y = 1.0 | |
cmd = NK_DRAW_COMMAND.new(cmd_ptr) | |
next if cmd[:elem_count] == 0 | |
glBindTexture(GL_TEXTURE_2D, cmd[:texture][:id]) | |
glScissor( | |
(cmd[:clip_rect][:x] * fb_scale_x).to_i, | |
((window_height - (cmd[:clip_rect][:y] + cmd[:clip_rect][:h])).to_i * fb_scale_y).to_i, | |
(cmd[:clip_rect][:w] * fb_scale_x).to_i, | |
(cmd[:clip_rect][:h] * fb_scale_y)).to_i | |
glDrawElements(GL_TRIANGLES, cmd[:elem_count], GL_UNSIGNED_SHORT, offset); | |
offset += cmd[:elem_count] | |
end | |
end | |
nk_clear(ctx) | |
nk_buffer_free(vbuf) | |
nk_buffer_free(ebuf) | |
end | |
glDisableClientState(GL_VERTEX_ARRAY) | |
glDisableClientState(GL_TEXTURE_COORD_ARRAY) | |
glDisableClientState(GL_COLOR_ARRAY) | |
glDisable(GL_CULL_FACE) | |
glDisable(GL_DEPTH_TEST) | |
glDisable(GL_SCISSOR_TEST) | |
glDisable(GL_BLEND) | |
glDisable(GL_TEXTURE_2D) | |
glBindTexture(GL_TEXTURE_2D, 0) | |
glMatrixMode(GL_MODELVIEW) | |
glPopMatrix() | |
glMatrixMode(GL_PROJECTION) | |
glPopMatrix() | |
glPopAttrib() | |
end | |
glfwSwapBuffers( window ) | |
end | |
nk_buffer_free(cmds) | |
nk_free(ctx) | |
glfwDestroyWindow( window ) | |
glfwTerminate() | |
end |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment