glfw 1.0.3 → 3.3.2.0

data/ext/glfw/glfw.h

@@ -1,41 +1,46 @@
-#ifndef GLFW_RB_H
-#define GLFW_RB_H 1
-
-#include "common.h"
-#include "window.h"
-#include "monitor.h"
-#include "image.h"
-#include "cursor.h"
-#include "video_mode.h"
-#include "vulkan.h"
-
-void rb_glfw_error_callback(int error, const char *message);
-void rb_glfw_monitor_callback(GLFWmonitor *monitor, int connected);
-void rb_glfw_joystick_callback(int joystick, int connected);
-
-VALUE rb_glfw_init(VALUE klass);
-VALUE rb_glfw_terminate(VALUE klass);
-VALUE rb_glfw_poll_events(VALUE klass);
-VALUE rb_glfw_wait_events(VALUE klass);
-VALUE rb_glfw_get_time(VALUE klass);
-VALUE rb_glfw_set_time(VALUE klass, VALUE t);
-VALUE rb_glfw_swap_interval(VALUE klass, VALUE interval);
-VALUE rb_glfe_event_timeout(VALUE klass, VALUE timeout);
-VALUE rb_glfw_current_context(VALUE klass);
-VALUE rb_glfw_supported_p(VALUE klass, volatile VALUE extension);
-VALUE rb_glfw_monitors(VALUE klass);
-VALUE rb_glfw_load_default_hints(VALUE klass);
-VALUE rb_glfw_window_hint(VALUE klass, VALUE hint, VALUE value);
-VALUE rb_glfw_key_name(VALUE klass, VALUE key, VALUE scancode);
-VALUE rb_glfw_post_empty(VALUE klass);
-VALUE rb_glfw_timer_frequency(VALUE klass);
-VALUE rb_glfw_timer_value(VALUE klass);
-VALUE rb_glfw_joystick_p(VALUE klass, VALUE joystick);
-VALUE rb_glfw_joystick_name(VALUE klass, VALUE joystick);
-VALUE rb_glfw_joystick_axes(VALUE klass, VALUE joystick);
-VALUE rb_glfw_joystick_buttons(VALUE klass, VALUE joystick);
-VALUE rb_glfw_monitor_changed(VALUE klass, VALUE monitor, VALUE connected);
-VALUE rb_glfw_joystick_changed(VALUE klass, VALUE joystick, VALUE connected);
-VALUE rb_glfw_proc_address(VALUE klass, VALUE name);
-
-#endif /* GLFW_RB_H */
+#ifndef RB_GLFW_H
+#define RB_GLFW_H 1
+
+#include "ruby.h"
+#include "GLFW/glfw3.h"
+
+#define GLFW_IMAGE_LOADER 1
+
+extern VALUE mGLFW;
+extern VALUE eGLFWError;
+extern VALUE cWindow;
+extern VALUE cMonitor;
+extern VALUE cImage;
+extern VALUE cCursor;
+extern VALUE cVideoMode;
+extern VALUE mJoystick;
+extern VALUE cGamepadState;
+extern VALUE cPoint;
+extern VALUE cSize;
+extern VALUE cVec2;
+
+#define RB_BOOL(exp) ((exp) ? Qtrue : Qfalse)
+#define NUM2FLT(v) ((float) NUM2DBL(v))
+#define STR2SYM(str) (ID2SYM(rb_intern(str)))
+
+void rb_glfw_window_init(void);
+void rb_glfw_monitor_init(void);
+void rb_glfw_image_init(void);
+void rb_glfw_cursor_init(void);
+void rb_glfw_common_init(void);
+void rb_glfw_joystick_init(void);
+
+typedef struct {
+    int x;
+    int y;
+} RBivec2;
+
+typedef struct {
+    double x;
+    double y;
+} RBvec2;
+
+VALUE rb_glfw_ivec2_create(VALUE klass, int x, int y);
+VALUE rb_glfw_vec2_create(VALUE klass, double x, double y);
+
+#endif /* RB_GLFW_H */

data/ext/glfw/image.c

@@ -1,77 +1,109 @@
 
-#include "image.h"
-
-VALUE rb_cGLFWimage;
-
-void Init_glfw_image(VALUE module) {
-    rb_cGLFWimage = rb_define_class_under(module, "Image", rb_cObject);
-    rb_define_alloc_func(rb_cGLFWimage, rb_glfw_image_alloc);
-    rb_define_method(rb_cGLFWimage, "initialize", rb_glfw_image_initialize, -1);
-    
-    rb_define_method(rb_cGLFWimage, "width", rb_glfw_image_width, 0);
-    rb_define_method(rb_cGLFWimage, "height", rb_glfw_image_height, 0);
-    rb_define_method(rb_cGLFWimage, "pixels", rb_glfw_image_pixels, 0);
-
-    rb_define_alias(rb_cGLFWimage, "columns", "width");
-    rb_define_alias(rb_cGLFWimage, "rows", "height");
-    rb_define_alias(rb_cGLFWimage, "to_blob", "pixels");
+#include "glfw.h"
+
+#ifdef GLFW_IMAGE_LOADER
+#define STBI_MALLOC xmalloc
+#define STBI_REALLOC xrealloc
+#define STBI_FREE xfree
+#define STB_IMAGE_IMPLEMENTATION 1
+#include "stb_image.h"
+#define ARG_PATTERN "12"
+#else
+#define ARG_PATTERN "21"
+#endif
+
+#define BYTES_PER_PIXEL (4)
+
+VALUE cImage;
+
+static void rb_glfw_image_free(void *image)
+{
+    GLFWimage *img = image;
+    if (img->pixels)
+        xfree(img->pixels);
+    xfree(img);
 }
 
-static VALUE rb_glfw_image_alloc(VALUE klass) {
-    GLFWimage *image = ALLOC(GLFWimage);
-    memset(image, 0, sizeof(GLFWimage));
-    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, image);
+static VALUE rb_glfw_image_alloc(VALUE klass)
+{
+    GLFWimage *img = ALLOC(GLFWimage);
+    memset(img, 0, sizeof(GLFWimage));
+    return Data_Wrap_Struct(klass, NULL, rb_glfw_image_free, img);
 }
 
-VALUE rb_glfw_image_initialize(int argc, VALUE *argv, VALUE self) {
-    if (argc == 2 || argc == 3)
-    {
-        GLFWimage *image = ALLOC(GLFWimage);
-        image->width = NUM2INT(argv[0]);
-        image->height = NUM2INT(argv[1]);
-
-        if (argc == 3)
-        {
-            if (RB_TYPE_P(argv[2], T_STRING))
-            {
-                image->pixels = StringValuePtr(argv[2]);
-            }
-            else 
-            {
-                uint32_t packed = NUM2UINT(argv[2]);
-                int size = sizeof(uint32_t) * image->width * image->height;
-                image->pixels = malloc(size);
-                memset(image->pixels, packed, size);
-            }
-        }
-        else
-        {
-            int size = 4 * image->width * image->height;
-            image->pixels = malloc(size);
-            memset(image->pixels, 0, size);
-        }
-        RDATA(self)->data = image;
-        return Qnil;
-    }
+static VALUE rb_glfw_image_width(VALUE self)
+{
+    return INT2NUM(((GLFWimage *)DATA_PTR(self))->width);
+}
 
-    rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 2, 3)", argc);
+static VALUE rb_glfw_image_height(VALUE self)
+{
+    return INT2NUM(((GLFWimage *)DATA_PTR(self))->height);
 }
 
-VALUE rb_glfw_image_width(VALUE self) {
-    GLFWimage *image;
-    Data_Get_Struct(self, GLFWimage, image);
-    return INT2NUM(image->width);
+static VALUE rb_glfw_image_pixels(VALUE self)
+{
+    GLFWimage *img = DATA_PTR(self);
+    long len = img->width * img->height * BYTES_PER_PIXEL;
+    return rb_str_new(img->pixels, len);
 }
 
-VALUE rb_glfw_image_height(VALUE self) {
-    GLFWimage *image;
-    Data_Get_Struct(self, GLFWimage, image);
-    return INT2NUM(image->height);
+static VALUE rb_glfw_image_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE w, h, blob;
+    rb_scan_args(argc, argv, ARG_PATTERN, &w, &h, &blob);
+    GLFWimage *image = DATA_PTR(self);
+
+    switch (argc)
+    {
+#ifdef GLFW_IMAGE_LOADER
+    case 1:
+    {
+        const char *filename = StringValueCStr(w);
+        image->pixels = stbi_load(filename, &image->width, &image->height, NULL, 4);
+        break;
+    }
+#endif
+    case 2:
+    {
+        image->width = NUM2INT(w);
+        image->height = NUM2INT(h);
+        size_t size = image->width * image->height * BYTES_PER_PIXEL;
+        if (size <= 0)
+            rb_raise(rb_eArgError, "invalid image size specified");
+
+        image->pixels = xcalloc(size, 1);
+        break;
+    }
+    case 3:
+    {
+        image->width = NUM2INT(w);
+        image->height = NUM2INT(h);
+        size_t size = image->width * image->height * BYTES_PER_PIXEL;
+
+        if (size <= 0)
+            rb_raise(rb_eArgError, "invalid image size specified");
+
+        image->pixels = xmalloc(size);
+        memcpy(image->pixels, StringValuePtr(blob), size);
+        break;
+    }
+    }
+
+    return Qnil;
 }
 
-VALUE rb_glfw_image_pixels(VALUE self) {
-    GLFWimage *image;
-    Data_Get_Struct(self, GLFWimage, image);
-    int size = image->width * image->height * 4;
-    return rb_str_new(image->pixels, size);
+void rb_glfw_image_init(void)
+{
+    cImage = rb_define_class_under(mGLFW, "Image", rb_cObject);
+    rb_define_alloc_func(cImage, rb_glfw_image_alloc);
+    rb_define_method(cImage, "initialize", rb_glfw_image_initialize, -1);
+
+    rb_define_method(cImage, "width", rb_glfw_image_width, 0);
+    rb_define_method(cImage, "height", rb_glfw_image_height, 0);
+    rb_define_method(cImage, "pixels", rb_glfw_image_pixels, 0);
+
+    rb_define_alias(cImage, "columns", "width");
+    rb_define_alias(cImage, "rows", "height");
+    rb_define_alias(cImage, "to_blob", "pixels");
 }

data/ext/glfw/joystick.c

@@ -0,0 +1,169 @@
+
+#include "glfw.h"
+
+VALUE mJoystick;
+VALUE cGamepadState;
+VALUE cb_joystick;
+
+static VALUE rb_glfw_gamepad_state_alloc(VALUE klass)
+{
+    GLFWgamepadstate *state = ALLOC(GLFWgamepadstate);
+    memset(state, 0, sizeof(GLFWgamepadstate));
+    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, state);
+}
+
+static VALUE rb_glfw_gamepad_axis(VALUE self, VALUE axis)
+{
+    int index = NUM2INT(axis);
+    if (index >= 0 && index <= GLFW_GAMEPAD_AXIS_LAST)
+        return DBL2NUM(((GLFWgamepadstate*) DATA_PTR(self))->axes[index]);
+    return DBL2NUM(0.0);
+}
+
+static VALUE rb_glfw_gamepad_button(VALUE self, VALUE button)
+{
+    int index = NUM2INT(button);
+    if (index >= 0 && index <= GLFW_GAMEPAD_BUTTON_LAST)
+        return RB_BOOL(((GLFWgamepadstate*) DATA_PTR(self))->buttons[index]);
+    return Qfalse;
+}
+
+static VALUE rb_glfw_joystick_is_present(VALUE module, VALUE jid)
+{
+    return RB_BOOL(glfwJoystickPresent(NUM2INT(jid)));
+}
+
+static VALUE rb_glfw_joystick_is_gamepad(VALUE module, VALUE jid)
+{
+    return RB_BOOL(glfwJoystickIsGamepad(NUM2INT(jid)));
+}
+
+static VALUE rb_glfw_joystick_name(VALUE module, VALUE jid)
+{
+    const char *name = glfwGetJoystickName(NUM2INT(jid));
+    return name ? rb_str_new_cstr(name) : Qnil;
+}
+
+static VALUE rb_glfw_joystick_gamepad_name(VALUE module, VALUE jid)
+{
+    const char *name = glfwGetGamepadName(NUM2INT(jid));
+    return name ? rb_str_new_cstr(name) : Qnil;
+}
+
+static VALUE rb_glfw_joystick_guid(VALUE module, VALUE jid)
+{
+    const char *guid = glfwGetJoystickGUID(NUM2INT(jid));
+    return guid ? rb_str_new_cstr(guid) : Qnil;
+}
+
+static void rb_glfw_joystick_cb_connection(int jid, int event)
+{
+    if (RTEST(cb_joystick))
+    {
+        VALUE args = rb_ary_new_from_args(2, INT2NUM(jid), RB_BOOL(event == GLFW_CONNECTED));
+        rb_proc_call(cb_joystick, args);
+    }
+}
+
+static VALUE rb_glfw_joystick_on_connection(VALUE module)
+{
+    VALUE current = cb_joystick;
+    if (rb_block_given_p())
+    {
+        cb_joystick = rb_block_proc();
+        rb_iv_set(mJoystick, "@connection_proc", cb_joystick);
+        glfwSetJoystickCallback(rb_glfw_joystick_cb_connection);
+    }
+    else
+    {
+        cb_joystick = Qnil;
+        rb_iv_set(mJoystick, "@connection_proc", Qnil);
+        glfwSetJoystickCallback(NULL);
+    }
+    return current;
+}
+
+static VALUE rb_glfw_joystick_update_mappings(int argc, VALUE *argv, VALUE module)
+{
+    int count = 0;
+    for (int i = 0; i < argc; i++)
+    {
+        const char *str = StringValueCStr(argv[i]);
+        count += glfwUpdateGamepadMappings(str);
+    }
+    return INT2NUM(count);
+}
+
+static VALUE rb_glfw_joystick_gamepad_state(VALUE module, VALUE jid)
+{
+    GLFWgamepadstate *state = ALLOC(GLFWgamepadstate);
+    if (glfwGetGamepadState(NUM2INT(jid), state))
+        return Data_Wrap_Struct(cGamepadState, NULL, RUBY_DEFAULT_FREE, state);
+    xfree(state);
+    return Qnil;
+}
+
+static VALUE rb_glfw_joystick_buttons(VALUE module, VALUE jid)
+{
+    int count;
+    const unsigned char* buttons = glfwGetJoystickButtons(NUM2INT(jid), &count);
+    if (count > 0)
+    {
+        VALUE ary = rb_ary_new_capa(count);
+        for (int i = 0; i < count; i++)
+            rb_ary_store(ary, i, RB_BOOL(buttons[i]));
+        return ary;
+    }
+    return Qnil;
+}
+
+static VALUE rb_glfw_joystick_axes(VALUE module, VALUE jid)
+{
+    int count;
+    const float* axes = glfwGetJoystickAxes(NUM2INT(jid), &count);
+    if (count > 0)
+    {
+        VALUE ary = rb_ary_new_capa(count);
+        for (int i = 0; i < count; i++)
+            rb_ary_store(ary, i, DBL2NUM(axes[i]));
+        return ary;
+    }
+    return Qnil;
+}
+
+static VALUE rb_glfw_joystick_hats(VALUE module, VALUE jid)
+{
+    int count;
+    const unsigned char* hats = glfwGetJoystickHats(NUM2INT(jid), &count);
+    if (count > 0)
+    {
+        VALUE ary = rb_ary_new_capa(count);
+        for (int i = 0; i < count; i++)
+            rb_ary_store(ary, i, RB_BOOL(hats[i]));
+        return ary;
+    }
+    return Qnil;
+}
+
+void rb_glfw_joystick_init(void)
+{
+    cGamepadState = rb_define_class_under(mGLFW, "GamepadState", rb_cObject);
+    rb_define_alloc_func(cGamepadState, rb_glfw_gamepad_state_alloc);
+    rb_define_method(cGamepadState, "axis", rb_glfw_gamepad_axis, 1);
+    rb_define_method(cGamepadState, "button", rb_glfw_gamepad_button, 1);
+
+    mJoystick = rb_define_module_under(mGLFW, "Joystick");
+    rb_define_singleton_method(mJoystick, "gamepad_state", rb_glfw_joystick_gamepad_state, 1);
+    rb_define_singleton_method(mJoystick, "name", rb_glfw_joystick_name, 1);
+    rb_define_singleton_method(mJoystick, "gamepad_name", rb_glfw_joystick_gamepad_name, 1);
+    rb_define_singleton_method(mJoystick, "present?", rb_glfw_joystick_is_present, 1);
+    rb_define_singleton_method(mJoystick, "gamepad?", rb_glfw_joystick_is_gamepad, 1);
+    rb_define_singleton_method(mJoystick, "guid", rb_glfw_joystick_guid, 1);
+    rb_define_singleton_method(mJoystick, "buttons", rb_glfw_joystick_buttons, 1);
+    rb_define_singleton_method(mJoystick, "axes", rb_glfw_joystick_axes, 1);
+    rb_define_singleton_method(mJoystick, "hats", rb_glfw_joystick_hats, 1);
+    rb_define_singleton_method(mJoystick, "update_mappings", rb_glfw_joystick_update_mappings, -1);
+    rb_define_singleton_method(mJoystick, "on_connection", rb_glfw_joystick_on_connection, 0);
+
+    cb_joystick = Qnil;
+}

data/ext/glfw/monitor.c

@@ -1,209 +1,285 @@
+#include "glfw.h"
 
-#include "monitor.h"
+VALUE cb_monitor;
+VALUE cMonitor;
+VALUE cVideoMode;
 
-VALUE rb_cGLFWmonitor;
-
-void Init_glfw_monitor(VALUE module) {
-    rb_cGLFWmonitor = rb_define_class_under(module, "Monitor", rb_cObject);
-
-    rb_define_method(rb_cGLFWmonitor, "name", rb_glfw_monitor_name, 0);
-    rb_define_method(rb_cGLFWmonitor, "position", rb_glfw_monitor_pos, 0);
-    rb_define_method(rb_cGLFWmonitor, "size", rb_glfw_monitor_size, 0);
-    rb_define_method(rb_cGLFWmonitor, "x", rb_glfw_monitor_x, 0);
-    rb_define_method(rb_cGLFWmonitor, "y", rb_glfw_monitor_y, 0);
-    rb_define_method(rb_cGLFWmonitor, "width", rb_glfw_monitor_width, 0);
-    rb_define_method(rb_cGLFWmonitor, "height", rb_glfw_monitor_height, 0);
-    rb_define_method(rb_cGLFWmonitor, "dimensions", rb_glfw_monitor_dimensions, 0);
-
-    rb_define_method(rb_cGLFWmonitor, "gamma", rb_glfw_monitor_gamma, 1);
-    rb_define_method(rb_cGLFWmonitor, "gamma_ramp", rb_glfw_monitor_get_gamma_ramp, 0);
-    rb_define_method(rb_cGLFWmonitor, "set_gamma_ramp", rb_glfw_monitor_set_gamma_ramp, -1);
-    rb_define_method(rb_cGLFWmonitor, "video_mode", rb_glfw_monitor_video_mode, 0);
-    rb_define_method(rb_cGLFWmonitor, "video_modes", rb_glfw_monitor_video_modes, 0);
-
-    rb_define_singleton_method(rb_cGLFWmonitor, "primary", rb_glfw_monitor_primary, 0);
-    rb_define_const(rb_cGLFWmonitor, "NONE", rb_glfw_monitor_alloc(rb_cGLFWmonitor));
-
-    rb_funcall(rb_cGLFWmonitor, rb_intern("private_class_method"), 1, STR2SYM("new"));
+static inline VALUE rb_glfw_video_create(const GLFWvidmode *value)
+{
+    GLFWvidmode *video = ALLOC(GLFWvidmode);
+    if (value)
+        memcpy(video, value, sizeof(GLFWvidmode));
+    else
+        memset(video, 0, sizeof(GLFWvidmode));
+    return Data_Wrap_Struct(cVideoMode, NULL, RUBY_DEFAULT_FREE, video);
 }
 
-static VALUE rb_glfw_monitor_alloc(VALUE klass) {
-    GLFWmonitor *monitor = ruby_xmalloc(SIZEOF_INTPTR_T);
-    memset(monitor, 0, SIZEOF_INTPTR_T);
-    return Data_Wrap_Struct(rb_cGLFWmonitor, NULL, RUBY_DEFAULT_FREE, monitor);
+static VALUE rb_glfw_video_alloc(VALUE klass)
+{
+    GLFWvidmode *video = ALLOC(GLFWvidmode);
+    memset(video, 0, sizeof(GLFWvidmode));
+    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, video);
 }
 
-VALUE rb_glfw_monitor_name(VALUE self) {
-    MONITOR();
-    const char *name = glfwGetMonitorName(m);
-    return rb_str_new_cstr(name);
+static VALUE rb_glfw_video_width(VALUE self)
+{   
+    return INT2NUM(((GLFWvidmode*) DATA_PTR(self))->width);
 }
 
-VALUE rb_glfw_monitor_pos(VALUE self) {
-    MONITOR();
-    int x, y;
-    glfwGetMonitorPos(m, &x, &y);
-    VALUE ary = rb_ary_new_capa(2);
-    rb_ary_store(ary, 0, INT2NUM(x));
-    rb_ary_store(ary, 1, INT2NUM(y));
-    return ary;
+static VALUE rb_glfw_video_height(VALUE self)
+{   
+    return INT2NUM(((GLFWvidmode*) DATA_PTR(self))->height);
 }
 
-VALUE rb_glfw_monitor_size(VALUE self) {
-    MONITOR();
-    int width, height;
-    glfwGetMonitorPhysicalSize(m, &width, &height);
-    VALUE ary = rb_ary_new_capa(2);
-    rb_ary_store(ary, 0, INT2NUM(width));
-    rb_ary_store(ary, 1, INT2NUM(height));
-    return ary;
+static VALUE rb_glfw_video_r_bits(VALUE self)
+{   
+    return INT2NUM(((GLFWvidmode*) DATA_PTR(self))->redBits);
 }
 
-VALUE rb_glfw_monitor_x(VALUE self) {
-    MONITOR();
-    int x;
-    glfwGetMonitorPos(m, &x, NULL);
-    return INT2NUM(x);
+static VALUE rb_glfw_video_g_bits(VALUE self)
+{   
+    return INT2NUM(((GLFWvidmode*) DATA_PTR(self))->greenBits);
 }
 
-VALUE rb_glfw_monitor_y(VALUE self) {
-    MONITOR();
-    int y;
-    glfwGetMonitorPos(m, NULL, &y);
-    return INT2NUM(y);
+static VALUE rb_glfw_video_b_bits(VALUE self)
+{   
+    return INT2NUM(((GLFWvidmode*) DATA_PTR(self))->blueBits);
 }
 
-VALUE rb_glfw_monitor_width(VALUE self) {
-    MONITOR();
-    int width;
-    glfwGetMonitorPhysicalSize(m, &width, NULL);
-    return INT2NUM(width);
+static VALUE rb_glfw_video_refresh_rate(VALUE self)
+{   
+    return INT2NUM(((GLFWvidmode*) DATA_PTR(self))->refreshRate);
 }
 
-VALUE rb_glfw_monitor_height(VALUE self) {
-    MONITOR();
-    int height;
-    glfwGetMonitorPhysicalSize(m, NULL, &height);
-    return INT2NUM(height);
+static VALUE rb_glfw_video_to_s(VALUE self)
+{
+    GLFWvidmode *v = DATA_PTR(self);
+    return rb_sprintf("<%s: width:%d, height:%d, r:%d, g:%d, b:%d, rate:%dhz>", rb_class2name(CLASS_OF(self)), v->width, v->height, v->redBits, v->greenBits, v->blueBits, v->refreshRate);
 }
 
-VALUE rb_glfw_monitor_dimensions(VALUE self) {
-    MONITOR();
-    int x, y, width, height;
-    glfwGetMonitorPos(m, &x, &y);
-    glfwGetMonitorPhysicalSize(m, &width, &height);
-    VALUE ary = rb_ary_new_capa(4);
-    rb_ary_store(ary, 0, INT2NUM(x));
-    rb_ary_store(ary, 1, INT2NUM(y));
-    rb_ary_store(ary, 2, INT2NUM(width));
-    rb_ary_store(ary, 3, INT2NUM(height));
-    return ary;
-}
+static VALUE rb_glfw_monitor_get_gamma_ramp(VALUE self)
+{
+    const GLFWgammaramp *ramp = glfwGetGammaRamp(DATA_PTR(self));
 
-VALUE rb_glfw_monitor_get_gamma_ramp(VALUE self) {
-    MONITOR();
-    const GLFWgammaramp *ramp = glfwGetGammaRamp(m);
+    long capa = (long) ramp->size;
+    VALUE r = rb_ary_new_capa(capa);
+    VALUE g = rb_ary_new_capa(capa);
+    VALUE b = rb_ary_new_capa(capa);
 
-    if (ramp == NULL)
-        return Qnil;
+    for (long i = 0; i < capa; i++)
+    {
+        rb_ary_store(r, i, USHORT2NUM(ramp->red[i]));
+        rb_ary_store(g, i, USHORT2NUM(ramp->green[i]));
+        rb_ary_store(b, i, USHORT2NUM(ramp->blue[i]));
+    }
+    return rb_ary_new_from_args(3, r, g, b);
+}
 
-    int count = ramp->size;
-    VALUE hash = rb_hash_new();
-    VALUE red = rb_ary_new_capa(count), green = rb_ary_new_capa(count), blue = rb_ary_new_capa(count);
+static VALUE rb_glfw_monitor_set_gamma_ramp(VALUE self, VALUE gamma)
+{
+    if (!RB_TYPE_P(gamma, T_ARRAY))
+        rb_raise(rb_eTypeError, "%s us not an Array", rb_obj_classname(CLASS_OF(gamma)));
+    if (rb_array_len(gamma) != 3)
+        rb_raise(rb_eArgError, "gamma array must have a length of 3");
 
-    for (int i = 0; i < count; i++) {
-        rb_ary_store(red, i, INT2NUM(ramp->red[i]));
-        rb_ary_store(green, i, INT2NUM(ramp->green[i]));
-        rb_ary_store(blue, i, INT2NUM(ramp->blue[i]));
-    }
 
-    rb_hash_aset(hash, ID2SYM(rb_intern("red")), red);
-    rb_hash_aset(hash, ID2SYM(rb_intern("green")), green);
-    rb_hash_aset(hash, ID2SYM(rb_intern("blue")), blue);
+    VALUE r = rb_ary_entry(gamma, 0);
+    VALUE g = rb_ary_entry(gamma, 1);
+    VALUE b = rb_ary_entry(gamma, 2);
 
-    return hash;
-}
+    long capa = rb_array_len(g);
+    if (rb_array_len(r) != capa || rb_array_len(b) != capa)
+        rb_raise(rb_eArgError, "all arrays must be the same length");
 
-VALUE rb_glfw_monitor_set_gamma_ramp(int argc, VALUE *argv, VALUE self) {
-    if (argc != 1 && argc != 3)
+    GLFWgammaramp ramp = {0};
+    ramp.size = (unsigned int) capa;
+    ramp.red = xmalloc(sizeof(short) * capa);
+    ramp.green = xmalloc(sizeof(short) * capa);
+    ramp.blue = xmalloc(sizeof(short) * capa);
+
+    for (long i = 0; i < capa; i++)
     {
-        rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 1, 3)", argc);
-        return Qnil;
+        ramp.red[i] = NUM2USHORT(rb_ary_entry(r, i));
+        ramp.green[i] = NUM2USHORT(rb_ary_entry(g, i));
+        ramp.blue[i] = NUM2USHORT(rb_ary_entry(b, i));
     }
 
-    MONITOR();
-    VALUE red, green, blue;
+    glfwSetGammaRamp(DATA_PTR(self), &ramp);
 
-    if (argc == 1)
-    {
-        Check_Type(argv[0], T_HASH);
-        red = rb_hash_aref(argv[0], ID2SYM(rb_intern("red")));
-        green = rb_hash_aref(argv[0], ID2SYM(rb_intern("green")));
-        blue = rb_hash_aref(argv[0], ID2SYM(rb_intern("blue")));
-    }
-    else
-    {
-        red = argv[0];
-        green = argv[1];
-        blue = argv[2];
-    }
+    xfree(ramp.red);
+    xfree(ramp.green);
+    xfree(ramp.blue);
 
-    Check_Type(red, T_ARRAY);
-    Check_Type(green, T_ARRAY);
-    Check_Type(blue, T_ARRAY);
+    return gamma;
+}
 
-    int size = rb_array_len(red);
-    if (rb_array_len(green) != size || rb_array_len(blue) != size)
-    {
-        rb_raise(rb_eRuntimeError, "red, green, and blue gamma ramps must all be of equal length");
-        return Qnil;
-    }
+static VALUE rb_glfw_monitor_gamma(VALUE self, VALUE gamma)
+{
+    glfwSetGamma(DATA_PTR(self), NUM2FLT(gamma));
+    return Qnil;
+}
+
+static VALUE rb_glfw_monitor_content_scale(VALUE self)
+{
+    float x, y;
+    glfwGetMonitorContentScale(DATA_PTR(self), &x, &y);
+    return rb_glfw_vec2_create(cVec2, x, y);
+}
 
-    GLFWgammaramp *ramp = malloc(sizeof(GLFWgammaramp));
-    ramp->size = size;
-    ramp->red = malloc(sizeof(u_short) * size);
-    ramp->green = malloc(sizeof(u_short) * size);
-    ramp->blue = malloc(sizeof(u_short) * size);
+static VALUE rb_glfw_monitor_video_mode(VALUE self)
+{
+    const GLFWvidmode *mode = glfwGetVideoMode(DATA_PTR(self));
+    return rb_glfw_video_create(mode);
+}
+
+static VALUE rb_glfw_monitor_video_modes(VALUE self)
+{
+    int count;
+    const GLFWvidmode *modes = glfwGetVideoModes(DATA_PTR(self), &count);
 
-    for (int i = 0; i < size; i++)
+    VALUE ary = rb_ary_new_capa(count);
+    for (int i = 0; i < count; i++)
     {
-        ramp->red[i] = NUM2USHORT(rb_ary_entry(red, i));
-        ramp->green[i] = NUM2USHORT(rb_ary_entry(green, i));
-        ramp->blue[i] = NUM2USHORT(rb_ary_entry(blue, i));
+        VALUE video = rb_glfw_video_create(&modes[i]);
+        rb_ary_store(ary, i, video);
     }
+    return ary;
+}
 
-    glfwSetGammaRamp(m, ramp);
+static VALUE rb_glfw_monitor_work_area_location(VALUE self)
+{
+    int x, y;
+    glfwGetMonitorWorkarea(DATA_PTR(self), &x, &y, NULL, NULL);
+    return rb_glfw_ivec2_create(cPoint, x, y);
+}
 
-    free(ramp);
-    return self;
+static VALUE rb_glfw_monitor_work_area_size(VALUE self)
+{
+    int w, h;
+    glfwGetMonitorWorkarea(DATA_PTR(self), NULL, NULL, &w, &h);
+    return rb_glfw_ivec2_create(cSize, w, h);
 }
 
-VALUE rb_glfw_monitor_gamma(VALUE self, VALUE exponent) {
-    MONITOR();
-    float e = (float) NUM2DBL(exponent);
-    glfwSetGamma(m, e);
-    return exponent;
+static VALUE rb_glfw_monitor_size(VALUE self)
+{
+    const GLFWvidmode *vid = glfwGetVideoMode(DATA_PTR(self));
+    return rb_glfw_ivec2_create(cSize, vid->width, vid->height);
 }
 
-VALUE rb_glfw_monitor_primary(VALUE klass) {
-    GLFWmonitor *m = glfwGetPrimaryMonitor();
-    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, m);
+static VALUE rb_glfw_monitor_physical_size(VALUE self)
+{
+    int w, h;
+    glfwGetMonitorPhysicalSize(DATA_PTR(self), &w, &h);
+    return rb_glfw_ivec2_create(cSize, w, h);
 }
 
-VALUE rb_glfw_monitor_video_mode(VALUE self) {
-    MONITOR();
-    const GLFWvidmode *v = glfwGetVideoMode(m);
-    return Data_Wrap_Struct(rb_cGLFWvidmode, NULL, RUBY_DEFAULT_FREE,  (void*) v);
+static VALUE rb_glfw_monitor_position(VALUE self)
+{
+    int x, y;
+    glfwGetMonitorPos(DATA_PTR(self), &x, &y);
+    return rb_glfw_ivec2_create(cPoint, x, y);
 }
 
-VALUE rb_glfw_monitor_video_modes(VALUE self) {
-    MONITOR();
+static VALUE rb_glfw_monitor_available(VALUE klass)
+{
     int count;
-    const GLFWvidmode *modes = glfwGetVideoModes(m, &count);
+    GLFWmonitor **monitors = glfwGetMonitors(&count);
     VALUE ary = rb_ary_new_capa(count);
+
     for (int i = 0; i < count; i++)
     {
-        rb_ary_store(ary, i, Data_Wrap_Struct(rb_cGLFWvidmode, NULL, RUBY_DEFAULT_FREE, (void*) &modes[i]));
+        VALUE monitor = Data_Wrap_Struct(klass, NULL, NULL, monitors[i]);
+        rb_ary_store(ary, i, monitor);
     }
+
     return ary;
 }
+
+static VALUE rb_glfw_monitor_name(VALUE self)
+{
+    return rb_str_new_cstr(glfwGetMonitorName(DATA_PTR(self)));
+}
+
+static VALUE rb_glfw_monitor_eql(VALUE self, VALUE other)
+{
+
+    if (CLASS_OF(self) != CLASS_OF(other))
+        return Qfalse;
+
+    return RB_BOOL(DATA_PTR(self) == DATA_PTR(other));
+}
+
+static VALUE rb_glfw_monitor_primary(VALUE klass)
+{
+    GLFWmonitor *monitor = glfwGetPrimaryMonitor();
+    return monitor ? Data_Wrap_Struct(klass, NULL, NULL, monitor) : Qnil;
+}
+
+static void rb_glfw_monitor_cb_connected(GLFWmonitor *monitor, int connected)
+{
+    if (RTEST(cb_monitor))
+    {
+        VALUE mon = Data_Wrap_Struct(cMonitor, NULL, NULL, monitor);
+        VALUE state = RB_BOOL(connected == GLFW_CONNECTED);
+        rb_proc_call(cb_monitor, rb_ary_new_from_args(2, mon, state));
+    }
+}
+
+static VALUE rb_glfw_monitor_on_connection(VALUE klass)
+{
+    VALUE current = cb_monitor;
+    if (rb_block_given_p())
+    {
+        cb_monitor = rb_block_proc();
+        glfwSetMonitorCallback(rb_glfw_monitor_cb_connected);
+        rb_iv_set(cMonitor, "@connection_proc", cb_monitor);
+    }
+    else
+    {
+        cb_monitor = Qnil;
+        glfwSetMonitorCallback(NULL);
+        rb_iv_set(cMonitor, "@connection_proc", Qnil);
+    }
+    return current;
+}
+
+static VALUE rb_glfw_monitor_to_s(VALUE self) {
+    return rb_str_new_cstr(glfwGetMonitorName(DATA_PTR(self)));
+}
+
+void rb_glfw_monitor_init(void)
+{
+
+    cVideoMode = rb_define_class_under(mGLFW, "VideoMode", rb_cObject);
+    rb_define_alloc_func(cVideoMode, rb_glfw_video_alloc);
+    rb_define_method(cVideoMode, "width", rb_glfw_video_width, 0);
+    rb_define_method(cVideoMode, "height", rb_glfw_video_height, 0);
+    rb_define_method(cVideoMode, "red_bits", rb_glfw_video_r_bits, 0);
+    rb_define_method(cVideoMode, "green_bits", rb_glfw_video_g_bits, 0);
+    rb_define_method(cVideoMode, "blue_bits", rb_glfw_video_b_bits, 0);
+    rb_define_method(cVideoMode, "refresh_rate", rb_glfw_video_refresh_rate, 0);
+    rb_define_method(cVideoMode, "to_s", rb_glfw_video_to_s, 0);
+
+    cMonitor = rb_define_class_under(mGLFW, "Monitor", rb_cObject);
+    rb_define_singleton_method(cMonitor, "available", rb_glfw_monitor_available, 0);
+    rb_define_singleton_method(cMonitor, "primary", rb_glfw_monitor_primary, 0);
+    rb_define_singleton_method(cMonitor, "on_connection", rb_glfw_monitor_on_connection, 0);
+
+    rb_define_method(cMonitor, "name", rb_glfw_monitor_name, 0);
+    rb_define_method(cMonitor, "position", rb_glfw_monitor_position, 0);
+    rb_define_method(cMonitor, "physical_size", rb_glfw_monitor_physical_size, 0);
+    rb_define_method(cMonitor, "size", rb_glfw_monitor_size, 0);
+    rb_define_method(cMonitor, "client_position", rb_glfw_monitor_work_area_location, 0);
+    rb_define_method(cMonitor, "client_size", rb_glfw_monitor_work_area_size, 0);
+    rb_define_method(cMonitor, "video_mode", rb_glfw_monitor_video_mode, 0);
+    rb_define_method(cMonitor, "video_modes", rb_glfw_monitor_video_modes, 0);
+    rb_define_method(cMonitor, "content_scale", rb_glfw_monitor_content_scale, 0);
+    rb_define_method(cMonitor, "gamma", rb_glfw_monitor_gamma, 1);
+    rb_define_method(cMonitor, "gamma_ramp", rb_glfw_monitor_get_gamma_ramp, 0);
+    rb_define_method(cMonitor, "gamma_ramp=", rb_glfw_monitor_set_gamma_ramp, 1);
+    rb_define_method(cMonitor, "==", rb_glfw_monitor_eql, 1);
+    rb_define_method(cMonitor, "eql?", rb_glfw_monitor_eql, 1);
+    rb_define_method(cMonitor, "to_s", rb_glfw_monitor_to_s, 0);
+
+    cb_monitor = Qnil;
+}