ray 0.1.1 → 0.2.0

data/ext/say_x11.h

@@ -9,6 +9,8 @@
 
 #include <GL/glx.h>
 
+#include "mo.h"
+
 typedef struct say_x11_window {
   Display *dis;
   Window win;
@@ -17,7 +19,7 @@ typedef struct say_x11_window {
   XVisualInfo *vi;
   GLXFBConfig config;
 
-  struct say_array *events;
+  mo_array events;
 
   XIM im;
   XIC ic;

data/ext/say_x11_context.h

@@ -1,22 +1,78 @@
 #include "say.h"
 
+#ifdef HAVE_GL_GLXEXT_H
+# include <GL/glxext.h>
+#else
+# define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
+# define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
+# define GLX_CONTEXT_FLAGS_ARB	       0x2094
+# define GLX_CONTEXT_PROFILE_MASK_ARB  0x9126
+
+# define GLX_CONTEXT_CORE_PROFILE_BIT_ARB          0x00000001
+# define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+
+# define GLX_CONTEXT_DEBUG_BIT_ARB                 0x00000001
+#endif
+
+typedef GLXContext (*say_glx_create_context)(Display *dpy,
+                                             GLXFBConfig config,
+                                             GLXContext share_context,
+                                             Bool direct,
+                                             const int *attrib_list);
+
+static say_glx_create_context glXCreateContextAttribs = NULL;
+
 say_imp_context say_imp_context_create() {
-  return  say_imp_context_create_shared(NULL);
+  return say_imp_context_create_shared(NULL);
+}
+
+static GLXContext say_x11_do_create_context(Display     *dis,
+                                            GLXFBConfig  conf,
+                                            GLXContext   share) {
+  glXCreateContextAttribs = (say_glx_create_context)
+    glXGetProcAddress((GLubyte*)"glXCreateContextAttribsARB");
+
+  say_context_config *say_conf = say_context_get_config();
+  size_t major = say_conf->major_version, minor = say_conf->minor_version;
+
+  if (glXCreateContextAttribs) {
+    GLint attribs[] = {
+      GLX_CONTEXT_MAJOR_VERSION_ARB, major,
+      GLX_CONTEXT_MINOR_VERSION_ARB, minor,
+      GLX_CONTEXT_FLAGS_ARB, say_conf->debug ? GLX_CONTEXT_DEBUG_BIT_ARB : 0,
+      GLX_CONTEXT_PROFILE_MASK_ARB, say_conf->core_profile ?
+      GLX_CONTEXT_CORE_PROFILE_BIT_ARB :
+      GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
+      None
+    };
+
+    GLXContext ctxt = glXCreateContextAttribs(dis, conf, share, true,
+                                              attribs);
+
+    if (ctxt)
+      return ctxt;
+  }
+
+  return glXCreateNewContext(dis, conf, GLX_RGBA_TYPE, share, True);
 }
 
 say_imp_context say_imp_context_create_shared(say_imp_context shared) {
   say_x11_context *context = malloc(sizeof(say_x11_context));
 
+  context->should_free_window = true;
+
   context->dis = XOpenDisplay(NULL);
 
   int screen = DefaultScreen(context->dis);
 
-  static int visual_attribs[] = {
+  say_context_config *say_conf = say_context_get_config();
+  int visual_attribs[] = {
     GLX_RED_SIZE,     8,
     GLX_GREEN_SIZE,   8,
     GLX_BLUE_SIZE,    8,
     GLX_ALPHA_SIZE,   8,
-    GLX_DEPTH_SIZE,   24,
+    GLX_DEPTH_SIZE,   say_conf->depth_size,
+    GLX_STENCIL_SIZE, say_conf->stencil_size,
     GLX_DOUBLEBUFFER, True,
     None
   };
@@ -44,12 +100,11 @@ say_imp_context say_imp_context_create_shared(say_imp_context shared) {
                                InputOutput,
                                vi->visual,
                                CWBorderPixel|CWColormap, &swa);
-
   XFree(vi);
 
   GLXContext glx_shared = shared ? shared->context : NULL;
-  context->context = glXCreateNewContext(context->dis, config, GLX_RGBA_TYPE,
-                                         glx_shared, True);
+  context->context = say_x11_do_create_context(context->dis, config,
+                                               glx_shared);
 
   return context;
 }
@@ -63,8 +118,8 @@ say_imp_context  say_imp_context_create_for_window(say_imp_context shared,
 
   context->should_free_window = 0;
 
-  context->context = glXCreateNewContext(window->dis, window->config,
-                                         GLX_RGBA_TYPE, shared->context, True);
+  context->context = say_x11_do_create_context(window->dis, window->config,
+                                               shared->context);
 
   return context;
 }
@@ -90,7 +145,6 @@ void say_imp_context_make_current(say_imp_context context) {
 }
 
 void say_imp_context_update(say_imp_context context) {
-  if (context->win)
-    glXSwapBuffers(context->dis, context->win);
+  glXSwapBuffers(context->dis, context->win);
 }
 

data/ext/say_x11_window.h

@@ -129,13 +129,13 @@ say_imp_window say_imp_window_create() {
   win->hidden_cursor = None;
   win->old_video_mode = -1;
 
-  win->events = say_array_create(sizeof(say_event), NULL, NULL);
+  mo_array_init(&win->events, sizeof(say_event));
 
   return win;
 }
 
 void say_imp_window_free(say_imp_window win) {
-  say_array_free(win->events);
+  mo_array_release(&win->events);
   free(win);
 }
 
@@ -298,7 +298,7 @@ bool say_imp_window_open(say_imp_window win, const char *title,
 }
 
 void say_imp_window_close(say_imp_window win) {
-  say_array_resize(win->events, 0);
+  mo_array_resize(&win->events, 0);
 
 #ifdef HAVE_XRANDR
   if (win->dis && win->old_video_mode >= 0) {
@@ -375,10 +375,13 @@ bool say_imp_window_set_icon(say_imp_window win, struct say_image *icon) {
 
   /* Convert image to BGRA */
 
-  say_color *orig_buf = say_image_get_buffer(icon);
-  long      *pixels   = malloc(sizeof(long) * (2 + (icon->width * icon->height)));
+  say_color *orig_buf = say_flip_color_buffer_copy(say_image_get_buffer(icon),
+                                                   say_image_get_width(icon),
+                                                   say_image_get_height(icon));
 
-  if (!pixels) {
+  long *pixels = malloc(sizeof(long) * (2 + (icon->width * icon->height)));
+
+  if (!(pixels && orig_buf)) {
     say_error_set("could not allocate icon buffer");
     return false;
   }
@@ -399,6 +402,8 @@ bool say_imp_window_set_icon(say_imp_window win, struct say_image *icon) {
     buf++;
   }
 
+  free(orig_buf);
+
   /* Set _NET_WM_ICON */
 
   Atom icon_atom = XInternAtom(win->dis, "_NET_WM_ICON", false);
@@ -695,7 +700,7 @@ static int say_x11_window_parse_event(say_x11_window *win, say_event *ev,
             ev.type = SAY_EVENT_TEXT_ENTERED;
             ev.ev.text.text = character;
 
-            say_array_push(win->events, &ev);
+            mo_array_push(&win->events, &ev);
           }
         }
         else
@@ -711,14 +716,14 @@ static int say_x11_window_parse_event(say_x11_window *win, say_event *ev,
             ev.type = SAY_EVENT_TEXT_ENTERED;
             ev.ev.text.text = (uint32_t)key_buffer[0];
 
-            say_array_push(win->events, &ev);
+            mo_array_push(&win->events, &ev);
           }
         }
       }
 
-      if (ev->type == SAY_EVENT_NONE && say_array_get_size(win->events) != 0) {
-        *ev = *(say_event*)say_array_get(win->events, 0);
-        say_array_delete(win->events, 0);
+      if (ev->type == SAY_EVENT_NONE && win->events.size != 0) {
+        *ev = mo_array_get_as(&win->events, 0, say_event);
+        mo_array_delete(&win->events, 0);
 
         return 1;
       }
@@ -775,9 +780,9 @@ static int say_x11_window_parse_event(say_x11_window *win, say_event *ev,
 
 bool say_imp_window_poll_event(say_imp_window win, struct say_event *ev,
                                struct say_input *input) {
-  if (say_array_get_size(win->events) != 0) {
-    *ev = *(say_event*)say_array_get(win->events, 0);
-    say_array_delete(win->events, 0);
+  if (win->events.size != 0) {
+    *ev = mo_array_get_as(&win->events, 0, say_event);
+    mo_array_delete(&win->events, 0);
 
     return 1;
   }
@@ -798,9 +803,9 @@ bool say_imp_window_poll_event(say_imp_window win, struct say_event *ev,
 
 void say_imp_window_wait_event(say_imp_window win, struct say_event *ev,
                                struct say_input *input) {
-  if (say_array_get_size(win->events) != 0) {
-    *ev = *(say_event*)say_array_get(win->events, 0);
-    say_array_delete(win->events, 0);
+  if (win->events.size != 0) {
+    *ev = mo_array_get_as(&win->events, 0, say_event);
+    mo_array_delete(&win->events, 0);
 
     return;
   }

data/ext/shader.c

@@ -158,6 +158,14 @@ VALUE ray_shader_bind(VALUE self) {
   return Qnil;
 }
 
+/*
+ * @return [Integer] The OpenGL program id
+ */
+static
+VALUE ray_shader_program(VALUE self) {
+  return NUM2ULONG(say_shader_get_program(ray_rb2shader(self)));
+}
+
 static
 VALUE ray_shader_set_vector2(VALUE self, VALUE loc, VALUE val) {
   rb_check_frozen(self);
@@ -299,4 +307,5 @@ void Init_ray_shader() {
   rb_define_method(ray_cShader, "set_bool", ray_shader_set_bool, 2);
 
   rb_define_method(ray_cShader, "bind", ray_shader_bind, 0);
+  rb_define_method(ray_cShader, "program", ray_shader_program, 0);
 }

data/ext/sprite.c

@@ -16,11 +16,17 @@ say_sprite *ray_rb2sprite(VALUE obj) {
 
 VALUE ray_sprite_alloc(VALUE self) {
   say_sprite *sprite = say_sprite_create();
-  return Data_Wrap_Struct(self, NULL, say_sprite_free, sprite);
+  VALUE rb = Data_Wrap_Struct(self, NULL, say_sprite_free, sprite);
+
+  say_drawable_set_shader_proc(sprite->drawable, ray_drawable_shader_proc);
+  say_drawable_set_other_data(sprite->drawable, (void*)rb);
+
+  return rb;
 }
 
 VALUE ray_sprite_init_copy(VALUE self, VALUE orig) {
   rb_iv_set(self, "@image", rb_iv_get(orig, "@image"));
+  ray_drawable_copy_attr(self, orig);
   say_sprite_copy(ray_rb2sprite(self), ray_rb2sprite(orig));
   return self;
 }

data/ext/target.c

@@ -18,19 +18,28 @@ say_target *ray_rb2target(VALUE obj) {
 }
 
 /*
-  @return [Ray::Vector2] Size of the target, in pixels.
-*/
+ * @return [Ray::Vector2] Size of the target, in pixels.
+ */
 static
 VALUE ray_target_size(VALUE self) {
   return ray_vector2_to_rb(say_target_get_size(ray_rb2target(self)));
 }
 
-/* @return [Ray::View] View currently used */
+/* @see view= */
 static
 VALUE ray_target_view(VALUE self) {
   return ray_view2rb(say_target_get_view(ray_rb2target(self)));
 }
 
+/*
+ * @overload view=(view)
+ *   Sets the view used by the target
+ *
+ *   Notice the view returned by {#view} is a copy of the view used internally.
+ *
+ *   @param [Ray::View] view New view
+ *   @see Ray::View
+ */
 static
 VALUE ray_target_set_view(VALUE self, VALUE val) {
   rb_check_frozen(self);
@@ -39,28 +48,51 @@ VALUE ray_target_set_view(VALUE self, VALUE val) {
 }
 
 
-/* @return [Ray::View] Default view of the target */
+/*
+ * Default view of the target
+ *
+ * The default view is made so that no scaling will be performed. It has the
+ * following properties:
+ *
+ * 1. +size+ is the size of the target;
+ * 2. +center+ is the center of the target (half of the target);
+ * 3. +viewport+ is the whole target (that is, +[0, 0, 1, 1]+).
+ *
+ * @return [Ray::View] Default view of the target
+ */
 static
 VALUE ray_target_default_view(VALUE self) {
   say_view *view = say_target_get_default_view(ray_rb2target(self));
-  return Data_Wrap_Struct(rb_path2class("Ray::View"), NULL, say_view_free, view);
+  return Data_Wrap_Struct(rb_path2class("Ray::View"), NULL, say_view_free,
+                          view);
 }
 
+/*
+ * Low-level access to the shader. {#shader} will cache this.
+ * @return [Ray::Shader] The target's shader
+ */
 static
 VALUE ray_target_shader(VALUE self) {
   return ray_shader2rb(say_target_get_shader(ray_rb2target(self)), self);
 }
 
-/* @return [Ray::Rect] Part of the target that's used by the view */
+/*
+ * Clipping rectangle when using the current view
+ * @return [Ray::Rect] Part of the target that's used by the view
+ *
+ * @see Ray::View.clip
+ */
 static
 VALUE ray_target_clip(VALUE self) {
   return ray_rect2rb(say_target_get_clip(ray_rb2target(self)));
 }
 
 /*
-  @overload viewport_for(rect)
-    @param [Ray::Rect] rect Rect in pixel
-    @return [Ray::Rect] Viewport to set in the view
+ * @overload viewport_for(rect)
+ *   Viewport for a view to make it draw on a given rect
+ *
+ *   @param [Ray::Rect] rect Rect in pixel
+ *   @return [Ray::Rect] Viewport to set in the view
  */
 static
 VALUE ray_target_viewport_for(VALUE self, VALUE rect) {
@@ -69,12 +101,15 @@ VALUE ray_target_viewport_for(VALUE self, VALUE rect) {
 }
 
 /*
-  Makes a target become the current one.
-  Not useful unless using OpenGL directly.
-
-  @raise If a context could not be created or made current. Would often mean the
-    target was not initialized properly (e.g. window is not open)
-*/
+ * Makes a target become the current one
+ *
+ * This method is only used when using low-level OpenGL access. Calling {#draw}
+ * will cause this method to be called anyway (and custom drawables also allow
+ * OpenGL calls)
+ *
+ * @raise If a context could not be created or made current. This Would often
+ *   mean the target was not initialized properly (e.g. window is not open)
+ */
 static
 VALUE ray_target_make_current(VALUE self) {
   if (!say_target_make_current(ray_rb2target(self)))
@@ -83,12 +118,13 @@ VALUE ray_target_make_current(VALUE self) {
 }
 
 /*
-  @overload clear(color)
-    Clears the target in a given color. Should usually be called before drawing
-    anything in a new frame.
-
-    @param [Ray::Color] color Color to clear the target with.
-*/
+ * @overload clear(color)
+ *   Clears the target in a given color
+ *
+ *   This method should usually be called before performing drawing.
+ *
+ *   @param [Ray::Color] color Color to clear the target with.
+ */
 static
 VALUE ray_target_clear(VALUE self, VALUE color) {
   say_target_clear(ray_rb2target(self), ray_rb2col(color));
@@ -96,10 +132,10 @@ VALUE ray_target_clear(VALUE self, VALUE color) {
 }
 
 /*
-  @overload draw(obj)
-    Draws an object on the target.
-    @param [Ray::Drawable, Ray::BufferRenderer] obj Object to be drawn
-*/
+ * @overload draw(obj)
+ *   Draws an object on the target
+ *   @param [Ray::Drawable, Ray::BufferRenderer] obj Object to be drawn
+ */
 static
 VALUE ray_target_draw(VALUE self, VALUE obj) {
   if (RAY_IS_A(obj, rb_path2class("Ray::BufferRenderer"))) {
@@ -113,6 +149,11 @@ VALUE ray_target_draw(VALUE self, VALUE obj) {
 
 /*
  * @overload [](x, y)
+ *  Color of the pixel at a given position
+ *
+ *  This operation is slow. It is much faster to access a rect or the whole
+ *  image than to read each pixel from that rect.
+ *
  *  @param [Integer] x
  *  @param [Integer] y
  *
@@ -127,7 +168,8 @@ VALUE ray_target_get(VALUE self, VALUE x, VALUE y) {
 
 /*
  * @overload rect(rect)
- *   @param [Ray::Rect] rect
+ *   Colors of pixels present in a rect
+ *   @param [Ray::Rect] rect Rect to read pixels from
  *   @return [Ray::Image] An image containing the pixels of that rect.
  */
 static
@@ -146,6 +188,7 @@ VALUE ray_target_rect(VALUE self, VALUE rect) {
 }
 
 /*
+ * Colors of all the pixels in the target
  * @return [Ray::Image] An image containing all the pixels of the target
  */
 static
@@ -165,20 +208,29 @@ void Init_ray_target() {
 
   rb_define_method(ray_cTarget, "size", ray_target_size, 0);
 
+  /* @group Manipulating views */
   rb_define_method(ray_cTarget, "view", ray_target_view, 0);
   rb_define_method(ray_cTarget, "view=", ray_target_set_view, 1);
   rb_define_method(ray_cTarget, "default_view", ray_target_default_view, 0);
 
-  rb_define_private_method(ray_cTarget, "simple_shader", ray_target_shader, 0);
-
   rb_define_method(ray_cTarget, "clip", ray_target_clip, 0);
   rb_define_method(ray_cTarget, "viewport_for", ray_target_viewport_for, 1);
+  /* @endgroup */
+
+  rb_define_private_method(ray_cTarget, "simple_shader", ray_target_shader, 0);
 
+  /* @group Low-level access */
   rb_define_method(ray_cTarget, "make_current", ray_target_make_current, 0);
+  /* @endgroup */
+
+  /* @group Drawing */
   rb_define_method(ray_cTarget, "clear", ray_target_clear, 1);
   rb_define_method(ray_cTarget, "draw", ray_target_draw, 1);
+  /* @endgroup */
 
+  /* @group Pixel-level access */
   rb_define_method(ray_cTarget, "[]", ray_target_get, 2);
   rb_define_method(ray_cTarget, "rect", ray_target_rect, 1);
   rb_define_method(ray_cTarget, "to_image", ray_target_to_image, 0);
+  /* @endgroup */
 }