nuklear 0.1.0

data/ext/nuklear/nkrb_font.c

@@ -0,0 +1,80 @@
+#include "nkrb.h"
+
+typedef struct {
+  struct { int width, height; const void *data; } img;
+  struct nk_font_atlas atlas;
+  struct nk_font *font;
+  struct nk_draw_null_texture null;
+} NkRbFont;
+
+#define VALUE_TO_NK(value, varname)     \
+  NkRbFont *varname = NULL;  \
+  Data_Get_Struct(value, NkRbFont, varname);
+
+VALUE cNuklearFont = Qnil;
+VALUE cNuklearNullTexture = Qnil;
+
+struct nk_user_font *nkrb_font_to_nk(VALUE value) {
+  VALUE_TO_NK(value, nk);
+  return &(nk->font->handle);
+}
+
+void nkrb_null_texture_free(struct nk_draw_null_texture *tex) {
+  free(tex);
+}
+
+VALUE nkrb_font_get_null(VALUE value) {
+  VALUE_TO_NK(value, nk);
+  struct nk_draw_null_texture *tex = malloc(sizeof(struct nk_draw_null_texture));
+  memcpy(tex, &(nk->null), sizeof(struct nk_draw_null_texture));
+  return Data_Wrap_Struct(cNuklearNullTexture, NULL, nkrb_null_texture_free, tex);
+}
+
+void nkrb_font_free(NkRbFont *font) {
+  nk_font_atlas_clear(&(font->atlas));
+}
+
+VALUE nkrb_font_width(VALUE self, VALUE rtext) {
+  const char *text = StringValueCStr(rtext);
+  struct nk_user_font *handle = nkrb_font_to_nk(self);
+  float width = handle->width(handle->userdata, handle->height, text, (int) strlen(text));
+  return DBL2NUM(width);
+}
+
+VALUE nkrb_font_height(VALUE self) {
+  struct nk_user_font *handle = nkrb_font_to_nk(self);
+  return DBL2NUM(handle->height);
+}
+
+VALUE nkrb_font_new(int argc, VALUE *argv, VALUE self) {
+  if (argc < 2 || argc > 3)
+    rb_raise(rb_eArgError, "Invalid number of arguments (%d for 2 or 3): pass path, size, and an optional arguments hash", argc);
+  VALUE path = argv[0];
+  VALUE size = argv[1];
+  struct nk_font_config config;
+  config = nk_font_config((float) NUM2DBL(size));
+  if (argc == 3) {
+    // TODO support extra font config options
+  }
+
+  NkRbFont *font = malloc(sizeof(NkRbFont));
+  memset(font, 0, sizeof(NkRbFont));
+  nk_font_atlas_init_default(&(font->atlas));
+  nk_font_atlas_begin(&(font->atlas));
+  font->font = nk_font_atlas_add_from_file(&(font->atlas), StringValueCStr(path), (float) NUM2DBL(size), NULL);
+  if (font->font == NULL)
+    rb_raise(rb_eStandardError, "Failed to load font file %s", StringValueCStr(path));
+  font->img.data = nk_font_atlas_bake(&(font->atlas), &(font->img.width), &(font->img.height), NK_FONT_ATLAS_RGBA32);
+  VALUE bytes = rb_str_new((char *) font->img.data, font->img.width * font->img.height * 4);
+  VALUE tex = rb_yield_values(3, INT2FIX(font->img.width), INT2FIX(font->img.height), bytes);
+  nk_font_atlas_end(&(font->atlas), nk_handle_ptr((void *) NUM2ULL(tex)), &(font->null));
+  return Data_Wrap_Struct(cNuklearFont, NULL, nkrb_font_free, font);
+}
+
+void nkrb_font_init(void) {
+  cNuklearFont = rb_define_class_under(mNuklear, "Font", rb_cObject);
+  cNuklearNullTexture = rb_define_class_under(mNuklear, "NullTexture", rb_cObject);
+  rb_define_module_function(cNuklearFont, "new", nkrb_font_new, -1);
+  rb_define_method(cNuklearFont, "width", nkrb_font_width, 1);
+  rb_define_method(cNuklearFont, "height", nkrb_font_height, 0);
+}

data/ext/nuklear/nkrb_renderer.c

@@ -0,0 +1,114 @@
+#include "nkrb.h"
+
+static enum nk_draw_vertex_layout_attribute rb2nk_attribute(VALUE v) {
+  ID id = SYM2ID(v);
+  if (id == rb_intern("position"))             return NK_VERTEX_POSITION;
+  else if (id == rb_intern("color"))           return NK_VERTEX_COLOR;
+  else if (id == rb_intern("texcoord"))        return NK_VERTEX_TEXCOORD;
+  else if (id == rb_intern("attribute_count")) return NK_VERTEX_ATTRIBUTE_COUNT;
+  else rb_raise(rb_eArgError, "Invalid vertex layout attribute name");
+}
+
+static enum nk_draw_vertex_layout_format rb2nk_format(VALUE v) {
+  ID id = SYM2ID(v);
+  if (id == rb_intern("schar"))                    return NK_FORMAT_SCHAR;
+  else if (id == rb_intern("sshort"))              return NK_FORMAT_SSHORT;
+  else if (id == rb_intern("sint"))                return NK_FORMAT_SINT;
+  else if (id == rb_intern("uchar"))               return NK_FORMAT_UCHAR;
+  else if (id == rb_intern("ushort"))              return NK_FORMAT_USHORT;
+  else if (id == rb_intern("uint"))                return NK_FORMAT_UINT;
+  else if (id == rb_intern("float"))               return NK_FORMAT_FLOAT;
+  else if (id == rb_intern("double"))              return NK_FORMAT_DOUBLE;
+  else if (id == rb_intern("r8g8b8"))              return NK_FORMAT_R8G8B8;
+  else if (id == rb_intern("r16g15b16"))           return NK_FORMAT_R16G15B16;
+  else if (id == rb_intern("r32g32b32"))           return NK_FORMAT_R32G32B32;
+  else if (id == rb_intern("r8g8b8a8"))            return NK_FORMAT_R8G8B8A8;
+  else if (id == rb_intern("b8g8r8a8"))            return NK_FORMAT_B8G8R8A8;
+  else if (id == rb_intern("r16g15b16a16"))        return NK_FORMAT_R16G15B16A16;
+  else if (id == rb_intern("r32g32b32a32"))        return NK_FORMAT_R32G32B32A32;
+  else if (id == rb_intern("r32g32b32a32_float"))  return NK_FORMAT_R32G32B32A32_FLOAT;
+  else if (id == rb_intern("r32g32b32a32_double")) return NK_FORMAT_R32G32B32A32_DOUBLE;
+  else if (id == rb_intern("rgb32"))               return NK_FORMAT_RGB32;
+  else if (id == rb_intern("rgba32"))              return NK_FORMAT_RGBA32;
+  else rb_raise(rb_eArgError, "Invalid vertex layout format name");
+}
+
+VALUE nkrb_renderer_convert(VALUE self) {
+  struct nk_context *context = NULL;
+  struct nk_buffer *commands = NULL;
+  struct nk_buffer *vertices = NULL;
+  struct nk_buffer *indices  = NULL;
+  Data_Get_Struct(rb_funcall(self, rb_intern("context"),  0),       struct nk_context, context);
+  Data_Get_Struct(rb_funcall(self, rb_intern("commands"), 0),       struct nk_buffer,  commands);
+  Data_Get_Struct(rb_funcall(self, rb_intern("vertices"), 0),       struct nk_buffer,  vertices);
+  Data_Get_Struct(rb_funcall(self, rb_intern("vertex_indices"), 0), struct nk_buffer,  indices);
+  VALUE rconfig = rb_funcall(self, rb_intern("convert_config"), 0);
+  VALUE rvertex_layout = rb_hash_aref(rconfig, ID2SYM(rb_intern("vertex_layout")));
+  struct nk_convert_config config;
+  struct nk_draw_vertex_layout_element *vertex_layout = alloca((RARRAY_LEN(rvertex_layout) + 1) * sizeof(struct nk_draw_vertex_layout_element));
+  for (int i = 0; i < RARRAY_LEN(rvertex_layout); i++) {
+    VALUE rlayout = RARRAY_AREF(rvertex_layout, i);
+    vertex_layout[i].attribute = rb2nk_attribute(RARRAY_AREF(rlayout, 0));
+    vertex_layout[i].format    = rb2nk_format(RARRAY_AREF(rlayout, 1));
+    vertex_layout[i].offset    = FIX2INT(RARRAY_AREF(rlayout, 2));
+  }
+  vertex_layout[RARRAY_LEN(rvertex_layout)].attribute = NK_VERTEX_LAYOUT_END;
+  memset(&config, 0, sizeof(config));
+  config.vertex_layout = vertex_layout;
+  config.vertex_size = FIX2INT(rb_hash_aref(rconfig, ID2SYM(rb_intern("vertex_size"))));
+  config.vertex_alignment = FIX2INT(rb_hash_aref(rconfig, ID2SYM(rb_intern("vertex_alignment"))));
+  config.null.texture = (nk_handle) (void *) NUM2ULL(rb_hash_aref(rconfig, ID2SYM(rb_intern("null"))));
+  config.circle_segment_count = NUM2UINT(rb_hash_aref(rconfig, ID2SYM(rb_intern("circle_segment_count"))));
+  config.curve_segment_count = NUM2UINT(rb_hash_aref(rconfig, ID2SYM(rb_intern("curve_segment_count"))));
+  config.arc_segment_count = NUM2UINT(rb_hash_aref(rconfig, ID2SYM(rb_intern("arc_segment_count"))));
+  config.global_alpha = (float) NUM2DBL(rb_hash_aref(rconfig, ID2SYM(rb_intern("global_alpha"))));
+  config.shape_AA = RTEST(rb_hash_aref(rconfig, ID2SYM(rb_intern("shape_aa")))) ? NK_ANTI_ALIASING_ON : NK_ANTI_ALIASING_OFF;
+  config.line_AA = RTEST(rb_hash_aref(rconfig, ID2SYM(rb_intern("line_aa")))) ? NK_ANTI_ALIASING_ON : NK_ANTI_ALIASING_OFF;
+  // all that for this
+  nk_flags result = nk_convert(context, commands, vertices, indices, &config);
+  switch(result) {
+    case NK_CONVERT_SUCCESS: break; // OK
+    case NK_CONVERT_INVALID_PARAM: rb_raise(rb_eRuntimeError, "Nuklear error: INVALID_PARAM");
+    case NK_CONVERT_COMMAND_BUFFER_FULL: rb_raise(rb_eRuntimeError, "Nuklear error: COMMAND_BUFFER_FULL");
+    case NK_CONVERT_VERTEX_BUFFER_FULL: rb_raise(rb_eRuntimeError, "Nuklear error: VERTEX_BUFFER_FULL");
+    case NK_CONVERT_ELEMENT_BUFFER_FULL: rb_raise(rb_eRuntimeError, "Nuklear error: ELEMENT_BUFFER_FULL");
+    default: rb_raise(rb_eRuntimeError, "Nuklear error: %d (unknown)", result);
+  }
+  return self;
+}
+
+VALUE nkrb_renderer_draw_foreach(VALUE self) {
+  struct nk_context *context = NULL;
+  struct nk_buffer *commands = NULL;
+  Data_Get_Struct(rb_funcall(self, rb_intern("context"),  0), struct nk_context, context);
+  Data_Get_Struct(rb_funcall(self, rb_intern("commands"), 0), struct nk_buffer,  commands);
+
+  /* convert from command queue into draw list and draw to screen */
+  const struct nk_draw_command *cmd;
+  // const nk_draw_index *offset = NULL;
+  /* iterate over and execute each draw command */
+  int offset = 0;
+  nk_draw_foreach(cmd, context, commands) {
+    if (!cmd->elem_count) continue;
+    VALUE rcmd = rb_hash_new();
+    VALUE rclip_rect = rb_ary_new2(4);
+    rb_ary_store(rclip_rect, 0, DBL2NUM(cmd->clip_rect.x));
+    rb_ary_store(rclip_rect, 1, DBL2NUM(cmd->clip_rect.y));
+    rb_ary_store(rclip_rect, 2, DBL2NUM(cmd->clip_rect.w));
+    rb_ary_store(rclip_rect, 3, DBL2NUM(cmd->clip_rect.h));
+    rb_hash_aset(rcmd, ID2SYM(rb_intern("element_count")),  INT2NUM(cmd->elem_count));
+    rb_hash_aset(rcmd, ID2SYM(rb_intern("texture_handle")), ULL2NUM((unsigned long long) cmd->texture.ptr));
+    rb_hash_aset(rcmd, ID2SYM(rb_intern("clip_rect")), rclip_rect);
+    rb_hash_aset(rcmd, ID2SYM(rb_intern("offset")), INT2NUM(offset));
+    rb_yield(rcmd);
+    offset += cmd->elem_count;
+  }
+
+  return self;
+}
+
+void nkrb_renderer_init(void) {
+  VALUE cRenderer = rb_define_class_under(mNuklear, "Renderer", rb_cObject);
+  rb_define_method(cRenderer, "nk_convert",      nkrb_renderer_convert,      0);
+  rb_define_method(cRenderer, "nk_draw_foreach", nkrb_renderer_draw_foreach, 0);
+}

data/ext/nuklear/nkrb_style.c

@@ -0,0 +1,61 @@
+#include "nkrb.h"
+
+VALUE mNuklearStyle = Qnil;
+
+struct nk_style_item *nkrb_style_item(VALUE value) {
+  struct nk_style_item *item;
+  Data_Get_Struct(value, struct nk_style_item, item);
+  return item;
+}
+
+void nkrb_style_item_free(struct nk_style_item *item) {
+  free(item);
+}
+
+void assign_button_style_from_ruby(struct nk_style_button *style, VALUE rstyle) {
+  if (!NIL_P(rstyle)) {
+    VALUE rnormal          = rb_hash_aref(rstyle, ID2SYM(rb_intern("normal")));
+    VALUE rhover           = rb_hash_aref(rstyle, ID2SYM(rb_intern("hover")));
+    VALUE ractive          = rb_hash_aref(rstyle, ID2SYM(rb_intern("active")));
+    VALUE rborder_color    = rb_hash_aref(rstyle, ID2SYM(rb_intern("border_color")));
+    VALUE rtext_background = rb_hash_aref(rstyle, ID2SYM(rb_intern("text_background")));
+    VALUE rtext_normal     = rb_hash_aref(rstyle, ID2SYM(rb_intern("text_normal")));
+    VALUE rtext_hover      = rb_hash_aref(rstyle, ID2SYM(rb_intern("text_hover")));
+    VALUE rtext_active     = rb_hash_aref(rstyle, ID2SYM(rb_intern("text_active")));
+    VALUE rtext_alignment  = rb_hash_aref(rstyle, ID2SYM(rb_intern("text_alignment")));
+    VALUE rborder          = rb_hash_aref(rstyle, ID2SYM(rb_intern("border")));
+    VALUE rrounding        = rb_hash_aref(rstyle, ID2SYM(rb_intern("rounding")));
+    VALUE rpadding         = rb_hash_aref(rstyle, ID2SYM(rb_intern("padding")));
+    VALUE rimage_padding   = rb_hash_aref(rstyle, ID2SYM(rb_intern("image_padding")));
+    VALUE rtouch_padding   = rb_hash_aref(rstyle, ID2SYM(rb_intern("touch_padding")));
+    
+    // TODO button style user callbacks
+    // nk_handle userdata;
+    // void(*draw_begin)(struct nk_command_buffer*, nk_handle userdata);
+    // void(*draw_end)(struct nk_command_buffer*, nk_handle userdata);
+
+    if (!NIL_P(rnormal))          style->normal = *nkrb_style_item(rnormal);
+    if (!NIL_P(rhover))           style->hover  = *nkrb_style_item(rhover);
+    if (!NIL_P(ractive))          style->active = *nkrb_style_item(ractive);
+    if (!NIL_P(rborder_color))    { ASSIGN_STYLE_AS_COLOR(style->border_color,    nkrb_style_item(rborder_color)); }
+    if (!NIL_P(rtext_background)) { ASSIGN_STYLE_AS_COLOR(style->text_background, nkrb_style_item(rtext_background)); }
+    if (!NIL_P(rtext_normal))     { ASSIGN_STYLE_AS_COLOR(style->text_normal,     nkrb_style_item(rtext_normal)); }
+    if (!NIL_P(rtext_hover))      { ASSIGN_STYLE_AS_COLOR(style->text_hover,      nkrb_style_item(rtext_hover)); }
+    if (!NIL_P(rtext_active))     { ASSIGN_STYLE_AS_COLOR(style->text_active,     nkrb_style_item(rtext_active)); }
+    if (!NIL_P(rtext_alignment))  style->text_alignment = FIX2INT(rtext_alignment);
+    if (!NIL_P(rborder))          style->border = (float) RFLOAT_VALUE(rborder);
+    if (!NIL_P(rrounding))        style->rounding = (float) RFLOAT_VALUE(rrounding);
+    if (!NIL_P(rpadding))         style->padding = nk_vec2(RFLOAT_VALUE(rb_ary_entry(rpadding, 0)),
+                                                          RFLOAT_VALUE(rb_ary_entry(rpadding, 1)));
+    if (!NIL_P(rimage_padding))   style->image_padding = nk_vec2(RFLOAT_VALUE(rb_ary_entry(rimage_padding, 0)),
+                                                                 RFLOAT_VALUE(rb_ary_entry(rimage_padding, 1)));
+    if (!NIL_P(rtouch_padding))   style->touch_padding = nk_vec2(RFLOAT_VALUE(rb_ary_entry(rtouch_padding, 0)),
+                                                                 RFLOAT_VALUE(rb_ary_entry(rtouch_padding, 1)));
+  }
+}
+
+void nkrb_style_init(void) {
+  mNuklearStyle = rb_define_module_under(mNuklear, "Style");
+  nkrb_style_color_init();
+  nkrb_style_image_init();
+}

data/ext/nuklear/nkrb_style_color.c

@@ -0,0 +1,126 @@
+#include "nkrb.h"
+
+#define NK_UNPACK(rvalue, varname)                        \
+  struct nk_style_item *varname;                          \
+  Data_Get_Struct(rvalue, struct nk_style_item, varname);
+
+
+VALUE cNuklearStyleColor = Qnil;
+
+VALUE nkrb_style_color_alloc(VALUE self) {
+  struct nk_style_item *style = malloc(sizeof(struct nk_style_item));
+  memset(style, 0, sizeof(struct nk_style_item));
+  style->type = NK_STYLE_ITEM_COLOR;
+  return Data_Wrap_Struct(self, NULL, nkrb_style_item_free, style);
+}
+
+VALUE nkrb_style_color_set_red(VALUE self, VALUE r) {
+  NK_UNPACK(self, style);
+  style->data.color.r = (nk_byte) (NK_SATURATE((float) NUM2DBL(r)) * 255.0f);
+  return r;
+}
+
+VALUE nkrb_style_color_get_red(VALUE self) {
+  NK_UNPACK(self, style);
+  return DBL2NUM(style->data.color.r / 255.0);
+}
+
+VALUE nkrb_style_color_set_green(VALUE self, VALUE g) {
+  NK_UNPACK(self, style);
+  style->data.color.g = (nk_byte) (NK_SATURATE((float) NUM2DBL(g)) * 255.0f);
+  return g;
+}
+
+VALUE nkrb_style_color_get_green(VALUE self) {
+  NK_UNPACK(self, style);
+  return DBL2NUM(style->data.color.g / 255.0);
+}
+
+VALUE nkrb_style_color_set_blue(VALUE self, VALUE b) {
+  NK_UNPACK(self, style);
+  style->data.color.b = (nk_byte) (NK_SATURATE((float) NUM2DBL(b)) * 255.0f);
+  return b;
+}
+
+VALUE nkrb_style_color_get_blue(VALUE self) {
+  NK_UNPACK(self, style);
+  return DBL2NUM(style->data.color.b / 255.0);
+}
+
+VALUE nkrb_style_color_set_alpha(VALUE self, VALUE a) {
+  NK_UNPACK(self, style);
+  style->data.color.a = (nk_byte) (NK_SATURATE((float) NUM2DBL(a)) * 255.0f);
+  return a;
+}
+
+VALUE nkrb_style_color_get_alpha(VALUE self) {
+  NK_UNPACK(self, style);
+  return DBL2NUM(style->data.color.a / 255.0);
+}
+
+VALUE nkrb_style_color_set_hue(VALUE self, VALUE a) {
+  NK_UNPACK(self, style);
+  nk_byte tmp[4];
+  nk_color_hsva_bv(tmp, style->data.color);
+  tmp[0] = (nk_byte) (NK_SATURATE((float) NUM2DBL(a)) * 255.0f);
+  style->data.color = nk_hsva_bv(tmp);
+  return a;
+}
+
+VALUE nkrb_style_color_get_hue(VALUE self) {
+  NK_UNPACK(self, style);
+  nk_byte tmp[4];
+  nk_color_hsva_bv(tmp, style->data.color);
+  return DBL2NUM(tmp[0] / 255.0);
+}
+
+VALUE nkrb_style_color_set_saturation(VALUE self, VALUE a) {
+  NK_UNPACK(self, style);
+  nk_byte tmp[4];
+  nk_color_hsva_bv(tmp, style->data.color);
+  tmp[1] = (nk_byte) (NK_SATURATE((float) NUM2DBL(a)) * 255.0f);
+  style->data.color = nk_hsva_bv(tmp);
+  return a;
+}
+
+VALUE nkrb_style_color_get_saturation(VALUE self) {
+  NK_UNPACK(self, style);
+  nk_byte tmp[4];
+  nk_color_hsva_bv(tmp, style->data.color);
+  return DBL2NUM(tmp[1] / 255.0);
+}
+
+VALUE nkrb_style_color_set_value(VALUE self, VALUE a) {
+  NK_UNPACK(self, style);
+  nk_byte tmp[4];
+  nk_color_hsva_bv(tmp, style->data.color);
+  tmp[3] = (nk_byte) (NK_SATURATE((float) NUM2DBL(a)) * 255.0f);
+  style->data.color = nk_hsva_bv(tmp);
+  return a;
+}
+
+VALUE nkrb_style_color_get_value(VALUE self) {
+  NK_UNPACK(self, style);
+  nk_byte tmp[4];
+  nk_color_hsva_bv(tmp, style->data.color);
+  return DBL2NUM(tmp[3] / 255.0);
+}
+
+void nkrb_style_color_init(void) {
+  cNuklearStyleColor = rb_define_class_under(mNuklearStyle, "Color", rb_cObject);
+  rb_define_alloc_func(cNuklearStyleColor, nkrb_style_color_alloc);
+  rb_define_method(cNuklearStyleColor, "red=",   nkrb_style_color_set_red, 1);
+  rb_define_method(cNuklearStyleColor, "red",    nkrb_style_color_get_red, 0);
+  rb_define_method(cNuklearStyleColor, "green=", nkrb_style_color_set_green, 1);
+  rb_define_method(cNuklearStyleColor, "green",  nkrb_style_color_get_green, 0);
+  rb_define_method(cNuklearStyleColor, "blue=",  nkrb_style_color_set_blue, 1);
+  rb_define_method(cNuklearStyleColor, "blue",   nkrb_style_color_get_blue, 0);
+  rb_define_method(cNuklearStyleColor, "hue=",   nkrb_style_color_set_hue, 1);
+  rb_define_method(cNuklearStyleColor, "hue",    nkrb_style_color_get_hue, 0);
+  rb_define_method(cNuklearStyleColor, "saturation=", nkrb_style_color_set_saturation, 1);
+  rb_define_method(cNuklearStyleColor, "saturation",  nkrb_style_color_get_saturation, 0);
+  rb_define_method(cNuklearStyleColor, "value=",  nkrb_style_color_set_value, 1);
+  rb_define_method(cNuklearStyleColor, "value",   nkrb_style_color_get_value, 0);
+  rb_define_method(cNuklearStyleColor, "alpha=", nkrb_style_color_set_alpha, 1);
+  rb_define_method(cNuklearStyleColor, "alpha",  nkrb_style_color_get_alpha, 0);
+}

data/ext/nuklear/nkrb_style_image.c

@@ -0,0 +1,32 @@
+#include "nkrb.h"
+
+#define NK_UNPACK(rvalue, varname)                        \
+  struct nk_style_item *varname;                          \
+  Data_Get_Struct(rvalue, struct nk_style_item, varname);
+
+VALUE cNuklearStyleImage = Qnil;
+
+VALUE nkrb_style_image_alloc(VALUE self) {
+  struct nk_style_item *style = malloc(sizeof(struct nk_style_item));
+  memset(style, 0, sizeof(struct nk_style_item));
+  style->type = NK_STYLE_ITEM_IMAGE;
+  return Data_Wrap_Struct(self, NULL, nkrb_style_item_free, style);
+}
+
+VALUE nkrb_style_image_set_id(VALUE self, VALUE id) {
+  NK_UNPACK(self, style);
+  style->data.image.handle.id = FIX2INT(id);
+  return id;
+}
+
+VALUE nkrb_style_image_get_id(VALUE self) {
+  NK_UNPACK(self, style);
+  return INT2FIX(style->data.image.handle.id);
+}
+
+void nkrb_style_image_init(void) {
+  cNuklearStyleImage = rb_define_class_under(mNuklearStyle, "Image", rb_cObject);
+  rb_define_alloc_func(cNuklearStyleImage, nkrb_style_image_alloc);
+  rb_define_method(cNuklearStyleImage, "id=",   nkrb_style_image_set_id, 1);
+  rb_define_method(cNuklearStyleImage, "id",    nkrb_style_image_get_id, 0);
+}

data/ext/nuklear/nkrb_ui.c

@@ -0,0 +1,32 @@
+#include "nkrb.h"
+
+VALUE mNuklearUI = Qnil;
+
+void instance_eval_block(VALUE self) {
+  rb_need_block();
+  rb_funcall_with_block(self, rb_intern("instance_eval"), 0, NULL, rb_block_proc());
+}
+
+void nkrb_ui_init(void) {
+  mNuklearUI = rb_define_module_under(mNuklear, "UI");
+  nkrb_ui_container_init();
+
+  nkrb_ui_button_init();
+  nkrb_ui_checkbox_init();
+  nkrb_ui_color_picker_init();
+  nkrb_ui_combo_init();
+  nkrb_ui_edit_string_init();
+  nkrb_ui_group_init();
+  nkrb_ui_label_init();
+  nkrb_ui_layout_init();
+  nkrb_ui_menu_init();
+  nkrb_ui_menu_item_init();
+  nkrb_ui_menubar_init();
+  nkrb_ui_popup_init();
+  nkrb_ui_progress_init();
+  nkrb_ui_property_init();
+  nkrb_ui_slider_init();
+  nkrb_ui_tree_init();
+  nkrb_ui_widget_init();
+  nkrb_ui_window_init();
+}

data/ext/nuklear/nkrb_ui_builder.c

@@ -0,0 +1,29 @@
+#include "nkrb.h"
+
+#define UNPACK_CONTEXT(varname) struct nk_context *varname = nkrb_context_get(rb_ivar_get(self, rb_intern("@context")));
+
+VALUE cNuklearUIBuilder = Qnil;
+
+VALUE nkrb_ui_initialize(VALUE self, VALUE context) {
+  rb_ivar_set(self, rb_intern("@context"), context);
+  return self;
+}
+
+
+VALUE nkrb_ui_list_view_begin(VALUE self, VALUE id, VALUE flags, VALUE row_height, VALUE row_count) {
+  UNPACK_CONTEXT(ctx);
+  struct nk_list_view view;
+  if (nk_list_view_begin(ctx, &view, StringValueCStr(id), FIX2INT(flags), FIX2INT(row_height), FIX2INT(row_count))) {
+    if (rb_block_given_p()) {
+      instance_eval_block(self);
+    }
+    nk_list_view_end(&view);
+  }
+  return self;
+}
+
+void nkrb_ui_builder_init(void) {
+  cNuklearUIBuilder = rb_define_class_under(mNuklear, "UIBuilder", rb_cObject);
+  rb_define_method(cNuklearUIBuilder, "initialize",                   nkrb_ui_initialize,                        1);
+  rb_define_method(cNuklearUIBuilder, "list_view",                    nkrb_ui_list_view_begin,                   4);
+}

data/ext/nuklear/nkrb_ui_button.c

@@ -0,0 +1,55 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_button(VALUE self, VALUE rcontext, VALUE roptions) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+  VALUE rrepeat = rb_hash_aref(roptions, ID2SYM(rb_intern("repeat")));
+  VALUE rtitle = rb_hash_aref(roptions, ID2SYM(rb_intern("title")));
+  VALUE rcolor = rb_hash_aref(roptions, ID2SYM(rb_intern("color")));
+  VALUE rsymbol = rb_hash_aref(roptions, ID2SYM(rb_intern("symbol")));
+  VALUE rimage = rb_hash_aref(roptions, ID2SYM(rb_intern("image")));
+  VALUE rstyle = rb_hash_aref(roptions, ID2SYM(rb_intern("style")));
+  VALUE ralign = rb_hash_aref(roptions, ID2SYM(rb_intern("alignment")));
+  int alignment = 0;
+  if (!NIL_P(ralign)) alignment = FIX2INT(ralign);
+
+  struct nk_style_button style;
+  memcpy(&style, &context->style.button, sizeof(style));
+  assign_button_style_from_ruby(&style, rstyle);
+
+  enum nk_symbol_type symbol = NK_SYMBOL_NONE;
+  SET_RSYMBOL(symbol, rsymbol);
+
+  int repeat = RTEST(rrepeat);
+  int result = 0;
+  if (repeat) nk_button_set_behavior(context, NK_BUTTON_REPEATER);
+  if (NIL_P(rtitle) && symbol == NK_SYMBOL_NONE && NIL_P(rimage)) {
+    if (NIL_P(rcolor)) {
+      rb_raise(rb_eArgError, "need :title or :symbol, with optional :image, or :color");
+    } else {
+      struct nk_color color;
+      ASSIGN_STYLE_AS_COLOR(color, nkrb_style_item(rcolor));
+      result = nk_button_color(context, color);
+    }
+  } else {
+    if (NIL_P(rtitle) && NIL_P(rimage)) {
+      result = nk_button_symbol_styled(context, &style, symbol);
+    } else if (!NIL_P(rtitle) && NIL_P(rimage)) {
+      result = nk_button_symbol_text_styled(context, &style, symbol, RSTRING_PTR(rtitle), (int) RSTRING_LEN(rtitle), alignment);
+    } else if (NIL_P(rtitle) && !NIL_P(rimage)) {
+      struct nk_image img;
+      ASSIGN_STYLE_AS_IMAGE(img, nkrb_style_item(rimage));
+      result = nk_button_image_text_styled(context, &style, img, RSTRING_PTR(rtitle), (int) RSTRING_LEN(rtitle), alignment);
+    } else {
+      struct nk_image img;
+      ASSIGN_STYLE_AS_IMAGE(img, nkrb_style_item(rimage));
+      result = nk_button_image_styled(context, &style, img);
+    }
+  }
+  if (repeat) nk_button_set_behavior(context, NK_BUTTON_DEFAULT);
+
+  return INT2FIX(result);
+}
+
+void nkrb_ui_button_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_button", nkrb_ui_button, 2);
+}

data/ext/nuklear/nkrb_ui_color_picker.c

@@ -0,0 +1,20 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_color_picker(VALUE self, VALUE rcontext, VALUE rcolor, VALUE rtype) {
+  struct nk_context *ctx = nkrb_context_get(rcontext);
+  enum nk_color_format type = (SYM2ID(rtype) == rb_intern("rgb")) ? NK_RGB : NK_RGBA;
+  struct nk_style_item *style = nkrb_style_item(rcolor);
+  struct nk_color color;
+  ASSIGN_STYLE_AS_COLOR(color, style);
+
+  if (nk_color_pick(ctx, &color, type)) {
+    style->data.color = color;
+    return rcolor;
+  }
+
+  return Qnil;
+}
+
+void nkrb_ui_color_picker_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_color_picker", nkrb_ui_color_picker, 3);
+}

data/ext/nuklear/nkrb_ui_combo.c

@@ -0,0 +1,73 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_combo(VALUE self, VALUE rcontext, VALUE rselected_index,
+                    VALUE rchoices, VALUE ritem_height, VALUE rwidth, VALUE rheight) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+  float width = (float) NUM2DBL(rwidth);
+  float height = (float) NUM2DBL(rheight);
+  int item_height = FIX2INT(ritem_height);
+  int len = (int) RARRAY_LEN(rchoices);
+  int selected_index = FIX2INT(rselected_index);
+  int i;
+  const char **choices = malloc(len * sizeof(const char *));
+  for (i = 0; i < len; i++) {
+    VALUE str = rb_funcall(rb_ary_entry(rchoices, i), rb_intern("to_s"), 0);
+    choices[i] = StringValueCStr(str);
+  }
+  int result = nk_combo(context, choices, len, selected_index, item_height, nk_vec2(width, height));
+  free(choices);
+  return INT2FIX(result);
+}
+
+VALUE nkrb_ui_combobox(VALUE self, VALUE rcontext, VALUE rtext, VALUE rcolor,
+                       VALUE rsymbol, VALUE rimage, VALUE rwidth, VALUE rheight) {
+  struct nk_context *context = nkrb_context_get(rcontext);
+  float width = (float) NUM2DBL(rwidth);
+  float height = (float) NUM2DBL(rheight);
+  int result = 0;
+  enum nk_symbol_type symbol = NK_SYMBOL_NONE;
+  SET_RSYMBOL(symbol, rsymbol);
+  struct nk_vec2 size = nk_vec2(width, height);
+
+  if (!NIL_P(rcolor)) {
+    struct nk_color color;
+    ASSIGN_STYLE_AS_COLOR(color, nkrb_style_item(rcolor));
+    result = nk_combo_begin_color(context, color, nk_vec2(width, height));
+  } else if (!NIL_P(rtext)) {
+    rtext = rb_funcall(rtext, rb_intern("to_s"), 0);
+    const char *text = StringValuePtr(rtext);
+    int len = (int) RSTRING_LEN(rtext);
+    if (!NIL_P(rsymbol)) {
+      result = nk_combo_begin_symbol_text(context, text, len, symbol, size);
+    } else if (!NIL_P(rimage)) {
+      struct nk_image img;
+      ASSIGN_STYLE_AS_IMAGE(img, nkrb_style_item(rimage));
+      result = nk_combo_begin_image_text(context, text, len, img, size);
+    } else {
+      result = nk_combo_begin_text(context, text, len, size);
+    }
+  } else {
+    if (!NIL_P(symbol)) {
+      result = nk_combo_begin_symbol(context, symbol, size);
+    } else if (!NIL_P(rimage)) {
+      struct nk_image img;
+      ASSIGN_STYLE_AS_IMAGE(img, nkrb_style_item(rimage));
+      result = nk_combo_begin_image(context, img, size);
+    } else {
+      return Qnil;
+    }
+  }
+
+  if (rb_block_given_p())
+    rb_yield(result ? Qtrue : Qfalse);
+  
+  if (result)
+    nk_combo_end(context);
+
+  return Qnil;
+}
+
+void nkrb_ui_combo_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_combobox", nkrb_ui_combobox, 7);
+  rb_define_method(mNuklearUIContainer, "ui_combo",    nkrb_ui_combo,    6);
+}

data/ext/nuklear/nkrb_ui_container.c

@@ -0,0 +1,7 @@
+#include "nkrb.h"
+
+VALUE mNuklearUIContainer = Qnil;
+
+void nkrb_ui_container_init(void) {
+  mNuklearUIContainer = rb_define_module_under(mNuklearUI, "Container");
+}

data/ext/nuklear/nkrb_ui_edit_string.c

@@ -0,0 +1,38 @@
+#include "nkrb.h"
+
+VALUE nkrb_ui_edit_string(VALUE self, VALUE context, VALUE rflags, VALUE rbuffer, VALUE max_length, VALUE rfilter) {
+  Check_Type(rbuffer, T_STRING);
+  rfilter = rb_funcall(rfilter, rb_intern("to_s"), 0);
+  int buffer_size = FIX2INT(max_length) + 1;
+  char *buffer = malloc(buffer_size);
+  memset(buffer, 0, buffer_size);
+  char *ptr = RSTRING_PTR(rbuffer);
+  int rbuffer_len = (int) RSTRING_LEN(rbuffer);
+  if (rbuffer_len > buffer_size - 1) rbuffer_len = buffer_size - 1;
+  memcpy(buffer, ptr, rbuffer_len);
+  nk_plugin_filter filter = nk_filter_default;
+  if (!strcmp(StringValueCStr(rfilter), "ascii"))   filter = nk_filter_ascii;
+  if (!strcmp(StringValueCStr(rfilter), "float"))   filter = nk_filter_float;
+  if (!strcmp(StringValueCStr(rfilter), "decimal")) filter = nk_filter_decimal;
+  if (!strcmp(StringValueCStr(rfilter), "hex"))     filter = nk_filter_hex;
+  if (!strcmp(StringValueCStr(rfilter), "octal"))   filter = nk_filter_oct;
+  if (!strcmp(StringValueCStr(rfilter), "binary"))  filter = nk_filter_binary;
+  int start_len = rbuffer_len;
+  nk_flags result = nk_edit_string(nkrb_context_get(context), FIX2INT(rflags), buffer, &rbuffer_len, buffer_size - 1, filter);
+  if (rbuffer_len != start_len || memcmp(buffer, ptr, rbuffer_len)) {
+    rb_funcall(rbuffer, rb_intern("clear"), 0);
+    rb_str_cat(rbuffer, buffer, rbuffer_len);
+  }
+  free(buffer);
+  return INT2FIX(result);
+}
+
+VALUE nkrb_ui_edit_focus(VALUE self, VALUE context, VALUE rflags) {
+  nk_edit_focus(nkrb_context_get(context), FIX2INT(rflags));
+  return Qnil;
+}
+
+void nkrb_ui_edit_string_init(void) {
+  rb_define_method(mNuklearUIContainer, "ui_edit_string", nkrb_ui_edit_string, 5);
+  rb_define_method(mNuklearUIContainer, "ui_edit_focus",  nkrb_ui_edit_focus, 2);
+}