glfw 1.0.3 → 3.3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e69775e67613e755b555ebbb6522a3b3f7391a2c6c00d36a57a50b487badcfd3
-  data.tar.gz: c6058d2aa0a4e4522a474e65ba8dd88fe48b56328afa00d2c73d8c7235aaf78b
+  metadata.gz: 16c2c389d080bc44625d725196247b84be720a1bb2e39ddfc6b23a1b6d34342b
+  data.tar.gz: ac83f1b8c3cfbdb85160e3f42bc537c245e3125180e489ca6871d532c47f2f27
 SHA512:
-  metadata.gz: 6b7d8b904daf15a09148b750c9dde8993aeaf79f57a1a464bed501276a1f7730913ab97c8a2498fbad835939d396842b56fd4923a93a2c6a246f5f0c3b96e7c1
-  data.tar.gz: 54df070661af858ee7c13e5a1ae41e9b58bc6119424df1118b7fa706d2285592a7af6d8a54eeda0de8b8124908d5f8c48401ac11d9503b09232ca56bb589c89b
+  metadata.gz: cbf849bf4928972a9bc4170ba1938755582b5812f99f32933b61230ebf2b78580f67634ce20f3e622ede0340075286bc9d0509a39b1d41508f5e554c988af1ca
+  data.tar.gz: 45475496435905e7b7c63e56de45cd0e4b8bc5439bc2d5645dd0210a28c86ccb8e1800ec35cf60f78288c3d65b1c3b6149e0b8ff3568d237adeda546c40ea38a

data/.gitignore

@@ -15,3 +15,164 @@ MakeFile
 mkmf.log
 /.idea/
 /.vscode/
+
+
+# Created by https://www.gitignore.io/api/ruby,rubymine+all,visualstudiocode
+# Edit at https://www.gitignore.io/?templates=ruby,rubymine+all,visualstudiocode
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+### Ruby Patch ###
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*
+
+### RubyMine+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### RubyMine+all Patch ###
+# Ignores the whole .idea folder and all .iml files
+# See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
+
+.idea/
+
+# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
+
+*.iml
+modules.xml
+.idea/misc.xml
+*.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+
+# End of https://www.gitignore.io/api/ruby,rubymine+all,visualstudiocode

data/.yardopts

@@ -0,0 +1,6 @@
+--readme README.md
+--title 'GLFW'
+--charset utf-8
+--markup markdown
+--protected
+lib/**/*.rb

data/Gemfile

@@ -1,6 +1,4 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
-# Specify your gem's dependencies in glfw.gemspec
-gemspec
+# Dependencies specified glfw.gemspec
+gemspec

data/README.md

@@ -1,12 +1,12 @@
 # ![icon](./glfw-icon.png) GLFW
 
-This is a Ruby C-extension that for the excellent [GLFW](https://github.com/glfw/glfw) library. Unlike other bindings, this gem goes beyond just providing a 1:1 wrapper of the functions, and has been organized to be used in a more object-oriented, Ruby way.
+This is a Ruby C-extension for the excellent [GLFW](https://github.com/glfw/glfw) library. Unlike other bindings, this gem goes beyond just providing a 1:1 wrapper of the functions, and has been organized to be used in a more object-oriented, Ruby way.
 
 ## Installation
 
-For Windows user, you can download the pre-built binaries at [here](https://www.glfw.org/download.html) for your target architecture, or both. Place these within the their respective folders withing the `ext/glfw/` directory.
+For Windows users, the dependencies will automatically be fetched and installed into Ruby's environment using the built-in functionality of MSYS2. 
 
-For Unix users, simply have GLFW installed globally, and it will be found and linked against during the build process.
+For Unix-like systems, simply have GLFW installed globally, and it will be found and linked against during the build process.
 
 
 ### From [RubyGems.org](https://rubygems.org/gems/glfw)
@@ -24,14 +24,14 @@ Open a terminal/command prompt in the base directory:
 
 ### Window Creation
 
-At is simplest, to create a platform-specific window with an OpenGL context requires very little code.
+At its simplest, to create a platform-specific window with an OpenGL context requires very little code.
 
 ```ruby
 GLFW::Window.new(800, 600, "Hello, World!") do |window|
 
   until window.closing?
     GLFW.poll_events
-    GLFW.swap_buffers
+    window.swap_buffers
     # Your rendering code goes here
   end
 end
@@ -44,53 +44,49 @@ You will likely want to fine-tune the created context to what your application r
 GLFW.init
 
 # Load default window hints. This will reset any previous hints given
-GLFW.default_hints
+GLFW::Window.default_hints
 
 # Window will be NOT be decorated (title, border, close widget, etc)
-GLFW.hint(GLFW::HINT_DECORATED, false)
+GLFW::Window.hint(GLFW::HINT_DECORATED, false)
 
-# Specifiy MINIMUM required OpenGL version
-GLFW.hint(GLFW::HINT_CONTEXT_VERSION_MAJOR, 3)
-GLFW.hint(GLFW::HINT_CONTEXT_VERSION_MAJOR, 0)
+# Specify MINIMUM required OpenGL version
+GLFW::Window.hint(GLFW::HINT_CONTEXT_VERSION_MAJOR, 3)
+GLFW::Window.hint(GLFW::HINT_CONTEXT_VERSION_MAJOR, 3)
 ```
 
 All constants for creation hints are prefixed with `HINT`.
 
 ### Callbacks
 
-GLFW offers a high-level of control of the application window, including callbacks for nearly every relevant system event that effects the window (see documentation for what all callbacks are available). By default, most of these callbacks are disabled, and need enabled with a method call to have them fired. This for performance reasons, as it is inefficient to have them all being invoked if they are not going to be used.
+GLFW offers a high-level of control of the application window, including callbacks for nearly every relevant system event that effects the window (see documentation for what all callbacks are available). Callbacks are implemented by using Ruby blocks to create a closure that will be invoked the callback fires. 
 
-To enable a callback:
+All callbacks in the libaray follow the same idioms:
 
 ```ruby
-window.enable_callback(GLFW::CB_RESIZED, true)
-```
-
-You then have two options; to either alias the `GLFW::Window` class for the relevant callback, or more commonly is to create your own class the inherits from `GLFW::Window`.
-
-```ruby
-class MyGame < GLFW::Window
-
-  def initialize
-    super(800, 600, "My Awesome Game Title", fullscreen: true)
-    enable_callback(GLFW::CB_RESIZED, true)
-  end
+window.on_framebuffer_resize do |width, height|
+  # Block will be called when framebuffer size changes (change projection matrix, viewport, etc.)
+end
 
-  # This method will be invoked when the window is resized.
-  def resized(width, hight)
-    # Your code goes here. 
-    # The "width/height" arguments passed are the new size
-  end
+window.on_key do |key, scancode, action, mods|
+  # Block called when keyboard input changes (process keystroke)
 end
+
+# Use method without block to unsubscribe from callback
+window.on_key
 ```
 
-All constants for callbacks are prefixed with `CB`.
+#### Breaking Changes
+
+Prior versions of the gem used a method of enabling all callbacks via a single method, which would then invoke a
+pre-defined method that had to be overridden/aliased. Starting with version 3.3.2, this functiionality has been
+removed in favor of using Ruby blocks, which is more familiar and Ruby-like, as well as being more flexible.
 
 ## Documentation
 
-The documentation is a work-in-progress.
+The gem documention can be found [here](), it covers at least minimal coverage of the entire API surface.
 
-The GLFW API offers a very in-depth and detailed [documentation](http://www.glfw.org/docs/latest/intro_guide.html) that may be used as a subsitute until complete, and as a fantastic stand-alone source of information to understanding the linrary.
+For more in depth explanation of some features, the native GLFW library offers a very in-depth and detailed [documentation](http://www.glfw.org/docs/latest/intro_guide.html) that may be used as to augment it, or even as a stand-alone source of information to understanding the library. While not all features will match up
+with a 1:1 ratio, the naming conventions and idioms are the same and self-explanatory to use the C documentation for the Ruby gem.
 
 ## Contributing
 
@@ -100,7 +96,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/Foreve
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-The [GLFW API](http://www.glfw.org) is is licensed under the [zlib/libpng](http://www.glfw.org/license.html) license.
+[GLFW](http://www.glfw.org) is is licensed under the [zlib/libpng](http://www.glfw.org/license.html) license.
 
 ## Code of Conduct
 

data/Rakefile

@@ -1,9 +1,11 @@
-require "rake/extensiontask"
+# frozen_string_literal: true
+
+require 'rake/extensiontask'
 
 task :build => :compile
 
-Rake::ExtensionTask.new("glfw") do |ext|
-  ext.lib_dir = "lib/glfw"
+Rake::ExtensionTask.new('glfw') do |ext|
+  ext.lib_dir = 'lib/glfw'
 end
 
-task :default => [:clobber, :compile, :test]
+task :default => [:clobber, :compile]

data/ext/glfw/common.c

@@ -0,0 +1,159 @@
+#include "glfw.h"
+
+VALUE cPoint;
+VALUE cSize;
+VALUE cVec2;
+
+static VALUE rb_glfw_ivec_alloc(VALUE klass)
+{
+    RBivec2 *ivec = ALLOC(RBivec2);
+    memset(ivec, 0, sizeof(RBivec2));
+    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, ivec);
+}
+
+static VALUE rb_glfw_vec_alloc(VALUE klass)
+{
+    RBvec2 *vec = ALLOC(RBvec2);
+    memset(vec, 0, sizeof(RBvec2));
+    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, vec);
+}
+
+static VALUE rb_glfw_ivec_get_x(VALUE self)
+{
+    return INT2NUM(((RBivec2*) DATA_PTR(self))->x);
+}
+
+static VALUE rb_glfw_ivec_get_y(VALUE self)
+{
+    return INT2NUM(((RBivec2*) DATA_PTR(self))->y);
+}
+
+static VALUE rb_glfw_ivec_set_x(VALUE self, VALUE value)
+{
+    RBivec2 *ivec = DATA_PTR(self);
+    ivec->x = NUM2INT(value);
+    return value;
+}
+
+static VALUE rb_glfw_ivec_set_y(VALUE self, VALUE value)
+{
+    RBivec2 *ivec = DATA_PTR(self);
+    ivec->y = NUM2INT(value);
+    return value;
+}
+
+
+static VALUE rb_glfw_vec_get_x(VALUE self)
+{
+    return DBL2NUM(((RBvec2*) DATA_PTR(self))->x);
+}
+
+static VALUE rb_glfw_vec_get_y(VALUE self)
+{
+    return DBL2NUM(((RBvec2*) DATA_PTR(self))->y);
+}
+
+static VALUE rb_glfw_vec_set_x(VALUE self, VALUE value)
+{
+    RBvec2 *vec = DATA_PTR(self);
+    vec->x = NUM2DBL(value);
+    return value;
+}
+
+static VALUE rb_glfw_vec_set_y(VALUE self, VALUE value)
+{
+    RBvec2 *vec = DATA_PTR(self);
+    vec->y = NUM2DBL(value);
+    return value;
+}
+
+static VALUE rb_glfw_vec_initialize(VALUE self, VALUE x, VALUE y)
+{
+    RBvec2 *vec = DATA_PTR(self);
+    vec->x = NUM2DBL(x);
+    vec->y = NUM2DBL(y);
+    return Qnil;
+}
+
+static VALUE rb_glfw_ivec_initialize(VALUE self, VALUE x, VALUE y)
+{
+    RBivec2 *ivec = DATA_PTR(self);
+    ivec->x = NUM2INT(x);
+    ivec->y = NUM2INT(y);
+    return Qnil;
+}
+
+static VALUE rb_glfw_ivec_equal(VALUE self, VALUE other)
+{
+    if (CLASS_OF(self) != CLASS_OF(other))
+        return Qfalse;
+
+    RBivec2 *v1 = DATA_PTR(self), *v2 = DATA_PTR(other);
+    return RB_BOOL(v1->x == v2->x && v1->y == v2->y);
+}
+
+static VALUE rb_glfw_ivec_inspect(VALUE self)
+{   
+    RBivec2 *v = DATA_PTR(self);
+    return rb_sprintf("<%d, %d>", v->x, v->y);
+}
+
+static VALUE rb_glfw_vec_inspect(VALUE self)
+{   
+    RBvec2 *v = DATA_PTR(self);
+    return rb_sprintf("<%f, %f>", v->x, v->y);
+}
+
+VALUE rb_glfw_ivec2_create(VALUE klass, int x, int y)
+{
+    RBivec2 *ivec = ALLOC(RBivec2);
+    ivec->x = x;
+    ivec->y = y;
+    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, ivec);
+}
+
+VALUE rb_glfw_vec2_create(VALUE klass, double x, double y)
+{
+    RBvec2 *vec = ALLOC(RBvec2);
+    vec->x = x;
+    vec->y = y;
+    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, vec);
+}
+
+void rb_glfw_common_init(void)
+{
+    cPoint = rb_define_class_under(mGLFW, "Point", rb_cObject);
+    cSize = rb_define_class_under(mGLFW, "Size", rb_cObject);
+    cVec2 = rb_define_class_under(mGLFW, "Vec2", rb_cObject);
+
+    rb_define_alloc_func(cPoint, rb_glfw_ivec_alloc);
+    rb_define_alloc_func(cSize, rb_glfw_ivec_alloc);
+    rb_define_alloc_func(cSize, rb_glfw_vec_alloc);
+
+    rb_define_method(cPoint, "x", rb_glfw_ivec_get_x, 0);
+    rb_define_method(cPoint, "y", rb_glfw_ivec_get_y, 0);
+    rb_define_method(cPoint, "x=", rb_glfw_ivec_set_x, 1);
+    rb_define_method(cPoint, "y=", rb_glfw_ivec_set_y, 1);
+
+    rb_define_method(cSize, "width", rb_glfw_ivec_get_x, 0);
+    rb_define_method(cSize, "height", rb_glfw_ivec_get_y, 0);
+    rb_define_method(cSize, "width=", rb_glfw_ivec_set_x, 1);
+    rb_define_method(cSize, "height=", rb_glfw_ivec_set_y, 1);
+
+    rb_define_method(cVec2, "x", rb_glfw_vec_get_x, 0);
+    rb_define_method(cVec2, "y", rb_glfw_vec_get_y, 0);
+    rb_define_method(cVec2, "x=", rb_glfw_vec_set_x, 1);
+    rb_define_method(cVec2, "y=", rb_glfw_vec_set_y, 1);
+
+    rb_define_method(cPoint, "==", rb_glfw_ivec_equal, 1);
+    rb_define_method(cPoint, "eql?", rb_glfw_ivec_equal, 1);
+    rb_define_method(cSize, "==", rb_glfw_ivec_equal, 1);
+    rb_define_method(cSize, "eql?", rb_glfw_ivec_equal, 1);
+    rb_define_method(cPoint, "inspect", rb_glfw_ivec_inspect, 0);
+    rb_define_method(cSize, "inspect", rb_glfw_ivec_inspect, 0);
+    rb_define_method(cVec2, "inspect", rb_glfw_vec_inspect, 0);
+
+    rb_define_method(cPoint, "initialize", rb_glfw_ivec_initialize, 2);
+    rb_define_method(cSize, "initialize", rb_glfw_ivec_initialize, 2);
+    rb_define_method(cVec2, "initialize", rb_glfw_vec_initialize, 2);
+}