glfw 0.1.0 → 0.9.8

data/ext/glfw/image.c

@@ -0,0 +1,77 @@
+
+#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");
+}
+
+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);
+}
+
+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;
+    }
+
+    rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 2, 3)", argc);
+}
+
+VALUE rb_glfw_image_width(VALUE self) {
+    GLFWimage *image;
+    Data_Get_Struct(self, GLFWimage, image);
+    return INT2NUM(image->width);
+}
+
+VALUE rb_glfw_image_height(VALUE self) {
+    GLFWimage *image;
+    Data_Get_Struct(self, GLFWimage, image);
+    return INT2NUM(image->height);
+}
+
+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);
+}

data/ext/glfw/image.h

@@ -0,0 +1,14 @@
+
+#ifndef GLFW_RB_IMAGE_H
+#define GLFW_RB_IMAGE_H 1
+
+#include "common.h"
+
+void Init_glfw_image(VALUE module);
+static VALUE rb_glfw_image_alloc(VALUE klass);
+VALUE rb_glfw_image_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_glfw_image_width(VALUE self);
+VALUE rb_glfw_image_height(VALUE self);
+VALUE rb_glfw_image_pixels(VALUE self);
+
+#endif /* GLFW_RB_IMAGE_H */

data/ext/glfw/monitor.c

@@ -0,0 +1,209 @@
+
+#include "monitor.h"
+
+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 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);
+}
+
+VALUE rb_glfw_monitor_name(VALUE self) {
+    MONITOR();
+    const char *name = glfwGetMonitorName(m);
+    return rb_str_new_cstr(name);
+}
+
+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;
+}
+
+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;
+}
+
+VALUE rb_glfw_monitor_x(VALUE self) {
+    MONITOR();
+    int x;
+    glfwGetMonitorPos(m, &x, NULL);
+    return INT2NUM(x);
+}
+
+VALUE rb_glfw_monitor_y(VALUE self) {
+    MONITOR();
+    int y;
+    glfwGetMonitorPos(m, NULL, &y);
+    return INT2NUM(y);
+}
+
+VALUE rb_glfw_monitor_width(VALUE self) {
+    MONITOR();
+    int width;
+    glfwGetMonitorPhysicalSize(m, &width, NULL);
+    return INT2NUM(width);
+}
+
+VALUE rb_glfw_monitor_height(VALUE self) {
+    MONITOR();
+    int height;
+    glfwGetMonitorPhysicalSize(m, NULL, &height);
+    return INT2NUM(height);
+}
+
+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;
+}
+
+VALUE rb_glfw_monitor_get_gamma_ramp(VALUE self) {
+    MONITOR();
+    const GLFWgammaramp *ramp = glfwGetGammaRamp(m);
+
+    if (ramp == NULL)
+        return Qnil;
+
+    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);
+
+    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);
+
+    return hash;
+}
+
+VALUE rb_glfw_monitor_set_gamma_ramp(int argc, VALUE *argv, VALUE self) {
+    if (argc != 1 && argc != 3)
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 1, 3)", argc);
+        return Qnil;
+    }
+
+    MONITOR();
+    VALUE red, green, blue;
+
+    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];
+    }
+
+    Check_Type(red, T_ARRAY);
+    Check_Type(green, T_ARRAY);
+    Check_Type(blue, T_ARRAY);
+
+    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;
+    }
+
+    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);
+
+    for (int i = 0; i < size; 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));
+    }
+
+    glfwSetGammaRamp(m, ramp);
+
+    free(ramp);
+    return self;
+}
+
+VALUE rb_glfw_monitor_gamma(VALUE self, VALUE exponent) {
+    MONITOR();
+    float e = (float) NUM2DBL(exponent);
+    glfwSetGamma(m, e);
+    return exponent;
+}
+
+VALUE rb_glfw_monitor_primary(VALUE klass) {
+    GLFWmonitor *m = glfwGetPrimaryMonitor();
+    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, m);
+}
+
+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);
+}
+
+VALUE rb_glfw_monitor_video_modes(VALUE self) {
+    MONITOR();
+    int count;
+    const GLFWvidmode *modes = glfwGetVideoModes(m, &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]));
+    }
+    return ary;
+}

data/ext/glfw/monitor.h

@@ -0,0 +1,29 @@
+
+#ifndef GLFW_RB_MONITOR_H
+#define GLFW_RB_MONITOR_H 1
+
+#include "common.h"
+#include "monitor.h"
+
+#define MONITOR() \
+    GLFWmonitor *m; \
+    Data_Get_Struct(self, GLFWmonitor, m)
+
+void Init_glfw_monitor(VALUE module);
+static VALUE rb_glfw_monitor_alloc(VALUE klass);
+VALUE rb_glfw_monitor_name(VALUE self);
+VALUE rb_glfw_monitor_pos(VALUE self);
+VALUE rb_glfw_monitor_size(VALUE self);
+VALUE rb_glfw_monitor_x(VALUE self);
+VALUE rb_glfw_monitor_y(VALUE self);
+VALUE rb_glfw_monitor_width(VALUE self);
+VALUE rb_glfw_monitor_height(VALUE self);
+VALUE rb_glfw_monitor_dimensions(VALUE self);
+VALUE rb_glfw_monitor_get_gamma_ramp(VALUE self);
+VALUE rb_glfw_monitor_set_gamma_ramp(int argc, VALUE *argv, VALUE self);
+VALUE rb_glfw_monitor_gamma(VALUE self, VALUE exponent);
+VALUE rb_glfw_monitor_video_mode(VALUE self);
+VALUE rb_glfw_monitor_video_modes(VALUE self);
+VALUE rb_glfw_monitor_primary(VALUE klass);
+
+#endif /* GLFW_RB_MONITOR_H */

data/ext/glfw/video_mode.c

@@ -0,0 +1,60 @@
+
+#include "video_mode.h"
+
+VALUE rb_cGLFWvidmode;
+
+void Init_glfw_vidmode(VALUE module) {
+    rb_cGLFWvidmode = rb_define_class_under(module, "VideoMode", rb_cObject);
+
+    rb_define_method(rb_cGLFWvidmode, "width", rb_glfw_vidmode_width, 0);
+    rb_define_method(rb_cGLFWvidmode, "height", rb_glfw_vidmode_height, 0);
+    rb_define_method(rb_cGLFWvidmode, "red_bits", rb_glfw_vidmode_red_bits, 0);
+    rb_define_method(rb_cGLFWvidmode, "green_bits", rb_glfw_vidmode_green_bits, 0);
+    rb_define_method(rb_cGLFWvidmode, "blue_bits", rb_glfw_vidmode_blue_bits, 0);
+    rb_define_method(rb_cGLFWvidmode, "refresh_rate", rb_glfw_vidmode_refresh_rate, 0);
+
+    rb_define_method(rb_cGLFWvidmode, "to_s", rb_glfw_vidmode_to_s, 0);
+    rb_funcall(rb_cGLFWvidmode, rb_intern("private_class_method"), 1, STR2SYM("new"));
+}
+
+static VALUE rb_glfw_vidmode_alloc(VALUE klass) {
+    GLFWvidmode *v = ALLOC(GLFWvidmode);
+    memset(v, 0, sizeof(GLFWvidmode));
+    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, v);
+}
+
+VALUE rb_glfw_vidmode_width(VALUE self) {
+    VIDMODE();
+    return INT2NUM(v->width);
+}
+
+VALUE rb_glfw_vidmode_height(VALUE self) {
+    VIDMODE();
+    return INT2NUM(v->height);
+}
+
+VALUE rb_glfw_vidmode_red_bits(VALUE self) {
+    VIDMODE();
+    return INT2NUM(v->redBits);
+}
+
+VALUE rb_glfw_vidmode_green_bits(VALUE self) {
+    VIDMODE();
+    return INT2NUM(v->greenBits);
+}
+
+VALUE rb_glfw_vidmode_blue_bits(VALUE self) {
+    VIDMODE();
+    return INT2NUM(v->blueBits);
+}
+
+VALUE rb_glfw_vidmode_refresh_rate(VALUE self) {
+    VIDMODE();
+    return INT2NUM(v->refreshRate);
+}
+
+VALUE rb_glfw_vidmode_to_s(VALUE self) {
+    VIDMODE();
+    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);
+}

data/ext/glfw/video_mode.h

@@ -0,0 +1,21 @@
+#ifndef GLFW_RB_VIDEOMODE_H
+#define GLFW_RB_VIDEOMODE_H 1
+
+#include "common.h"
+
+#define VIDMODE()   \
+    GLFWvidmode *v; \
+    Data_Get_Struct(self, GLFWvidmode, v)
+
+void Init_glfw_vidmode(VALUE module);
+static VALUE rb_glfw_vidmode_alloc(VALUE klass);
+
+VALUE rb_glfw_vidmode_width(VALUE self);
+VALUE rb_glfw_vidmode_height(VALUE self);
+VALUE rb_glfw_vidmode_red_bits(VALUE self);
+VALUE rb_glfw_vidmode_green_bits(VALUE self);
+VALUE rb_glfw_vidmode_blue_bits(VALUE self);
+VALUE rb_glfw_vidmode_refresh_rate(VALUE self);
+VALUE rb_glfw_vidmode_to_s(VALUE self);
+
+#endif /* GLFW_RB_VIDEOMODE_H */

data/ext/glfw/vulkan.c

@@ -0,0 +1,48 @@
+
+#include "vulkan.h"
+
+VALUE rb_cGLFWvulkan;
+
+void Init_glfw_vulkan(VALUE module) {
+    rb_cGLFWvulkan = rb_define_class_under(module, "Vulkan", rb_cObject);
+
+    rb_define_method(rb_cGLFWvulkan, "create_surface", rb_glfw_vulkan_create_surface, 2);
+    rb_define_method(rb_cGLFWvulkan, "proc_address", rb_glfw_vulkan_proc_address, 1);
+    rb_define_method(rb_cGLFWvulkan, "device_support", rb_glfw_vulkan_device_support, 2);
+
+    rb_define_singleton_method(rb_cGLFWvulkan, "supported?", rb_glfw_vulkan_supported, 0);
+    rb_define_singleton_method(rb_cGLFWvulkan, "required_extensions", rb_glfw_vulkan_required_ext, 0);
+
+    // TODO: Implement once Vulkan support is better in GLFW
+    rb_funcall(rb_cGLFWvulkan, rb_intern("private_class_method"), 1, STR2SYM("new")); 
+}
+
+
+
+VALUE rb_glfw_vulkan_supported(VALUE klass) {
+    return glfwVulkanSupported() ? Qtrue : Qfalse;
+}
+
+VALUE rb_glfw_vulkan_required_ext(VALUE klass) {
+    uint32_t count;
+    const char **exts = glfwGetRequiredInstanceExtensions(&count);
+    VALUE ary = rb_ary_new_capa(count);
+    for (int i = 0; i < count; i++)
+        rb_ary_store(ary, i, rb_str_new_cstr(exts[i]));
+    return ary;
+}
+
+VALUE rb_glfw_vulkan_create_surface(VALUE self, VALUE window, VALUE allocator) {
+    // TODO: glfwCreateWindowSurface
+    return Qnil;
+}
+
+VALUE rb_glfw_vulkan_proc_address(VALUE self, VALUE name) {
+    // TODO: glfwGetInstanceProcAddress
+    return Qnil;
+}
+
+VALUE rb_glfw_vulkan_device_support(VALUE self, VALUE device, VALUE family) {
+    // TODO: glfwGetPhysicalDevicePresentationSupport	
+    return Qnil;
+}