mittsu-opengl 0.5.0

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'mittsu', path: '../mittsu'
+
+if /darwin/ === RUBY_PLATFORM
+  gem 'ffi', '~> 1.9', '!= 1.11.1'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2022 Danielle Smith
+
+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,195 @@
+# Mittsu
+
+[![Gem Version](https://badge.fury.io/rb/mittsu-opengl.svg)](https://badge.fury.io/rb/mittsu-opengl)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/XXX/test_coverage)](https://codeclimate.com/github/danini-the-panini/mittsu-opengl/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/XXX/maintainability)](https://codeclimate.com/github/danini-the-panini/mittsu-opengl/maintainability)
+[![Build Status](https://github.com/danini-the-panini/mittsu-opengl/workflows/Build/badge.svg)](https://github.com/danini-the-panini/mittsu-opengl/actions?query=workflow%3A%22Build%22)
+
+OpenGL renderer for Mittsu
+
+OpenGL 3 renderer for Mittsu using GLFW for context creation.
+
+## GIFs!
+
+![Normal-mapped Earth](https://cloud.githubusercontent.com/assets/1171825/18411863/45328540-7781-11e6-986b-6e3f2551c719.gif)
+![Point Light](https://cloud.githubusercontent.com/assets/1171825/18411861/4531bb4c-7781-11e6-92b4-b6ebda60e2c9.gif)
+![Tank Demo](https://cloud.githubusercontent.com/assets/1171825/18411862/4531fe9a-7781-11e6-9665-b172df1a3645.gif)
+
+(You can find the source for the Tank Demo [here](https://github.com/danini-the-panini/mittsu-tank-demo))
+
+## Installation
+
+Install the prerequisites:
+
+Mittsu depends on Ruby 2.6+, OpenGL 3.3+, and GLFW 3.1+
+
+```bash
+# OSX
+$ brew install glfw3
+
+# Ubuntu
+$ sudo apt install libglfw3
+
+# Fedora
+$ sudo dnf install glfw
+```
+
+**NOTE:** On Windows, you will have to manually specify the glfw3.dll path in an environment variable
+(you can download it [here](http://www.glfw.org/download.html))
+```bash
+# ex) set MITTSU_LIBGLFW_PATH=C:\Users\username\lib-mingw-w64
+> set MITTSU_LIBGLFW_PATH=C:\path\to\glfw3.dll
+> ruby your_awesome_mittsu_app.rb
+```
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mittsu-opengl'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mittsu-opengl
+
+## Usage
+
+### tl;dr
+
+Copy-Paste and Run:
+
+```ruby
+require 'mittsu-opengl'
+
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+ASPECT = SCREEN_WIDTH.to_f / SCREEN_HEIGHT.to_f
+
+renderer = Mittsu::OpenGL::Renderer.new width: SCREEN_WIDTH, height: SCREEN_HEIGHT, title: 'Hello, World!'
+
+scene = Mittsu::Scene.new
+
+camera = Mittsu::PerspectiveCamera.new(75.0, ASPECT, 0.1, 1000.0)
+camera.position.z = 5.0
+
+box = Mittsu::Mesh.new(
+  Mittsu::BoxGeometry.new(1.0, 1.0, 1.0),
+  Mittsu::MeshBasicMaterial.new(color: 0x00ff00)
+)
+
+scene.add(box)
+
+renderer.window.run do
+  box.rotation.x += 0.1
+  box.rotation.y += 0.1
+
+  renderer.render(scene, camera)
+end
+```
+
+### Step by Step
+
+First, we need to require the Mittsu OpenGL renderer in order to use it:
+```ruby
+require 'mittsu'
+```
+
+Then, we'll define some constants to help us with setting up our 3D environment:
+```ruby
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+ASPECT = SCREEN_WIDTH.to_f / SCREEN_HEIGHT.to_f
+```
+
+The aspect ratio will be used for setting up the camera later.
+
+Once we have all that we can create the canvas we will use to draw our graphics onto. In Mittsu this is called a renderer. It provides a window and an OpenGL context:
+
+```ruby
+renderer = Mittsu::OpenGL::Renderer.new width: SCREEN_WIDTH, height: SCREEN_HEIGHT, title: 'Hello, World!'
+```
+This will give us an 800x600 window with the title `Hello, World!`.
+
+Now that we have our canvas, let's start setting up the scene we wish to draw onto it:
+
+```ruby
+scene = Mittsu::Scene.new
+```
+
+A scene is like a stage where all our 3D objects live and animate.
+
+We can't draw a 3D scene without knowing where we're looking:
+
+```ruby
+camera = Mittsu::PerspectiveCamera.new(75.0, ASPECT, 0.1, 1000.0)
+```
+
+This camera has a 75° field-of-view (FOV), the aspect ratio of the window (which we defined earlier), and shows everything between a distance of 0.1 to 1000.0 away from the camera.
+
+The camera starts off at the origin `[0,0,0]` and faces the negative Z-axis. We'll position it somewhere along the positive Z-axis so that it is looking at the center of the scene from a short distance:
+
+```ruby
+camera.position.z = 5.0
+```
+
+Our scene isn't going to be very exciting if there is nothing in it, so we'll create a box:
+
+```ruby
+box = Mittsu::Mesh.new(
+  Mittsu::BoxGeometry.new(1.0, 1.0, 1.0),
+  Mittsu::MeshBasicMaterial.new(color: 0x00ff00)
+)
+```
+
+A `Mesh` in Mittsu is the combination of a `Geometry` (the shape of the object) and a `Material` (the "look" of the object). Here we've created a 1x1x1 box that is colored green.
+
+Box in hand, we make it part of our scene:
+
+```ruby
+scene.add(box)
+```
+
+Here comes the fun part... the render loop!
+
+```ruby
+renderer.window.run do
+```
+
+The given block is called every frame. This is where you can tell the renderer what scene to draw, and do any updates to the objects in your scene.
+
+Just to make things a bit more interesting, we'll make the box rotate around its X and Y axes, so that it spins like crazy.
+
+```ruby
+box.rotation.x += 0.1
+box.rotation.y += 0.1
+```
+
+Last but not least, we tell the renderer to draw our scene this frame, which will tell the graphics processor to draw our green box with its updated rotation.
+
+```ruby
+renderer.render(scene, camera)
+```
+
+Easy peasy! :)
+
+```ruby
+end
+```
+
+### More Resources
+
+If you just want to see what Mittsu can do and how to do it, take a peek inside the `examples` folder.
+
+## Contributing
+
+1. Fork it ( https://github.com/danini-the-panini/mittsu-opengl/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+Thank you for helping me help you help us all. ;)

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/**/test_*.rb"
+  t.warning = false
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mittsu"
+
+# 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

data/bin/setup

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

data/install-glfw.ps1

@@ -0,0 +1,13 @@
+$glfwversion="3.3.1"
+
+Invoke-WebRequest "https://github.com/glfw/glfw/releases/download/$glfwversion/glfw-$glfwversion.bin.WIN32.zip" -OutFile "$pwd\glfw-$glfwversion.bin.WIN32.zip"
+
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+function Unzip
+{
+    param([string]$zipfile, [string]$outpath)
+
+    [System.IO.Compression.ZipFile]::ExtractToDirectory($zipfile, $outpath)
+}
+
+Unzip "$pwd\glfw-$glfwversion.bin.WIN32.zip" "$pwd"

data/lib/mittsu/generic_lib.rb

@@ -0,0 +1,116 @@
+require 'opengl'
+require 'open3'
+
+module Mittsu
+  module GenericLib
+    def discover
+      case GL.get_platform
+      when :OPENGL_PLATFORM_WINDOWS
+        self::Windows.new
+      when :OPENGL_PLATFORM_MACOSX
+        self::MacOS.new
+      when :OPENGL_PLATFORM_LINUX
+        self::Linux.new
+      else
+        warn "WARNING: Unsupported platform: #{GL.get_platform}"
+        Base.new
+      end
+    end
+
+    class Base
+      def path; nil; end
+    end
+
+    class Linux < Base
+      def path
+        @_path ||= begin
+          ldconfig_lib || driver_specific_lib || sixtyfour_bit_lib || fallback_lib || give_up
+        end.tap do |result|
+          print_debug_info(result) if DEBUG
+        end
+      end
+
+      class << self
+        def kernel_module_in_use
+          lspci_line, stderr, _status = Open3.capture3("lspci -nnk | grep -i vga -A3 | grep 'in use'")
+          puts stderr if DEBUG
+          /in use:\s*(\S+)/ =~ lspci_line && $1
+        rescue
+          ''
+        end
+
+        def lib_paths
+          Dir.glob('/usr/lib*/**/libGL.so*')
+        rescue
+          []
+        end
+
+        def sixtyfour_bits?
+          1.size == 8
+        end
+
+        def ldconfig
+          `ldconfig -p | grep 'libGL\\.so'`.lines
+        rescue
+          []
+        end
+      end
+
+      private
+
+        def ldconfig_lib
+          return nil if ldconfig.empty?
+          @_debug = { source: 'ldconfig', info: ldconfig.inspect } if DEBUG
+          ldconfig_for_arch = ldconfig.reject { |lib| @loader.sixtyfour_bits? ^ ldconfig_64?(lib) }
+          ldconfig_for_arch.first.match(/=> (\/.*)$/)[1]
+        end
+
+        def ldconfig_64?(lib)
+          lib =~ /\([^\)]*64[^\)]*\) =>/
+        end
+
+        def driver_specific_lib
+          return nil if libs.empty?
+          @_debug = { source: 'driver', info: kernel_module } if DEBUG
+          libs.select { |lib| lib =~ /nvidia/ }.first if kernel_module =~ /nvidia/
+        end
+
+        def sixtyfour_bit_lib
+          return nil if libs.empty?
+          sixtyfour_bit_libs = libs.select { |lib| lib =~ /64/ }
+          @_debug = { source: '64', info: sixtyfour_bit_libs.inspect } if DEBUG
+          sixtyfour_bit_libs.first if @loader.sixtyfour_bits?
+        end
+
+        def fallback_lib
+          return nil if libs.empty?
+          @_debug = { source: 'fallback', info: libs.inspect } if DEBUG
+          libs.first
+        end
+
+        def give_up
+          @_debug = { source: 'none', info: nil } if DEBUG
+          nil
+        end
+
+        def kernel_module
+          @_kernel_module ||= @loader.kernel_module_in_use
+        end
+
+        def libs
+          @_libs ||= @loader.lib_paths.sort_by(&:length)
+        end
+
+        def ldconfig
+          @_ldconfig ||= @loader.ldconfig
+        end
+
+        def print_debug_info(result)
+          puts "Loading lib path: #{result.inspect}"
+          puts "Source: #{@_debug[:source]}"
+          puts "Info: #{@_debug[:info]}"
+          puts "64-bit? #{@loader.sixtyfour_bits?}"
+        end
+    end
+  end
+end

data/lib/mittsu/glfw/lib.rb

@@ -0,0 +1,58 @@
+require 'mittsu/generic_lib'
+
+module Mittsu
+  module GLFW
+    module Lib
+      extend GenericLib
+  
+      class Linux < GenericLib::Linux
+        def initialize(loader = Linux)
+          @loader = loader
+        end
+  
+        class << self
+          def lib_paths
+            Dir.glob('/usr/lib*/**/libglfw*.so*')
+          rescue
+            []
+          end
+  
+          def ldconfig
+            out, stderr, _status = Open3.capture3("ldconfig -p | grep 'libglfw3\\?\\.so'")
+            puts stderr if DEBUG
+            out.lines
+          rescue
+            []
+          end
+        end
+      end
+  
+      class Windows < GenericLib::Base
+        def path
+          'glfw3.dll'
+        end
+      end
+  
+      class MacOS < GenericLib::Base
+        SEARCH_GLOBS = ['/usr/local/lib/**',
+                        '/usr/lib/**',
+                        '/opt/homebrew/**']
+  
+        def path
+          @_path ||= find_match&.to_s
+        end
+  
+        private
+  
+          def find_match
+            SEARCH_GLOBS.each do |glob|
+              matches = Dir.glob("#{glob}/libglfw*.dylib")
+              next if matches.empty?
+  
+              return matches.find { |m| m.end_with?('libglfw3.dylib') || m.end_with?('libglfw.3.dylib') } || matches.first
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mittsu/glfw/window.rb

@@ -0,0 +1,231 @@
+require 'opengl'
+require 'glfw'
+
+require 'mittsu/utils'
+require 'mittsu/glfw/lib'
+glfw_lib = Mittsu::GLFW::Lib.discover
+::GLFW.load_lib(ENV["MITTSU_LIBGLFW_PATH"] || glfw_lib.path, Mittsu.debug?) unless Mittsu.test?
+
+module Mittsu
+  module GLFW
+    class Window
+      attr_accessor :key_press_handler, :key_release_handler, :key_repeat_handler, :char_input_handler, :cursor_pos_handler, :mouse_button_press_handler, :mouse_button_release_handler, :scroll_handler, :framebuffer_size_handler
+
+      def initialize(width, height, title, antialias: 0)
+        ::GLFW.Init
+
+        ::GLFW.WindowHint ::GLFW::OPENGL_PROFILE, ::GLFW::OPENGL_CORE_PROFILE
+        ::GLFW.WindowHint ::GLFW::OPENGL_FORWARD_COMPAT, GL::TRUE
+        ::GLFW.WindowHint ::GLFW::CONTEXT_VERSION_MAJOR, 3
+        ::GLFW.WindowHint ::GLFW::CONTEXT_VERSION_MINOR, 3
+        ::GLFW.WindowHint ::GLFW::CONTEXT_REVISION, 0
+
+        if antialias > 0
+          ::GLFW.WindowHint ::GLFW::SAMPLES, antialias
+        end
+
+        @width, @height, @title = width, height, title
+        @handle = ::GLFW.CreateWindow(@width, @height, @title, nil, nil)
+        if @handle.null?
+          raise "Unable to create window."
+        end
+        ::GLFW.MakeContextCurrent @handle
+        ::GLFW.SwapInterval 1
+
+        this = self
+        @key_callback = ::GLFW::create_callback(:GLFWkeyfun) do |window_handle, key, scancode, action, mods|
+          if action == ::GLFW::PRESS
+            this.key_press_handler.call(key) unless this.key_press_handler.nil?
+            this.key_repeat_handler.call(key) unless this.key_repeat_handler.nil?
+          elsif action == ::GLFW::RELEASE
+            this.key_release_handler.call(key) unless this.key_release_handler.nil?
+          elsif action == ::GLFW::REPEAT
+            this.key_repeat_handler.call(key) unless this.key_repeat_handler.nil?
+          end
+        end
+        ::GLFW.SetKeyCallback(@handle, @key_callback)
+
+        @char_callback = ::GLFW::create_callback(:GLFWcharfun) do |window_handle, codepoint|
+          char = [codepoint].pack('U')
+          this.char_input_handler.call(char) unless this.char_input_handler.nil?
+        end
+        ::GLFW.SetCharCallback(@handle, @char_callback)
+
+        @cursor_pos_callback = ::GLFW::create_callback(:GLFWcursorposfun) do |window_handle, xpos, ypos|
+          this.cursor_pos_handler.call(Vector2.new(xpos, ypos)) unless this.cursor_pos_handler.nil?
+        end
+        ::GLFW.SetCursorPosCallback(@handle, @cursor_pos_callback)
+
+        @mouse_button_callback = ::GLFW::create_callback(:GLFWmousebuttonfun) do |window_handle, button, action, mods|
+          mpos = this.mouse_position
+          if action == ::GLFW::PRESS
+            this.mouse_button_press_handler.call(button, mpos) unless this.mouse_button_press_handler.nil?
+          elsif action == ::GLFW::RELEASE
+            this.mouse_button_release_handler.call(button, mpos) unless this.mouse_button_release_handler.nil?
+          end
+        end
+        ::GLFW.SetMouseButtonCallback(@handle, @mouse_button_callback)
+
+        @scroll_callback = ::GLFW::create_callback(:GLFWscrollfun) do |window_handle, xoffset, yoffset|
+          this.scroll_handler.call(Vector2.new(xoffset, yoffset)) unless this.scroll_handler.nil?
+        end
+        ::GLFW.SetScrollCallback(@handle, @scroll_callback)
+
+        @frabuffer_size_callback = ::GLFW::create_callback(:GLFWframebuffersizefun) do |window_handle, new_width, new_height|
+          this.framebuffer_size_handler.call(new_width, new_height) unless this.framebuffer_size_handler.nil?
+        end
+        ::GLFW.SetFramebufferSizeCallback(@handle, @frabuffer_size_callback)
+
+        @joystick_buttons = poll_all_joysticks_buttons
+      end
+
+      def run
+        while ::GLFW.WindowShouldClose(@handle) == 0
+          yield
+
+          ::GLFW.SwapBuffers @handle
+          ::GLFW.PollEvents
+          poll_joystick_events
+        end
+        ::GLFW.DestroyWindow @handle
+        ::GLFW.Terminate
+      end
+
+      def framebuffer_size
+        width, height = ' '*8, ' '*8
+        ::GLFW.GetFramebufferSize(@handle, width, height)
+        [width.unpack('L')[0], height.unpack('L')[0]]
+      end
+
+      def on_key_pressed &block
+        @key_press_handler = block
+      end
+
+      def on_key_released &block
+        @key_release_handler = block
+      end
+
+      def on_key_typed &block
+        @key_repeat_handler = block
+      end
+
+      def key_down?(key)
+        ::GLFW.GetKey(@handle, key) == ::GLFW::PRESS
+      end
+
+      def on_character_input &block
+        @char_input_handler = block
+      end
+
+      def on_mouse_move &block
+        @cursor_pos_handler = block
+      end
+
+      def on_mouse_button_pressed &block
+        @mouse_button_press_handler = block
+      end
+
+      def on_mouse_button_released &block
+        @mouse_button_release_handler = block
+      end
+
+      def mouse_position
+        xpos, ypos = ' '*8, ' '*8
+        ::GLFW.GetCursorPos(@handle, xpos, ypos);
+        Vector2.new(xpos.unpack('D')[0], ypos.unpack('D')[0])
+      end
+
+      def mouse_button_down?(button)
+        ::GLFW.GetMouseButton(@handle, button) == ::GLFW::PRESS
+      end
+
+      def on_scroll &block
+        @scroll_handler = block
+      end
+
+      def on_resize &block
+        @framebuffer_size_handler = block
+      end
+
+      def joystick_buttons(joystick = ::GLFW::JOYSTICK_1)
+        @joystick_buttons = poll_all_joysticks_buttons
+        @joystick_buttons[joystick]
+      end
+
+      def joystick_axes(joystick = ::GLFW::JOYSTICK_1)
+        return [] unless joystick_present?(joystick)
+        count = ' ' * 4
+        array = ::GLFW.GetJoystickAxes(joystick, count)
+        count = count.unpack('l')[0]
+        array[0, count * 4].unpack('f' * count)
+      end
+
+      def on_joystick_button_pressed &block
+        @joystick_button_press_handler = block
+      end
+
+      def on_joystick_button_released &block
+        @joystick_button_release_handler = block
+      end
+
+      def joystick_present?(joystick = ::GLFW::JOYSTICK_1)
+        ::GLFW.JoystickPresent(joystick).nonzero?
+      end
+
+      def joystick_button_down?(button, joystick = ::GLFW::JOYSTICK_1)
+        @joystick_buttons[joystick][button]
+      end
+
+      def joystick_name(joystick = ::GLFW::JOYSTICK_1)
+        ::GLFW.GetJoystickName(joystick)
+      end
+
+      def set_mouselock(value)
+        if value
+          ::GLFW.SetInputMode(@handle, ::GLFW::CURSOR, ::GLFW::CURSOR_DISABLED)
+        else
+          ::GLFW.SetInputMode(@handle, ::GLFW::CURSOR, ::GLFW::CURSOR_NORMAL)
+        end
+      end
+
+      private
+
+      def poll_all_joysticks_buttons
+        (::GLFW::JOYSTICK_1..::GLFW::JOYSTICK_LAST).map do |joystick|
+          poll_joystick_buttons(joystick)
+        end
+      end
+
+      def poll_joystick_buttons(joystick)
+        return nil unless joystick_present?(joystick)
+        count = ' ' * 4
+        array = ::GLFW.GetJoystickButtons(joystick, count)
+        count = count.unpack('l')[0]
+        array[0, count].unpack('c' * count).map(&:nonzero?)
+      end
+
+      def poll_joystick_events
+        new_joystick_buttons = poll_all_joysticks_buttons
+        new_joystick_buttons.each_with_index do |buttons, joystick|
+          poll_single_joystick_events(joystick, buttons)
+        end
+        @joystick_buttons = new_joystick_buttons
+      end
+
+      def poll_single_joystick_events(joystick, buttons)
+        return if buttons.nil?
+        buttons.each_with_index do |pressed, button|
+          fire_joystick_button_event(joystick, button, pressed)
+        end
+      end
+
+      def fire_joystick_button_event(joystick, button, pressed)
+        if !@joystick_buttons[joystick][button] && pressed
+          @joystick_button_press_handler.call(joystick, button) unless @joystick_button_press_handler.nil?
+        elsif @joystick_buttons[joystick][button] && !pressed
+          @joystick_button_release_handler.call(joystick, button) unless @joystick_button_release_handler.nil?
+        end
+      end
+    end
+  end
+end