nuklear 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 00d829f1e7f4d4d305a18e1d831df3cd95874224581986977a89fd2eb114da0f
+  data.tar.gz: 45da4ef0e277ca42d642919a06c8086952c695a139b45265df6d5b7ceb4d5aaa
+SHA512:
+  metadata.gz: baa5798e57b4f1765b4e819ee7dac4db9aa40e172f44fd48c74ff6b6942bc8c0d5afdc55cc137aeb400b4c48f51cd5286000b4b849505e11b94f2de2e8e9ec43
+  data.tar.gz: f37d1e63dcb902f2752c21e37d3ceaebccb0a2b5b9d50d615925049010dc2eedf3c726da9edc0687a63ba9ec651ffcd03cbc052cd0ea16c1b38e28275aa9e777

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 2.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in nuklear.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    nuklear (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.15.0)
+    opengl-bindings (1.6.12)
+    rake (13.0.6)
+    rake-compiler (1.1.9)
+      rake
+    ruby-sdl2 (0.3.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 2.0)
+  minitest (>= 5.0)
+  nuklear!
+  opengl-bindings
+  rake (>= 10.0)
+  rake-compiler
+  ruby-sdl2
+
+BUNDLED WITH
+   2.2.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Colin MacKenzie IV
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,196 @@
+# Nuklear
+
+Ruby bindings for [Nuklear](https://github.com/Immediate-Mode-UI/Nuklear).
+
+Here is the description from the Nuklear project:
+
+> This is a minimal-state, immediate-mode graphical user interface toolkit
+> written in ANSI C and licensed under public domain. It was designed as a
+> simple embeddable user interface for application and does not have any
+> dependencies, a default render backend or OS window/input handling but
+> instead provides a highly modular, library-based approach, with simple
+> input state for input and draw commands describing primitive shapes as
+> output. So instead of providing a layered library that tries to abstract
+> over a number of platform and render backends, it focuses only on the actual
+> UI.
+
+This project implements a set of Ruby classes which wrap the Nuklear API. It
+also provides two sample renderers (OpenGL 2 and OpenGL 4).
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nuklear'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nuklear
+
+
+## Renderers
+
+The base class `Nuklear::Renderer` is essentially a headless renderer. It
+implements all necessary functionality to serve as a renderer for Nuklear,
+except the actual drawing, and is also intended to be subclassed for a custom
+renderer which actually draws something. The two bundled OpenGL renderers
+(`Nuklear::Renderer::OpenGL2` and `Nuklear::Renderer::OpenGL4`) are examples
+of this.
+
+
+## API
+
+The following examples are to help introduce you to how to use Nuklear, and
+to inform you as to how Nuklear fits into the larger design of a graphical
+application. They are not complete examples. For complete, functional
+examples, see the files in /examples/.
+
+
+## Initialization
+
+```ruby
+# Nuklear will load the font files for us, and will generate a font atlas
+# image. Then it will yield the width, height and pixel data of that image
+# to our block. Typically we would use this information to generate a
+# texture for our preferred rendering engine (OpenGL, Vulkan, etc.). Once
+# we have a handle, we pass that handle back to Nuklear as the result of
+# the block. Here we just use `0`. Nuklear will hold on to the handle,
+# and it will be passed back to us as part of draw calls involving the
+#font.
+font = Nuklear::Font.new("arial.ttf", 12) { |w, h, data| 0 }
+
+# Once we have our font, we can create a Nuklear context.
+ctx = Nuklear::Context.new(font)
+
+# The context requires a renderer. We can pass it an instance of
+# Nuklear::Renderer, but this will not actually draw anything.
+# Nuklear::Renderer is great for unit testing and as a base class for us
+# to actually implement our real renderer on top of. Here, we'll use the
+# bundled OpenGL 2 renderer.
+require 'nuklear/nuklear_renderer_opengl2'
+ctx.renderer = Nuklear::Renderer::OpenGL2.new(ctx)
+```
+
+### With DSL
+
+For convenience, a DSL is provided. It is particularly useful for building
+complex, mostly static interfaces as it removes a lot of the repetition that
+would come from using the primary interface. Here is a trivial example:
+
+```ruby
+ctx.dsl do
+  w = window "Hello Nuklear", left: 10, top: 10, width: 100, height: 100 do
+    layout_row_dynamic 35, 2
+    button "Click me" do
+      puts "Ouch!"
+      w.close # hide the window
+    end
+  end
+end
+```
+
+See `/examples/calculator.rb` for a more complete demonstration of the DSL.
+
+
+### Without DSL
+
+You can opt not to use the DSL, and instantiate the UI widgets directly. This
+is straightforward, but verbose. It can be helpful when you need to
+programmatically build an interface that doesn't need or desire a lot of
+syntactic sugar. For example, the DSL might actively hinder you if you were
+building an interface by parsing a YAML or XML file. Here is how we would
+build the same window as above without use of the DSL:
+
+```ruby
+# create the Nuklear window
+w = Nuklear::UI::Window.new "Hello Nuklear",
+                            left: 10,
+                            top: 10,
+                            width: 100,
+                            height: 100
+
+# Set up the window layout
+w.layout_row_dynamic 35, 2
+
+# Add the button to the window
+w << Nuklear::UI::Button.new "Click me" do
+  puts "Ouch!"
+  w.close # hide the window
+end
+
+# Add the window to the context
+ctx << w
+```
+
+See `/examples/hello_nuklear.rb` for a more complete demonstration without the
+DSL.
+
+
+### Main Loop
+
+Since Nuklear is backend-agnostic, you must do the backend stuff yourself. In
+all of the examples, you'll find that we use SDL2 for the window management
+and event processing, and OpenGL for the actual drawing. You may use whatever
+mechanisms you want, including none. (It's quite useful for unit testing to
+just use the Nuklear::Renderer base class for "drawing" and to
+programmatically deliver only specific window events to Nuklear.)
+
+The event processing loop can be a bit verbose, depending on how many events
+you want to respond to, so we'll just show some snippets here. You can find a
+more complete example in `/examples/hello_nuklear.rb`.
+
+```ruby
+# Initialize the viewport (OpenGL)
+glViewport(0, 0, *window.gl_drawable_size)
+glClearColor(0, 0, 0, 0)
+while true
+  # New frame: Clear the screen (OpenGL)
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+  # Process window, mouse, keyboard, etc events (SDL2)
+  while event = ::SDL2::Event.poll
+    case event
+    when SDL2::Event::Quit then exit
+    # ...
+  end
+
+  # Update the Nuklear context. This will generate/update the command buffer
+  # in preparation for rendering, then pass that command buffer to our
+  # renderer.
+  ctx.tick
+
+  # Show the rendered frame. (OpenGL)
+  window.gl_swap
+end
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then,
+run `rake test` to run the tests. You can also run `bin/console` for an
+interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then
+run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/[USERNAME]/nuklear.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,26 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("nuklear") do |ext|
+  ext.lib_dir = "lib/nuklear"
+end
+
+Rake::ExtensionTask.new("nuklear_renderer_opengl2") do |ext|
+  ext.lib_dir = "lib/nuklear"
+end
+
+Rake::ExtensionTask.new("nuklear_renderer_opengl4") do |ext|
+  ext.lib_dir = "lib/nuklear"
+end
+
+task :default => [:clobber, :compile, :test]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nuklear"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/calculator.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+#
+# This example is based loosely upon:
+# https://github.com/Immediate-Mode-UI/Nuklear/blob/master/demo/calculator.c
+#
+# This demonstrates using the Nuklear DSL to build and maintain a simple but
+# functional calculator. In order to show you only the most relevant
+# information, much of the set-up code has been moved to /examples/lib/ and
+# this file focuses mainly on the DSL. If you are more interested in the
+# set-up code and event loop, you will find that the files in /examples/lib/
+# are quite similar to what appears in /examples/hello_nuklear.rb.
+#
+require 'bundler/setup'
+require 'nuklear'
+require_relative 'lib/sdl2_init'
+require_relative 'lib/sdl2_input'
+require_relative 'lib/opengl_init'
+require_relative 'lib/opengl_font'
+require_relative 'lib/window'
+
+class Calculator
+  attr_reader :ctx, :window
+
+  def initialize(hidden: false)
+    @window = Examples::Window.new "Calculator Example", hidden: hidden
+    font = Examples::OpenGLFont.new File.expand_path("arial.ttf", __dir__)
+    @ctx = Nuklear::Context.new font.nuklear_handle
+    @window.nuklear_context = @ctx
+
+    numbers = '789456123'
+    ops = '+-*/'
+    operands = [0, 0]
+    current = 0
+    set = op = nil
+
+    @ctx.dsl do
+      window("Hello Nuklear", left: 10, top: 10, width: 180, height: 250,
+                              border: true, no_scrollbar: true, movable: true) do
+        layout_row_dynamic 35, 1
+        label = edit_string text: "0.0", flags: :simple, filter: :float, max_length: 255
+
+        layout_row_dynamic 35, 4
+        update = proc { label.text = '%.2f' % operands[current] }
+        solver = proc do
+          # operands[0] = operands[0] + operands[1]
+          operands[0] = operands[0].send(op, operands[1])
+          label.text = '%.2f' % operands[0]
+          current = 1
+          operands[1] = 0
+          set = true
+        end
+        16.times do |i|
+          if i >= 12 && i < 15
+            next if i > 12
+            button("C") { operands = [0, 0]; current = 0; op = nil; update.call }
+            button("0") { operands[current] *= 10; update.call }
+            button("=") { solver.call; op = nil }
+          elsif (i + 1) % 4 > 0
+            n = numbers[(i/4)*3+i%4]
+            button(n) do
+              operands[current] = operands[current] * 10 + n.to_i
+              set = nil
+              update.call
+            end
+          else
+            n = ops[i/4]
+            button(n) do
+              if !set
+                if current != 1
+                  current = 1
+                  update.call
+                else
+                  solver.call
+                end
+              end
+              op = ops[i/4]
+              set = true
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def tick
+    @window.frame do
+      @ctx.tick
+    end
+  end
+
+  def close
+    @window.close
+  end
+end
+
+if $0 == __FILE__
+  calculator = Calculator.new
+  while true
+    # process window events and render any display changes
+    calculator.tick
+  end
+end

data/examples/hello_nuklear.rb

@@ -0,0 +1,182 @@
+#!/usr/bin/env ruby
+#
+# This example is completely self-contained (the files in /examples/lib/ are
+# not used), so it makes a good "holistic" reference. It's a little on the
+# large side, mainly because of the SDL2 event loop as interesting events have
+# to be delegated into Nuklear so that, for example, button clicks actually
+# do something.
+#
+# This example also eschews the Nuklear DSL, instead preferring to instantiate
+# the UI widgets directly. Essentially, this shows you what is happening
+# within the DSL, and it can be a useful reference if you're in a situation
+# where the DSL is cumbersome to use. That said, it's not nearly as pretty
+# or intuitive as using the DSL would be.
+#
+require 'bundler/setup'
+require 'sdl2'
+require 'nuklear'
+require 'opengl'
+include OpenGL
+OpenGL.load_lib()
+
+module SDL2::Window::Flags
+  # Shim: Older versions of SDL2 for Ruby didn't define this flag.
+  ALLOW_HIGHDPI = 0x00002000 unless defined?(SDL2::Window::Flags::ALLOW_HIGHDPI)
+end
+
+# Initialize SDL2 and OpenGL.
+SDL2.init(SDL2::INIT_EVERYTHING)
+SDL2::GL.set_attribute(SDL2::GL::ACCELERATED_VISUAL, 1)
+window = SDL2::Window.create "Nuklear", 0, 0, 640, 480,
+                              SDL2::Window::Flags::OPENGL |
+                              SDL2::Window::Flags::ALLOW_HIGHDPI |
+                              SDL2::Window::Flags::RESIZABLE
+@gl = SDL2::GL::Context.create(window)
+
+# When Nuklear loads the font file it will yield to us the width, height
+# and baked font atlas image data. We must then tell OpenGL to load that
+# image data into a texture ID, and then pass the OpenGL texture ID back into
+# Nuklear for later reference.
+font = Nuklear::Font.new(File.expand_path("arial.ttf", __dir__), 14) do |w, h, data|
+  # give the image data to OpenGL
+  tex_names_buf = ' ' * 8
+  glGenTextures(1, tex_names_buf)
+  texture_id = tex_names_buf.unpack('L1')[0]
+  glBindTexture(GL_TEXTURE_2D, texture_id)
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data)
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+  # give the GL texture ID to Nuklear
+  texture_id
+end
+
+ctx = Nuklear::Context.new(font)
+
+# We'll use the OpenGL 2 renderer for Nuklear. Notice that we must tell the
+# renderer the size of the window and the size of the drawing surface, which
+# aren't always the same thing.
+require 'nuklear/nuklear_renderer_opengl2'
+ctx.renderer = Nuklear::Renderer::OpenGL2.new(ctx)
+ctx.renderer.window_size = window.size
+ctx.renderer.drawable_size = window.gl_drawable_size
+
+# We can now build our Nuklear UI. Let's create a window, then add a few
+# labels and a button to it.
+@window = Nuklear::UI::Window.new("Hello Nuklear",
+                                  left: 60, top: 60, width: 300, height: 200,
+                                  border: true, scalable: true, movable: true, minimizable: true)
+@window.layout_row_dynamic 35, 2
+@window << Nuklear::UI::Label.new("This is a label")
+@window << Nuklear::UI::Button.new("This is a button")
+@window << Nuklear::UI::Label.new("Frame number:")
+@window << @frame_num_label = Nuklear::UI::Label.new("0")
+# Let's also add a large, empty container to the window. This forces Nuklear
+# to add a scrollbar to the window.
+@window.layout_row_dynamic 200, 2
+container = Nuklear::UI::Group.new
+@window << container
+
+# Finally, add the window to the context so that Nuklear will render it. We
+# can add any number of windows.
+ctx << @window
+
+# Now for the main event loop. This loop is almost entirely dedicated to event
+# processing. Below the event processing, we'll deal with Nuklear.
+@frame_count = 0
+glViewport(0, 0, *window.gl_drawable_size)
+glClearColor(0, 0, 0, 0)
+@last_tick_time = Time.now
+while true
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+  while event = ::SDL2::Event.poll
+    case event
+    # TODO touch events
+    # when SDL2::Event::FingerMotion
+    # when SDL2::Event::FingerDown
+    # when SDL2::Event::FingerUp
+    when ::SDL2::Event::TextInput   then ctx.trigger(:glyph,  event.text)
+    when ::SDL2::Event::MouseMotion then ctx.trigger(:motion, event.x, event.y, event.xrel, event.yrel)
+    when ::SDL2::Event::MouseWheel  then ctx.trigger(:scroll, event.x, event.y)
+    when ::SDL2::Event::MouseButtonDown, ::SDL2::Event::MouseButtonUp
+      is_down = event.kind_of?(::SDL2::Event::MouseButtonDown)
+      if event.button == 1 and event.clicks > 1
+        ctx.trigger(:button, :double, event.x, event.y, is_down)
+      else
+        case event.button
+        # SDL_BUTTON_LEFT seems to be not defined
+        when 1 then ctx.trigger(:button, :left,   event.x, event.y, is_down)
+        when 2 then ctx.trigger(:button, :middle, event.x, event.y, is_down)
+        when 3 then ctx.trigger(:button, :right,  event.x, event.y, is_down)
+        end
+      end
+    when ::SDL2::Event::Window
+      case event.event
+      when ::SDL2::Event::Window::FOCUS_GAINED then @focused = true
+      when ::SDL2::Event::Window::FOCUS_LOST   then @focused = false
+      end
+    when ::SDL2::Event::KeyDown, ::SDL2::Event::KeyUp
+      is_down = event.kind_of?(::SDL2::Event::KeyDown)
+      case event.sym
+      when ::SDL2::Key::LSHIFT, ::SDL2::Key::RSHIFT then ctx.trigger(:key, :shift,           is_down)
+      when ::SDL2::Key::DELETE                      then ctx.trigger(:key, :del,             is_down)
+      when ::SDL2::Key::RETURN                      then ctx.trigger(:key, :enter,           is_down)
+      when ::SDL2::Key::TAB                         then ctx.trigger(:key, :tab,             is_down)
+      when ::SDL2::Key::BACKSPACE                   then ctx.trigger(:key, :backspace,       is_down)
+      when ::SDL2::Key::HOME                        then ctx.trigger(:key, :text_start,      is_down)
+                                                         ctx.trigger(:key, :scroll_start,    is_down)
+      when ::SDL2::Key::END                         then ctx.trigger(:key, :text_end,        is_down)
+                                                         ctx.trigger(:key, :scroll_end,      is_down)
+      when ::SDL2::Key::PAGEDOWN                    then ctx.trigger(:key, :scroll_down,     is_down)
+      when ::SDL2::Key::PAGEUP                      then ctx.trigger(:key, :scroll_up,       is_down)
+      when ::SDL2::Key::Z                           then ctx.trigger(:key, :text_undo,       is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+      when ::SDL2::Key::R                           then ctx.trigger(:key, :text_redo,       is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+      when ::SDL2::Key::C                           then ctx.trigger(:key, :copy,            is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+      when ::SDL2::Key::V                           then ctx.trigger(:key, :paste,           is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+      when ::SDL2::Key::X                           then ctx.trigger(:key, :cut,             is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+      when ::SDL2::Key::B                           then ctx.trigger(:key, :text_line_start, is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+      when ::SDL2::Key::E                           then ctx.trigger(:key, :text_line_end,   is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+      when ::SDL2::Key::UP                          then ctx.trigger(:key, :up,              is_down)
+      when ::SDL2::Key::DOWN                        then ctx.trigger(:key, :down,            is_down)
+      when ::SDL2::Key::LEFT
+        if event.mod & ::SDL2::Key::Mod::CTRL > 0   then ctx.trigger(:key, :text_word_left,  is_down)
+        else ctx.trigger(:key, :left, is_down)
+        end
+      when ::SDL2::Key::RIGHT
+        if event.mod & ::SDL2::Key::Mod::CTRL > 0   then ctx.trigger(:key, :text_word_right, is_down)
+        else ctx.trigger(:key, :right, is_down)
+        end
+      end
+
+    when SDL2::Event::Quit then exit
+    when SDL2::Event::KeyDown
+      case event.sym
+      when SDL2::Key::C
+        if (event.mod & SDL2::Key::Mod::CTRL) > 0
+          exit
+        end
+      end
+    end
+  end
+
+  # Track the number of frames and calculate the amount of time that has
+  # elapsed between the last frame and this one.
+  @frame_count += 1
+  time = Time.now
+  delta ||= begin
+    delta = time - @last_tick_time
+  end
+  @last_tick_time = time
+
+  # Update the frame counter label. The next time Nuklear renders it, the
+  # label will contain the updated text.
+  @frame_num_label.text = @frame_count.to_s
+
+  # Update the Nuklear context. This will generate/update the command buffer
+  # in preparation for rendering, then pass that command buffer to our
+  # renderer.
+  ctx.tick
+
+  # Show the rendered frame.
+  window.gl_swap
+end

data/examples/lib/opengl_font.rb

@@ -0,0 +1,32 @@
+# This class facilitates rendering text with Nuklear and presenting it using
+# OpenGL. It is part of the nuklear-ruby examples.
+module Examples
+  class OpenGLFont
+    attr_reader :path
+
+    def initialize(path, size = 12)
+      @path = path
+      @size = size
+      @texture_id = nil
+      @nuklear_handle = nil
+    end
+
+    def texture_id
+      @texture_id ||= begin
+        tex_names_buf = ' ' * 8
+        glGenTextures(1, tex_names_buf)
+        tex_names_buf.unpack('L1')[0]
+      end
+    end
+
+    def nuklear_handle
+      @nuklear_handle ||= Nuklear::Font.new(path, @size) do |w, h, data|
+        glBindTexture(GL_TEXTURE_2D, texture_id)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        texture_id
+      end
+    end
+  end
+end

data/examples/lib/opengl_init.rb

@@ -0,0 +1,4 @@
+require 'opengl'
+include OpenGL
+OpenGL.load_lib()
+SDL2::GL.set_attribute(SDL2::GL::ACCELERATED_VISUAL, 1)

data/examples/lib/sdl2_init.rb

@@ -0,0 +1,6 @@
+require 'sdl2'
+SDL2.init(SDL2::INIT_EVERYTHING)
+
+module SDL2::Window::Flags
+  ALLOW_HIGHDPI = 0x00002000 unless defined?(SDL2::Window::Flags::ALLOW_HIGHDPI)
+end