nuklear 0.1.0

data/ext/nuklear_renderer_opengl4/nuklear_renderer_opengl4.c

@@ -0,0 +1,255 @@
+/* Heavily adapted from https://github.com/vurtun/nuklear/blob/master/demo/sdl_opengl3/nuklear_sdl_gl3.h */
+
+#define NK_IMPLEMENTATION
+#include "../nuklear/nuklear.h"
+#include "glad.h"
+#include <ruby.h>
+
+#define MAX_VERTEX_MEMORY 512 * 1024
+#define MAX_ELEMENT_MEMORY 128 * 1024
+
+VALUE mNuklear = Qnil;
+VALUE cNuklearRenderer = Qnil;
+VALUE cNuklearRendererOpenGL4 = Qnil;
+VALUE cNuklearBuffer = Qnil;
+
+#ifdef __APPLE__
+  #define NK_SHADER_VERSION "#version 150\n"
+#else
+  #define NK_SHADER_VERSION "#version 300 es\n"
+#endif
+
+static const GLchar *vertex_shader =
+        NK_SHADER_VERSION
+        "uniform mat4 ProjMtx;\n"
+        "in vec2 Position;\n"
+        "in vec2 TexCoord;\n"
+        "in vec4 Color;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main() {\n"
+        "   Frag_UV = TexCoord;\n"
+        "   Frag_Color = Color;\n"
+        "   gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n"
+        "}\n";
+
+static const GLchar *fragment_shader =
+    NK_SHADER_VERSION
+    "precision mediump float;\n"
+    "uniform sampler2D Texture;\n"
+    "in vec2 Frag_UV;\n"
+    "in vec4 Frag_Color;\n"
+    "out vec4 Out_Color;\n"
+    "void main(){\n"
+    "   Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+    "}\n";
+
+struct vertex {
+  float position[2];
+  float uv[2];
+  nk_byte col[4];
+};
+
+void nuklear_command_buffer_free(struct nk_buffer *buf) {
+  nk_buffer_free(buf);
+}
+
+VALUE renderer_initialize(VALUE self, VALUE context) {
+  if (!gladLoadGL())
+    rb_raise(rb_eStandardError, "Failed to init GLAD");
+  // printf("OpenGL %s, GLSL %s\n", glGetString(GL_VERSION), glGetString(GL_SHADING_LANGUAGE_VERSION));
+
+  rb_call_super(1, &context);
+
+  int status;
+  int prog = glCreateProgram();
+  int vert_shdr = glCreateShader(GL_VERTEX_SHADER);
+  int frag_shdr = glCreateShader(GL_FRAGMENT_SHADER);
+  glShaderSource(vert_shdr, 1, &vertex_shader, 0);
+  glShaderSource(frag_shdr, 1, &fragment_shader, 0);
+  glCompileShader(vert_shdr);
+  glCompileShader(frag_shdr);
+  glGetShaderiv(vert_shdr, GL_COMPILE_STATUS, &status);
+  assert(status == GL_TRUE);
+  glGetShaderiv(frag_shdr, GL_COMPILE_STATUS, &status);
+  assert(status == GL_TRUE);
+  glAttachShader(prog, vert_shdr);
+  glAttachShader(prog, frag_shdr);
+  glLinkProgram(prog);
+  glGetProgramiv(prog, GL_LINK_STATUS, &status);
+  assert(status == GL_TRUE);
+
+  int uniform_tex  = glGetUniformLocation(prog, "Texture");
+  int uniform_proj = glGetUniformLocation(prog, "ProjMtx");
+  int attrib_pos   = glGetAttribLocation(prog, "Position");
+  int attrib_uv    = glGetAttribLocation(prog, "TexCoord");
+  int attrib_col   = glGetAttribLocation(prog, "Color");
+
+  /* buffer setup */
+  GLsizei vs = sizeof(struct vertex);
+  size_t vp = offsetof(struct vertex, position);
+  size_t vt = offsetof(struct vertex, uv);
+  size_t vc = offsetof(struct vertex, col);
+
+  GLuint vbo, ebo, vao;
+
+  glGenBuffers(1, &vbo);
+  glGenBuffers(1, &ebo);
+  glGenVertexArrays(1, &vao);
+
+  glBindVertexArray(vao);
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
+
+  glEnableVertexAttribArray((GLuint)attrib_pos);
+  glEnableVertexAttribArray((GLuint)attrib_uv);
+  glEnableVertexAttribArray((GLuint)attrib_col);
+
+  glVertexAttribPointer((GLuint)attrib_pos, 2, GL_FLOAT, GL_FALSE, vs, (void*)vp);
+  glVertexAttribPointer((GLuint)attrib_uv, 2, GL_FLOAT, GL_FALSE, vs, (void*)vt);
+  glVertexAttribPointer((GLuint)attrib_col, 4, GL_UNSIGNED_BYTE, GL_TRUE, vs, (void*)vc);
+
+  glBindTexture(GL_TEXTURE_2D, 0);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+  glBindVertexArray(0);
+
+  rb_ivar_set(self, rb_intern("@program"),      INT2FIX(prog));
+  rb_ivar_set(self, rb_intern("@uniform_tex"),  INT2FIX(uniform_tex));
+  rb_ivar_set(self, rb_intern("@uniform_proj"), INT2FIX(uniform_proj));
+  rb_ivar_set(self, rb_intern("@vao"),          INT2FIX(vao));
+  rb_ivar_set(self, rb_intern("@vbo"),          INT2FIX(vbo));
+  rb_ivar_set(self, rb_intern("@ebo"),          INT2FIX(ebo));
+
+  return self;
+}
+
+VALUE renderer_render_gl(VALUE self) {
+  struct nk_context *ctx;
+  struct nk_buffer *cmds;
+  VALUE window_size = rb_funcall(self, rb_intern("window_size"), 0);
+  VALUE drawable_size = rb_funcall(self, rb_intern("drawable_size"), 0);
+  VALUE window_width = rb_ary_entry(window_size, 0);
+  VALUE window_height = rb_ary_entry(window_size, 1);
+  VALUE drawable_width = rb_ary_entry(drawable_size, 0);
+  VALUE drawable_height = rb_ary_entry(drawable_size, 1);
+  int program = FIX2INT(rb_ivar_get(self, rb_intern("@program")));
+  int uniform_tex = FIX2INT(rb_ivar_get(self, rb_intern("@uniform_tex")));
+  int uniform_proj = FIX2INT(rb_ivar_get(self, rb_intern("@uniform_proj")));
+  int width = FIX2INT(window_width),
+      height = FIX2INT(window_height);
+  int display_width = FIX2INT(drawable_width),
+      display_height = FIX2INT(drawable_height);
+  struct nk_draw_null_texture *null_tex;
+  struct nk_vec2 scale;
+  VALUE context = rb_ivar_get(self, rb_intern("@context"));
+  Data_Get_Struct(rb_ivar_get(context, rb_intern("@null")), struct nk_draw_null_texture, null_tex);
+  Data_Get_Struct(context, struct nk_context, ctx);
+  Data_Get_Struct(rb_ivar_get(self, rb_intern("@commands")), struct nk_buffer, cmds);
+
+  GLfloat ortho[4][4] = {
+      {2.0f, 0.0f, 0.0f, 0.0f},
+      {0.0f,-2.0f, 0.0f, 0.0f},
+      {0.0f, 0.0f,-1.0f, 0.0f},
+      {-1.0f,1.0f, 0.0f, 1.0f},
+  };
+  ortho[0][0] /= (GLfloat)width;
+  ortho[1][1] /= (GLfloat)height;
+
+  scale.x = (float)display_width/(float)width;
+  scale.y = (float)display_height/(float)height;
+
+  /* setup global state */
+  glViewport(0,0,display_width,display_height);
+  glEnable(GL_BLEND);
+  glBlendEquation(GL_FUNC_ADD);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  glDisable(GL_CULL_FACE);
+  glDisable(GL_DEPTH_TEST);
+  glEnable(GL_SCISSOR_TEST);
+  glActiveTexture(GL_TEXTURE0);
+
+  /* setup program */
+  glUseProgram(program);
+  glUniform1i(uniform_tex, 0);
+  glUniformMatrix4fv(uniform_proj, 1, GL_FALSE, &ortho[0][0]);
+
+  rb_call_super(0, NULL);
+
+  glUseProgram(0);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+  glBindVertexArray(0);
+  glDisable(GL_SCISSOR_TEST);
+  glEnable(GL_CULL_FACE);
+  glEnable(GL_DEPTH_TEST);
+
+  return self;
+}
+
+VALUE renderer_nk_convert_gl(VALUE self) {
+  VALUE result = rb_call_super(0, NULL);
+
+  struct nk_buffer *vertices = NULL;
+  struct nk_buffer *indices  = NULL;
+  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);
+
+  int vao = FIX2INT(rb_ivar_get(self, rb_intern("@vao")));
+  int vbo = FIX2INT(rb_ivar_get(self, rb_intern("@vbo")));
+  int ebo = FIX2INT(rb_ivar_get(self, rb_intern("@ebo")));
+  glBindVertexArray(vao);
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
+  glBufferData(GL_ARRAY_BUFFER,
+               MAX_VERTEX_MEMORY,
+               nk_buffer_memory_const(vertices),
+               GL_STREAM_DRAW);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER,
+               MAX_ELEMENT_MEMORY,
+               nk_buffer_memory_const(indices),
+               GL_STREAM_DRAW);
+  return result;
+}
+
+VALUE renderer_draw_gl(VALUE self, VALUE cmd) {
+  VALUE window_size = rb_funcall(self, rb_intern("window_size"), 0);
+  VALUE drawable_size = rb_funcall(self, rb_intern("drawable_size"), 0);
+  VALUE window_width = rb_ary_entry(window_size, 0);
+  VALUE window_height = rb_ary_entry(window_size, 1);
+  VALUE drawable_width = rb_ary_entry(drawable_size, 0);
+  VALUE drawable_height = rb_ary_entry(drawable_size, 1);
+  int width = FIX2INT(window_width),
+      height = FIX2INT(window_height);
+  int display_width = FIX2INT(drawable_width),
+      display_height = FIX2INT(drawable_height);
+  struct nk_vec2 scale;
+  scale.x = (float)display_width/(float)width;
+  scale.y = (float)display_height/(float)height;
+
+  VALUE clip_rect = rb_hash_aref(cmd, ID2SYM(rb_intern("clip_rect")));
+  float x = (float) NUM2DBL(RARRAY_AREF(clip_rect, 0));
+  float y = (float) NUM2DBL(RARRAY_AREF(clip_rect, 1));
+  float w = (float) NUM2DBL(RARRAY_AREF(clip_rect, 2));
+  float h = (float) NUM2DBL(RARRAY_AREF(clip_rect, 3));
+  glBindTexture(GL_TEXTURE_2D, (GLuint) NUM2UINT(rb_hash_aref(cmd, ID2SYM(rb_intern("texture_handle")))));
+  glScissor((GLint)(x * scale.x),
+            (GLint)((height - (GLint)(y + h)) * scale.y),
+            (GLint)(w * scale.x),
+            (GLint)(h * scale.y));
+  glDrawElements(GL_TRIANGLES, (GLsizei)NUM2UINT(rb_hash_aref(cmd, ID2SYM(rb_intern("element_count")))),
+                 GL_UNSIGNED_SHORT, (void *) NUM2UINT(rb_hash_aref(cmd, ID2SYM(rb_intern("offset")))));
+  return self;
+}
+
+void Init_nuklear_renderer_opengl4(void) {
+  mNuklear = rb_define_module("Nuklear");
+  cNuklearRenderer = rb_define_class_under(mNuklear, "Renderer", rb_cObject);
+  cNuklearRendererOpenGL4 = rb_define_class_under(cNuklearRenderer, "OpenGL4", cNuklearRenderer);
+  cNuklearBuffer = rb_const_get(mNuklear, rb_intern("Buffer"));
+
+  rb_define_method(cNuklearRendererOpenGL4, "initialize", renderer_initialize, 1);
+  rb_define_method(cNuklearRendererOpenGL4, "nk_convert", renderer_nk_convert_gl, 0);
+  rb_define_method(cNuklearRendererOpenGL4, "draw",       renderer_draw_gl, 1);
+  rb_define_method(cNuklearRendererOpenGL4, "render",     renderer_render_gl, 0);
+}

data/lib/nuklear/context.rb

@@ -0,0 +1,49 @@
+module Nuklear
+  class Context
+    include Nuklear::UI::Container
+    attr_accessor :renderer
+    attr_reader :events
+
+    def events
+      @events ||= EventBuffer.new
+    end
+
+    def process_commands
+      remaining = commands.dup
+      while remaining.any?
+        cmd = remaining.shift
+        # cmd.tick(delta) if cmd.respond_to?(:tick)
+        remaining.concat cmd.commands if cmd.respond_to?(:commands)
+      end
+    end
+
+    # Triggers an event. The event name must be one of the symbols defined
+    # in Nuklear::EventBuffer::EVENT_NAMES.
+    def trigger(event_name, *event_args)
+      events.add(event_name, *event_args)
+    end
+
+    def dsl(&block)
+      Nuklear::DSL.new(self, &block)
+    end
+
+    # Draws the UI. This method will be called at the appropriate time in the
+    # Nuklear frame update process. It should not be called directly.
+    protected def paint
+      run_commands(self)
+      renderer.render
+    end
+
+    # Events (window events, input events, etc) will accumulate over time.
+    # Nuklear requires these events to be processed at the proper time or else
+    # issues could arise. This method will be called at the appropriate time
+    # in order to handle the events that have accumulated since the last
+    # frame. It should not be called directly.
+    protected def process_pending_events
+      events.drain do |evt|
+        @event_sink.send(*evt)
+      end
+    end
+
+  end
+end

data/lib/nuklear/dsl.rb

@@ -0,0 +1,46 @@
+require 'nuklear/ui'
+
+module Nuklear
+  class DSL
+    def initialize(ctx, &block)
+      @ctx = ctx
+      instance_eval(&block) if block_given?
+    end
+
+    def add_component(klass, *args, **kw, &block)
+      # if klass initialize accepts a block, pass the block into that. The
+      # caller must call .dsl on the result if they want a nested DSL.
+      if block_given? && klass.instance_method(:initialize).parameters.last[0] == :block
+        instance = klass.new(*args, **kw, &block)
+        @ctx << instance
+      else # assume block is for a nested DSL
+        instance = klass.new(*args, **kw)
+        @ctx << instance
+        instance.dsl(&block) if block_given?
+      end
+      instance
+    end
+
+    def method_missing(name, *args, **kw, &block)
+      @ctx.send(name, *args, **kw, &block)
+    end
+
+    def respond_to?(name)
+      super || @ctx.respond_to?(name)
+    end
+
+    # Scans all descendants of Nuklear::UI::Base and defines DSL method names
+    # based on each component name. This happens once automatically at startup
+    # but if you are having trouble with a new custom UI component, then you
+    # can call this method to make sure it's been defined.
+    def self.prepare!
+      Nuklear::UI::Base.descendants.each do |descendant|
+        define_method descendant.dsl_method_name do |*args, **kw, &block|
+          add_component(descendant, *args, **kw, &block)
+        end
+      end
+    end
+
+    prepare!
+  end
+end

data/lib/nuklear/event_buffer.rb

@@ -0,0 +1,23 @@
+module Nuklear
+  # Stores staged events waiting to be drained.
+  class EventBuffer
+    # These correlate to methods defined by Nuklear::Context::EventSink.
+    EVENT_NAMES = [:motion, :key, :button, :scroll, :char, :glyph, :unicode]
+
+    attr_reader :pending_events
+
+    def initialize
+      @pending_events = []
+    end
+
+    def drain
+      @pending_events.each { |evt| yield(evt) }
+      @pending_events.clear
+    end
+
+    def add(event_name, *event_args)
+      super unless EVENT_NAMES.include?(event_name)
+      @pending_events << [event_name, *event_args]
+    end
+  end
+end

data/lib/nuklear/renderer/opengl24.rb

@@ -0,0 +1,13 @@
+module Nuklear
+  class Renderer
+    def self.renderer_class
+      if SDL2::GL.get_attribute(SDL2::GL::CONTEXT_MAJOR_VERSION) > 2
+        require 'nuklear_renderer_opengl4'
+        Nuklear::Renderer::OpenGL4
+      else
+        require 'nuklear_renderer_opengl2'
+        Nuklear::Renderer::OpenGL2
+      end
+    end
+  end
+end

data/lib/nuklear/renderer.rb

@@ -0,0 +1,108 @@
+require 'fiddle/import'
+
+module Nuklear
+  # This base class provides a pure-Ruby renderer implementation for Nuklear.
+  # Importantly, it doesn't actually *draw* anything. Instead it provides a
+  # generic renderer implementation where subclasses need only override the
+  # #draw method to draw something.
+  #
+  # In most cases, subclasses will also have to override #initialize to set up
+  # one-time state (e.g. compiling shaders), and also #render to set up
+  # per-frame state (e.g. activating shaders). In both cases, subclasses
+  # should call `super`.
+  #
+  class Renderer
+    attr_accessor :window_size
+    attr_writer :drawable_size
+
+    # Returns the configuration necessary for converting a Nuklear rendering
+    # pass into a renderer-specific one. This data can be changed at run-time;
+    # it is not cached.
+    attr_accessor :convert_config
+
+    # Assign the handle for a 1x1 white texture to this accessor. It doesn't
+    # matter what format this takes, (GL texture ID, memory address of texture
+    # data, etc), as long as the renderer can decode this into a usable result
+    # when it's passed back to it later on.
+    attr_reader :null_texture_handle
+
+    # Nuklear::Buffer containing vertex data
+    attr_reader :vertices
+
+    # Nuklear::Buffer containing vertex index data
+    attr_reader :vertex_indices
+
+    # Nuklear::Buffer containing command data
+    attr_reader :commands
+
+    # Nuklear::Context for this renderer
+    attr_reader :context
+
+    Vertex = Fiddle::Importer.struct [
+      'float position[3]',
+      'float uv[3]',
+      'unsigned char color[4]'
+    ]
+
+    # For all renderer implementations, override #initialize to set up your
+    # initial state (e.g. compiling shaders) and call `super`.
+    def initialize(context)
+      @commands = Nuklear::Buffer.new
+      @vertices = Nuklear::Buffer.new
+      @vertex_indices = Nuklear::Buffer.new
+      @context = context
+      @window_size = [640, 480]
+      @drawable_size = nil
+      @null_texture_handle = 0
+      @convert_config = {
+        vertex_layout: [
+          [:position, :float,    Vertex.offsetof('position')],
+          [:texcoord, :float,    Vertex.offsetof('uv')],
+          [:color,    :r8g8b8a8, Vertex.offsetof('color')]
+        ],
+        vertex_size: Vertex.size,
+        vertex_alignment: Vertex.alignment,
+        null: null_texture_handle,
+        circle_segment_count: 22,
+        curve_segment_count: 22,
+        arc_segment_count: 22,
+        global_alpha: 1.0,
+        shape_aa: true,
+        line_aa: true
+      }
+    end
+
+    def null_texture_handle=(n)
+      @null_texture_handle = n
+      @convert_config[:null] = n
+    end
+
+    def drawable_size
+      @drawable_size || window_size
+    end
+
+    # Called at the start of a render pass. Renderers may wish to override
+    # this method to apply once-per-frame state updates. They should call
+    # `super` when they are ready to proceed.
+    def render
+      nk_convert
+      nk_draw_foreach { |command| draw(command) }
+    end
+
+    # Called for each Nuklear draw command, numerous times per render pass.
+    # Renderers should override this method to actually draw something, but
+    # keep this method as lightweight as possible.
+    #
+    # `element_count`: The number of elements to be drawn.
+    # `clip_rect`: An array containing the x, y, width and height
+    #              (in that order) of the region to be drawn to.
+    # `texture_handle`: The handle of a texture to be drawn. See
+    #                   #null_texture_handle.
+    # `offset`: The number of elements already drawn, not including the
+    #           current command.
+    #
+    def draw(cmd)
+
+    end
+  end
+end

data/lib/nuklear/style/color.rb

@@ -0,0 +1,24 @@
+module Nuklear
+  module Style
+    class Color
+      # defined in C
+      # attr_accessor :red, :green, :blue, :alpha
+      # attr_accessor :hue, :saturation, :value
+
+      def initialize(r, g, b, a = 1)
+        self.red   = r
+        self.green = g
+        self.blue  = b
+        self.alpha = a
+      end
+
+      def self.from_bytes(r, g, b, a = 255)
+        new(r / 255.0, g / 255.0, b / 255.0, a / 255.0)
+      end
+
+      def inspect
+        "#<#{self.class.name} red=#{red} green=#{green} blue=#{blue} alpha=#{alpha}>"
+      end
+    end
+  end
+end

data/lib/nuklear/style/image.rb

@@ -0,0 +1,9 @@
+module Nuklear
+  module Style
+    class Image
+      def initialize(id)
+        self.id = id
+      end
+    end
+  end
+end

data/lib/nuklear/style.rb

@@ -0,0 +1,8 @@
+module Nuklear
+  module UI
+    module Style
+      require 'nuklear/style/color'
+      require 'nuklear/style/image'
+    end
+  end
+end

data/lib/nuklear/test_case.rb

@@ -0,0 +1,30 @@
+module Nuklear
+  module TestCase
+    def nuklear
+      @nuklear || raise("Nuklear::TestCase requires you to assign a Nuklear::Context to @nuklear during your test setup.")
+    end
+
+    def tick
+      raise "Nuklear::TestCase requires you to override #tick to process window events and to call your Nuklear::Context#tick method."
+    end
+
+    def click_button(text)
+      els = nuklear.find do |item|
+        item.kind_of?(Nuklear::UI::Button) && item.respond_to?(:text) && item.text[text]
+      end
+      if els.count > 1
+        raise "Ambiguous text: #{text} (found #{els.inspect})"
+      elsif els.empty?
+        raise "Cannot find an element with text: #{text.inspect}"
+      else
+        els.first.trigger(:clicked)
+      end
+      tick
+    end
+
+    def assert_text(txt)
+      refute_empty nuklear.find { |el| el.respond_to?(:text) && el.text[txt] },
+                   "Expected to find at least one element with text: #{txt.inspect}"
+    end
+  end
+end

data/lib/nuklear/ui/base.rb

@@ -0,0 +1,34 @@
+module Nuklear
+  module UI
+    class Base
+      include Nuklear::UI::Events
+      include Nuklear::UI::Enableable
+
+      def initialize(enabled: true)
+        self.enabled = enabled
+      end
+
+      def dsl(&block)
+        require 'nuklear/dsl'
+        Nuklear::DSL.new(self, &block)
+      end
+
+      class << self
+        attr_writer :dsl_method_name
+
+        def dsl_method_name
+          # Nukelar::UI::ColorPicker => 'color_picker'
+          @dsl_method_name ||= name.split('::').last.gsub(/([A-Z])/) { |a| "_#{a.downcase}" }.sub(/^_/, '')
+        end
+
+        def descendants
+          @descendants ||= []
+        end
+
+        def inherited(child)
+          descendants << child
+        end
+      end
+    end
+  end
+end

data/lib/nuklear/ui/button.rb

@@ -0,0 +1,77 @@
+module Nuklear
+  module UI
+    class Button < Nuklear::UI::Base
+      include Nuklear::UI::TextAlign
+      
+      attr_accessor :text
+
+      # A hash which may contain the following options:
+      #    :normal          => a style item, see the classes contained in Nuklear::Style
+      #    :hover           => a style item, see the classes contained in Nuklear::Style
+      #    :active          => a style item, see the classes contained in Nuklear::Style
+      #    :border_color    => an instance of Nuklear::Style::Color
+      #    :text_background => an instance of Nuklear::Style::Color
+      #    :text_normal     => an instance of Nuklear::Style::Color
+      #    :text_hover      => an instance of Nuklear::Style::Color
+      #    :text_active     => an instance of Nuklear::Style::Color
+      #    :text_alignment  => a set of alignment flags
+      #    :border          => a float
+      #    :rounding        => a float
+      #    :padding         => a vec2 of floats
+      #    :image_padding   => a vec2 of floats
+      #    :touch_padding   => a vec2 of floats
+      attr_accessor :style
+
+      # Whether the button click event will repeat while the button is pressed
+      attr_writer :repeat
+
+      attr_accessor :color
+
+      # One of: nil, :x, :underscore, :circle_solid, :circle_outline,
+      # :rect_solid, :rect_outline, :triangle_up, :triangle_down,
+      # :triangle_left, :triangle_right, :plus, :minus or :max
+      attr_accessor :symbol
+
+      attr_accessor :image
+
+      # nil, or a set of alignment flags
+      attr_accessor :align
+
+      def initialize(text = nil, style: nil, repeat: false, color: nil, symbol: nil, image: nil, align: nil, **options, &block)
+        super(**options)
+        @text = text
+        @style = style
+        @repeat = repeat
+        @color = color
+        @symbol = symbol
+        @image = image
+        @align = align
+        on(:clicked, &block) if block_given?
+      end
+
+      def repeat?
+        @repeat
+      end
+
+      def to_command
+        [
+          :ui_button, {
+            repeat: repeat?,
+            title: text,
+            color: color,
+            symbol: symbol,
+            image: image,
+            style: style,
+            alignment: align_as_flags(align)
+          }
+        ]
+      end
+
+      def result(result, context)
+        if result == 1 then trigger(:clicked)
+        else trigger(:released)
+        end
+      end
+    end
+  end
+end