ray 0.1.1 → 0.2.0

data/ext/polygon.c

@@ -17,12 +17,18 @@ say_polygon *ray_rb2polygon(VALUE obj) {
 static
 VALUE ray_polygon_alloc(VALUE self) {
   say_polygon *obj = say_polygon_create(0);
-  return Data_Wrap_Struct(self, NULL, say_polygon_free, obj);
+  VALUE rb = Data_Wrap_Struct(self, NULL, say_polygon_free, obj);
+
+  say_drawable_set_shader_proc(obj->drawable, ray_drawable_shader_proc);
+  say_drawable_set_other_data(obj->drawable, (void*)rb);
+
+  return rb;
 }
 
 static
 VALUE ray_polygon_init_copy(VALUE self, VALUE other) {
   say_polygon_copy(ray_rb2polygon(self), ray_rb2polygon(other));
+  ray_drawable_copy_attr(self, other);
   return self;
 }
 
@@ -41,16 +47,16 @@ void ray_polygon_make_outline(say_polygon *poly, VALUE outline_width,
 }
 
 /*
-  @overload line(first, last, width = 1, color = Ray::Color.white)
-    @param [Vector2, #to_vector2] first First point of the line
-    @param [Vector2, #to_vector2] last Last point of the line
-
-    @param [Float] width Width of the line
-
-    @param [Ray::Color] color Color of the line
-
-    @return [Ray::Polygon] A line
-*/
+ * @overload line(first, last, width = 1, color = Ray::Color.white)
+ *   @param [Vector2, #to_vector2] first First point of the line
+ *   @param [Vector2, #to_vector2] last Last point of the line
+ *
+ *   @param [Float] width Width of the line
+ *
+ *   @param [Ray::Color] color Color of the line
+ *
+ *   @return [Ray::Polygon] A line
+ */
 static
 VALUE ray_polygon_line(int argc, VALUE *argv, VALUE self) {
   VALUE first = Qnil, last = Qnil, width = Qnil, color = Qnil;
@@ -62,19 +68,24 @@ VALUE ray_polygon_line(int argc, VALUE *argv, VALUE self) {
                                        NIL_P(color) ?
                                        say_make_color(255, 255, 255, 255) :
                                        ray_rb2col(color));
-  return Data_Wrap_Struct(self, NULL, say_polygon_free, line);
+  VALUE rb = Data_Wrap_Struct(self, NULL, say_polygon_free, line);
+
+  say_drawable_set_shader_proc(line->drawable, ray_drawable_shader_proc);
+  say_drawable_set_other_data(line->drawable, (void*)rb);
+
+  return rb;
 }
 
 /*
-  @overload rectangle(rect, color = Ray::Color.white, outline_width = 0,
-                      outline_color = Ray::Color.white)
-    @param [Ray::Rect, #to_rect] rect Rectangle occupied by the polygon
-    @param [Ray::Color] color Color of the rectangle
-    @param [Float] outline_width Width of the outline
-    @param [Ray::Color] outline_color Color of the outline
-
-    @return [Ray::Polygon] A rectangle
-*/
+ * @overload rectangle(rect, color = Ray::Color.white, outline_width = 0,
+ *                     outline_color = Ray::Color.white)
+ *   @param [Ray::Rect, #to_rect] rect Rectangle occupied by the polygon
+ *   @param [Ray::Color] color Color of the rectangle
+ *   @param [Float] outline_width Width of the outline
+ *   @param [Ray::Color] outline_color Color of the outline
+ *
+ *   @return [Ray::Polygon] A rectangle
+ */
 static
 VALUE ray_polygon_rectangle(int argc, VALUE *argv, VALUE self) {
   VALUE rb_rect = Qnil, rb_color = Qnil, outline_width = Qnil, outline = Qnil;
@@ -91,21 +102,25 @@ VALUE ray_polygon_rectangle(int argc, VALUE *argv, VALUE self) {
 
   ray_polygon_make_outline(poly, outline_width, outline);
 
+  say_drawable_set_shader_proc(poly->drawable, ray_drawable_shader_proc);
+  say_drawable_set_other_data(poly->drawable, (void*)ret);
+
   return ret;
 }
 
 /*
-  @overload circle(center, radius, color = Ray::Color.white, outline_width = 0,
-                   outline_color = Ray::Color.white)
-    @param [Ray::Vector2] center The center of the circle
-    @param [Float] radius The radius of the circle
-    @param [Ray::Color] color The color of the circle
-
-    @param outline_width (see rectangle)
-    @param outline_color (see rectangle)
-
-    @return [Ray::Polygon] A circle
-*/
+ * @overload circle(center, radius, color = Ray::Color.white, outline_width = 0,
+ *                  outline_color = Ray::Color.white)
+ *
+ *   @param [Ray::Vector2] center The center of the circle
+ *   @param [Float] radius The radius of the circle
+ *   @param [Ray::Color] color The color of the circle
+ *
+ *   @param outline_width (see rectangle)
+ *   @param outline_color (see rectangle)
+ *
+ *   @return [Ray::Polygon] A circle
+ */
 static
 VALUE ray_polygon_circle(int argc, VALUE *argv, VALUE self) {
   VALUE rb_center = Qnil, rb_radius = Qnil, rb_color = Qnil,
@@ -124,22 +139,25 @@ VALUE ray_polygon_circle(int argc, VALUE *argv, VALUE self) {
 
   ray_polygon_make_outline(poly, rb_outline_width, rb_outline);
 
+  say_drawable_set_shader_proc(poly->drawable, ray_drawable_shader_proc);
+  say_drawable_set_other_data(poly->drawable, (void*)ret);
+
   return ret;
 }
 
 /*
-  @overload ellipse(center, rx, ry, color = Ray::Color.white, outline_width = 0,
-                    outline_color = Ray::Color.white)
-    @param [Ray::Vector2] center The center of the ellipse
-    @param [Float] rx Horizontal radius
-    @param [Float] ry Vertical radius
-    @param [Ray::Color] color The color of the ellipse
-
-    @param outline_width (see rectangle)
-    @param outline_color (see rectangle)
-
-    @return [Ray::Polygon] An ellipse
-*/
+ * @overload ellipse(center, rx, ry, color = Ray::Color.white,
+ *                   outline_width = 0, outline_color = Ray::Color.white)
+ *
+ *   @param [Ray::Vector2] center The center of the ellipse
+ *   @param [Float] rx Horizontal radius
+ *   @param [Float] ry Vertical radius
+ *   @param [Ray::Color] color The color of the ellipse
+ *   @param outline_width (see rectangle)
+ *   @param outline_color (see rectangle)
+ *
+ *   @return [Ray::Polygon] An ellipse
+ */
 static
 VALUE ray_polygon_ellipse(int argc, VALUE *argv, VALUE self) {
   VALUE rb_center = Qnil, rb_rx = Qnil, rb_ry = Qnil, rb_color = Qnil,
@@ -157,7 +175,12 @@ VALUE ray_polygon_ellipse(int argc, VALUE *argv, VALUE self) {
 
   ray_polygon_make_outline(poly, rb_outline_width, rb_outline);
 
-  return Data_Wrap_Struct(self, NULL, say_polygon_free, poly);
+  VALUE rb = Data_Wrap_Struct(self, NULL, say_polygon_free, poly);
+
+  say_drawable_set_shader_proc(poly->drawable, ray_drawable_shader_proc);
+  say_drawable_set_other_data(poly->drawable, (void*)rb);
+
+  return rb;
 }
 
 /*

data/ext/ray.c

@@ -37,6 +37,7 @@ void Init_ray_ext() {
   Init_ray_int_array();
   Init_ray_gl_buffer();
   Init_ray_gl_index_buffer();
+  Init_ray_pixel_bus();
   Init_ray_image();
   Init_ray_font();
   Init_ray_shader();

data/ext/ray.h

@@ -29,9 +29,11 @@ extern VALUE ray_cColor;
 extern VALUE ray_cVertex;
 extern VALUE ray_mGL;
 extern VALUE ray_cGLVertex;
+extern VALUE ray_cGLInstance;
 extern VALUE ray_cIntArray;
 extern VALUE ray_cGLBuffer;
 extern VALUE ray_cGLIndexBuffer;
+extern VALUE ray_cPixelBus;
 extern VALUE ray_cImage;
 extern VALUE ray_cFont;
 extern VALUE ray_cShader;
@@ -63,6 +65,18 @@ extern VALUE ray_cMusic;
 
 #define RAY_ARRAY_AT(ary, i) (rb_funcall(ary, RAY_METH("[]"), 1, INT2FIX(i)))
 
+#if defined(JRUBY) && defined(_DARWIN_C_SOURCE)
+# include <dispatch/dispatch.h>
+
+# define RAY_MAIN dispatch_sync(dispatch_get_main_queue(), ^
+# define RAY_MAIN_END );
+# define RAY_BLOCK __block
+#else
+# define RAY_MAIN if (1)
+# define RAY_MAIN_END
+# define RAY_BLOCK
+#endif
+
 void Init_ray_ext();
 void Init_ray_vector();
 void Init_ray_rect();
@@ -74,6 +88,7 @@ void Init_ray_gl_vertex();
 void Init_ray_int_array();
 void Init_ray_gl_buffer();
 void Init_ray_gl_index_buffer();
+void Init_ray_pixel_bus();
 void Init_ray_image();
 void Init_ray_font();
 void Init_ray_shader();
@@ -128,6 +143,9 @@ say_font *ray_rb2font(VALUE obj);
 VALUE ray_shader2rb(say_shader *shader, VALUE owner);
 say_shader *ray_rb2shader(VALUE obj);
 
+void ray_drawable_copy_attr(VALUE self, VALUE orig);
+void ray_drawable_shader_proc(void *data, say_shader *shader);
+
 say_drawable *ray_rb2drawable(VALUE obj);
 say_polygon *ray_rb2polygon(VALUE obj);
 say_sprite *ray_rb2sprite(VALUE obj);
@@ -148,7 +166,7 @@ say_audio_source *ray_rb2audio_source(VALUE obj);
 say_sound *ray_rb2sound(VALUE obj);
 say_music *ray_rb2music(VALUE obj);
 
-say_array *ray_rb2int_array(VALUE obj);
+mo_array *ray_rb2int_array(VALUE obj);
 
 say_buffer_renderer *ray_rb2buf_renderer(VALUE obj);
 

data/ext/rect.c

@@ -39,59 +39,21 @@ VALUE ray_alloc_rect(VALUE self) {
 }
 
 /*
-  @overload initialize(x, y)
-    Creates a new rect with size set to 0, 0.
-
-  @overload initialize(x, y, w, h)
-    Creates a new rect with the specified size.
-
-  @overload initialize(hash)
-    Creates a new rect according to the keys specified in hash.
-
-    @option hash [Float] :x
-    @option hash [Float] :y
-    @option hash [Float] (0) :width
-    @option hash [Float] (0) :height required if width is set
-
-    @option hash [Float] (0) :w alias for :width
-    @option hash [Float] (0) :h alias for :height
-*/
+ * @overload initialize(x, y)
+ *   Creates a new rect with size set to (0, 0).
+ *
+ * @overload initialize(x, y, w, h)
+ *   Creates a new rect with the specified size.
+ */
 static
 VALUE ray_init_rect(int argc, VALUE *argv, VALUE self) {
-  VALUE x_or_hash, y, w, h;
-  rb_scan_args(argc, argv, "13", &x_or_hash, &y, &w, &h);
-
-  int type = TYPE(x_or_hash);
-  if (type == T_HASH) {
-    if (!NIL_P(y)) {
-      rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
-               argc);
-    }
-
-    VALUE hash = x_or_hash;
-
-    x_or_hash = rb_hash_aref(hash, RAY_SYM("x"));
-    y = rb_hash_aref(hash, RAY_SYM("y"));
-
-    w = rb_hash_aref(hash, RAY_SYM("width"));
-    h = rb_hash_aref(hash, RAY_SYM("height"));
-
-    if (NIL_P(w)) w = rb_hash_aref(hash, RAY_SYM("w"));
-    if (NIL_P(h)) h = rb_hash_aref(hash, RAY_SYM("h"));
-
-    if (NIL_P(y)) {
-      rb_raise(rb_eArgError, "missing option :y");
-    }
-
-    if (!NIL_P(w) && NIL_P(h)) {
-      rb_raise(rb_eArgError, "missing option :height");
-    }
-  }
+  VALUE x, y, w, h;
+  rb_scan_args(argc, argv, "22", &x, &y, &w, &h);
 
   say_rect *rect;
   Data_Get_Struct(self, say_rect, rect);
 
-  rect->x = NUM2DBL(x_or_hash);
+  rect->x = NUM2DBL(x);
   rect->y = NUM2DBL(y);
 
   if (!NIL_P(w)) {

data/ext/say.h

@@ -2,8 +2,6 @@
 #define SAY_H_
 
 #include "say_basic_type.h"
-#include "say_array.h"
-#include "say_table.h"
 #include "say_thread.h"
 #include "say_matrix.h"
 #include "say_image.h"
@@ -14,6 +12,7 @@
 #include "say_buffer_slice.h"
 #include "say_index_buffer.h"
 #include "say_index_buffer_slice.h"
+#include "say_pixel_bus.h"
 #include "say_drawable.h"
 #include "say_view.h"
 #include "say_buffer_renderer.h"

data/ext/say_all.h

@@ -3,6 +3,9 @@
 
 /* Dependencies for all of the files */
 
+/* Data structures */
+#include "mo.h"
+
 /* Standard headers */
 #include <stdlib.h>
 #include <stdio.h>
@@ -72,6 +75,9 @@ void say_error_set(const char *message);
 
 void say_error_clean_up();
 
+/* Get OpenGL proc */
+void *say_get_proc(const char *name);
+
 #define SAY_PI 3.14159265358979323846
 
 #endif

data/ext/say_audio.h

@@ -1,6 +1,9 @@
 #ifndef SAY_AUDIO_H_
 #define SAY_AUDIO_H_
 
+#include "say_basic_type.h"
+#include "say_thread.h"
+
 typedef struct {
   ALuint buf;
 

data/ext/say_audio_context.c

@@ -24,8 +24,6 @@ void say_audio_context_ensure() {
 }
 
 void say_audio_context_clean_up() {
-/* Can't clean properly on windows... */
-#ifndef SAY_WIN
   alcMakeContextCurrent(NULL);
 
   if (say_audio_context)
@@ -35,6 +33,5 @@ void say_audio_context_clean_up() {
     alcCloseDevice(say_audio_device);
 
   say_audio_context = NULL;
-  say_audio_device  = NULL;
-#endif
+  say_audio_device  = NULL;  
 }

data/ext/say_basic_type.c

@@ -15,3 +15,27 @@ bool say_rect_eq(say_rect a, say_rect b) {
 bool say_color_eq(say_color a, say_color b) {
   return a.r == b.r && a.g == b.g  && a.b == b.b && a.a == b.a;
 }
+
+say_color *say_flip_color_buffer_copy(say_color *buf, size_t width,
+                                      size_t height) {
+  size_t     line_size = sizeof(say_color) * width;
+  say_color *ret       = malloc(line_size * height);
+
+  for (size_t y = 0; y < height; y++)
+    memcpy(&ret[y * width], &buf[(height - y - 1) * width], line_size);
+
+  return ret;
+}
+
+void say_flip_color_buffer(say_color *buffer, size_t width, size_t height) {
+  size_t     line_size = sizeof(say_color) * width;
+  say_color *temp_line = malloc(line_size);
+
+  for (size_t y = 0; y < height / 2.0; y++) {
+    memcpy(temp_line, &buffer[y * width], line_size);
+    memcpy(&buffer[y * width], &buffer[(height - y - 1) * width], line_size);
+    memcpy(&buffer[(height - y - 1) * width], temp_line, line_size);
+  }
+
+  free(temp_line);
+}

data/ext/say_basic_type.h

@@ -44,4 +44,8 @@ bool say_color_eq(say_color a, say_color b);
 typedef void (*say_destructor)(void *data);
 typedef void (*say_creator)(void *data);
 
+say_color *say_flip_color_buffer_copy(say_color *buffer, size_t width,
+                                      size_t height);
+void say_flip_color_buffer(say_color *buffer, size_t width, size_t height);
+
 #endif

data/ext/say_buffer.c

@@ -1,8 +1,8 @@
 #include "say.h"
 
 static bool say_has_vao() {
-  return __GLEW_ARB_vertex_array_object ||
-    __GLEW_APPLE_vertex_array_object;
+  return GLEW_ARB_vertex_array_object ||
+    GLEW_VERSION_3_0;
 }
 
 static GLuint say_current_vbo = 0;
@@ -16,11 +16,11 @@ static void say_vbo_make_current(GLuint vbo) {
     say_current_vbo      = vbo;
     say_vbo_last_context = context;
 
-    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, vbo);
   }
 }
 
-static GLuint say_current_vao = 0;
+static GLuint       say_current_vao      = 0;
 static say_context *say_vao_last_context = NULL;
 
 typedef struct {
@@ -37,6 +37,8 @@ static void say_vao_make_current(GLuint vao) {
     say_vao_last_context = context;
 
     glBindVertexArray(vao);
+
+    say_index_buffer_rebind();
   }
 }
 
@@ -72,9 +74,46 @@ static void say_buffer_delete_vao_pair(say_vao_pair *pair) {
   if (say_vao_last_context == pair->context && say_current_vao == pair->vao) {
     say_current_vao = 0;
     glDeleteVertexArrays(1, &pair->vao);
+
+    say_index_buffer_rebind();
+  }
+}
+
+static size_t say_buffer_register_pointer(size_t attr_i, say_vertex_elem_type t,
+                                          size_t stride, size_t offset) {
+  switch (t) {
+  case SAY_FLOAT:
+    glVertexAttribPointer(attr_i, 1, GL_FLOAT, GL_FALSE, stride,
+                          (void*)offset);
+    return offset + sizeof(GLfloat);
+  case SAY_INT:
+    glVertexAttribPointer(attr_i, 1, GL_INT, GL_FALSE, stride,
+                          (void*)offset);
+    return offset + sizeof(GLint);
+  case SAY_UBYTE:
+    glVertexAttribPointer(attr_i, 1, GL_UNSIGNED_BYTE, GL_FALSE, stride,
+                          (void*)offset);
+    return offset + sizeof(GLubyte);
+  case SAY_BOOL:
+    glVertexAttribPointer(attr_i, 1, GL_INT, GL_FALSE, stride,
+                          (void*)offset);
+    return offset + sizeof(GLint);
+
+  case SAY_COLOR:
+    glVertexAttribPointer(attr_i, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride,
+                          (void*)offset);
+    return offset + sizeof(GLubyte) * 4;
+  case SAY_VECTOR2:
+    glVertexAttribPointer(attr_i, 2, GL_FLOAT, GL_FALSE, stride,
+                          (void*)offset);
+    return offset + sizeof(GLfloat) * 2;
+  case SAY_VECTOR3:
+    glVertexAttribPointer(attr_i, 3, GL_FLOAT, GL_FALSE, stride,
+                          (void*)offset);
+    return offset + sizeof(GLfloat) * 3;
   }
 
-  free(pair);
+  return offset;
 }
 
 static void say_buffer_setup_pointer(say_buffer *buf) {
@@ -82,64 +121,69 @@ static void say_buffer_setup_pointer(say_buffer *buf) {
 
   say_vertex_type *type = say_get_vertex_type(buf->vtype);
 
-  size_t count  = say_vertex_type_get_elem_count(type);
-  size_t stride = say_vertex_type_get_size(type);
+  size_t count = say_vertex_type_get_elem_count(type);
+  if (count == 0) /* No attrbutes to set */
+    return;
 
+  size_t stride = say_vertex_type_get_size(type);
   size_t offset = 0;
 
+  size_t instance_stride = say_vertex_type_get_instance_size(type);
+  size_t instance_offset = 0;
+
+  /*
+   * This fixes a bug on OSX (with OpenGL 2.1). Nothing is drawn unless vertex
+   * attribute 0 is enabled.
+   *
+   * We set its data to the same as those used by the first element to ensure
+   * memory we do not own isn't accessed.
+   */
+  say_vertex_elem_type t = say_vertex_type_get_type(type, 0);
+
+  if (say_vertex_type_is_per_instance(type, 0)) {
+    say_vbo_make_current(buf->instance_vbo);
+    say_buffer_register_pointer(0, t, instance_stride, instance_offset);
+  }
+  else {
+    say_vbo_make_current(buf->vbo);
+    say_buffer_register_pointer(0, t, stride, offset);
+  }
+
+  glEnableVertexAttribArray(0);
+
   size_t i = 0;
   for (; i < count; i++) {
-    say_vertex_elem_type t = say_vertex_type_get_type(type, i);
+    t = say_vertex_type_get_type(type, i);
 
-    switch (t) {
-    case SAY_FLOAT:
-      glVertexAttribPointerARB(i, 1, GL_FLOAT, GL_FALSE, stride, (void*)offset);
-      offset += sizeof(GLfloat);
-      break;
-    case SAY_INT:
-      glVertexAttribPointerARB(i, 1, GL_INT, GL_FALSE, stride, (void*)offset);
-      offset += sizeof(GLint);
-      break;
-    case SAY_UBYTE:
-      glVertexAttribPointerARB(i, 1, GL_UNSIGNED_BYTE, GL_FALSE, stride,
-                               (void*)offset);
-      offset += sizeof(GLubyte);
-      break;
-    case SAY_BOOL:
-      glVertexAttribPointerARB(i, 1, GL_INT, GL_FALSE, stride, (void*)offset);
-      offset += sizeof(GLint);
-      break;
-
-    case SAY_COLOR:
-      glVertexAttribPointerARB(i, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride,
-                               (void*)offset);
-      offset += sizeof(GLubyte) * 4;
-      break;
-    case SAY_VECTOR2:
-      glVertexAttribPointerARB(i, 2, GL_FLOAT, GL_FALSE, stride,
-                               (void*)offset);
-      offset += sizeof(GLfloat) * 2;
-      break;
-    case SAY_VECTOR3:
-      glVertexAttribPointerARB(i, 3, GL_FLOAT, GL_FALSE, stride,
-                               (void*)offset);
-      offset += sizeof(GLfloat) * 3;
-      break;
+    if (say_vertex_type_is_per_instance(type, i)) {
+      say_vbo_make_current(buf->instance_vbo);
+      instance_offset = say_buffer_register_pointer(i + 1, t, instance_stride,
+                                                    instance_offset);
+    }
+    else {
+      say_vbo_make_current(buf->vbo);
+      offset = say_buffer_register_pointer(i + 1, t, stride, offset);
     }
 
-    glEnableVertexAttribArrayARB(i);
+    glEnableVertexAttribArray(i + 1);
+    if (glVertexAttribDivisor) {
+      if (say_vertex_type_is_per_instance(type, i))
+        glVertexAttribDivisor(i + 1, 1);
+      else
+        glVertexAttribDivisor(i + 1, 0);
+    }
   }
 
   /*
    * Say will always use all the attribs. Disable all of them until
    * finding one that is already disabled.
    */
-  for (; i < GL_MAX_VERTEX_ATTRIBS_ARB; i++) {
+  for (; i < GL_MAX_VERTEX_ATTRIBS - 1; i++) {
     GLint enabled;
-    glGetVertexAttribivARB(i, GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB, &enabled);
+    glGetVertexAttribiv(i + 1, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &enabled);
 
     if (enabled)
-      glDisableVertexAttribArrayARB(i);
+      glDisableVertexAttribArray(i + 1);
     else
       break;
   }
@@ -147,29 +191,24 @@ static void say_buffer_setup_pointer(say_buffer *buf) {
 
 static void say_buffer_build_vao(say_buffer *buf, GLuint vao) {
   say_vao_make_current(vao);
-  glBindBufferARB(GL_ARRAY_BUFFER_ARB, buf->vbo); /* forcefully bind */
   say_buffer_setup_pointer(buf);
 }
 
 static GLuint say_buffer_get_vao(say_buffer *buf) {
   say_context *ctxt = say_context_current();
-  uint32_t count = ctxt->count;
-
-  say_vao_pair *pair = say_table_get(buf->vaos, count);
 
-  if (!pair) {
-    pair = malloc(sizeof(say_vao_pair));
-    say_table_set(buf->vaos, count, pair);
+  if (!mo_hash_has_key(buf->vaos, &ctxt)) {
+    say_vao_pair pair;
+    pair.context = ctxt;
+    glGenVertexArrays(1, &pair.vao);
+    say_buffer_build_vao(buf, pair.vao);
 
-    pair->context = ctxt;
+    mo_hash_set(buf->vaos, &ctxt, &pair);
 
-    glGenVertexArrays(1, &pair->vao);
-    say_buffer_build_vao(buf, pair->vao);
-
-    return pair->vao;
+    return pair.vao;
   }
   else {
-    return pair->vao;
+    return mo_hash_get_ptr(buf->vaos, &ctxt, say_vao_pair)->vao;
   }
 }
 
@@ -178,23 +217,40 @@ say_buffer *say_buffer_create(size_t vtype, GLenum type, size_t size) {
 
   say_buffer *buf = (say_buffer*)malloc(sizeof(say_buffer));
 
-  if (say_has_vao())
-    buf->vaos = say_table_create((say_destructor)say_buffer_delete_vao_pair);
+  if (say_has_vao()) {
+    buf->vaos = mo_hash_create(sizeof(say_context*), sizeof(say_vao_pair));
+    buf->vaos->release = (say_destructor)say_buffer_delete_vao_pair;
+    buf->vaos->hash_of = mo_hash_of_pointer;
+    buf->vaos->key_cmp = mo_hash_pointer_cmp;
+
+  }
   else
     buf->vaos = NULL;
 
   buf->vtype = vtype;
 
-  glGenBuffersARB(1, &buf->vbo);
+  glGenBuffers(1, &buf->vbo);
   say_vbo_make_current(buf->vbo);
 
   buf->type = type;
 
-  size_t byte_size = say_vertex_type_get_size(say_get_vertex_type(vtype));
-  buf->buffer = say_array_create(byte_size, NULL, NULL);
-  say_array_resize(buf->buffer, size);
+  say_vertex_type *vtype_ref = say_get_vertex_type(vtype);
+  size_t byte_size = say_vertex_type_get_size(vtype_ref);
+  mo_array_init(&buf->buffer, byte_size);
+  mo_array_resize(&buf->buffer, size);
+
+  glBufferData(GL_ARRAY_BUFFER, size * byte_size, NULL, type);
 
-  glBufferDataARB(GL_ARRAY_BUFFER_ARB, size * byte_size, NULL, type);
+  buf->instance_vbo    = 0;
+  buf->instance_buffer = NULL;
+
+  if (say_vertex_type_has_instance_data(vtype_ref)) {
+    glGenBuffers(1, &buf->instance_vbo);
+    say_vbo_make_current(buf->instance_vbo);
+
+    byte_size = say_vertex_type_get_instance_size(vtype_ref);
+    buf->instance_buffer = mo_array_create(byte_size);
+  }
 
   return buf;
 }
@@ -203,19 +259,34 @@ void say_buffer_free(say_buffer *buf) {
   say_context_ensure();
 
   if (buf->vaos)
-    say_table_free(buf->vaos);
+    mo_hash_free(buf->vaos);
   else
     say_buffer_will_delete(buf);
 
   say_vbo_will_delete(buf->vbo);
-  glDeleteBuffersARB(1, &(buf->vbo));
+  glDeleteBuffers(1, &buf->vbo);
+
+  if (buf->instance_vbo) {
+    say_vbo_will_delete(buf->instance_vbo);
+    glDeleteBuffers(1, &buf->instance_vbo);
+
+    mo_array_free(buf->instance_buffer);
+  }
 
-  say_array_free(buf->buffer);
+  mo_array_release(&buf->buffer);
   free(buf);
 }
 
+bool say_buffer_has_instance(say_buffer *buf) {
+  return buf->instance_buffer != NULL;
+}
+
 void *say_buffer_get_vertex(say_buffer *buf, size_t id) {
-  return say_array_get(buf->buffer, id);
+  return mo_array_at(&buf->buffer, id);
+}
+
+void *say_buffer_get_instance(say_buffer *buf, size_t id) {
+  return mo_array_at(buf->instance_buffer, id);
 }
 
 void say_buffer_bind(say_buffer *buf) {
@@ -227,51 +298,109 @@ void say_buffer_bind(say_buffer *buf) {
     say_buffer_make_current(buf);
 }
 
+void say_buffer_bind_vbo(say_buffer *buf) {
+  say_context_ensure();
+  say_vbo_make_current(buf->vbo);
+}
+
+void say_buffer_bind_instance_vbo(say_buffer *buf) {
+  say_context_ensure();
+  say_vbo_make_current(buf->instance_vbo);
+}
+
 void say_buffer_unbind() {
-  say_vbo_make_current(0);
+  say_context_ensure();
 
   if (say_has_vao())
     say_vao_make_current(0);
   else { /* disable vertex attribs */
-    for (size_t i = 0; i < GL_MAX_VERTEX_ATTRIBS_ARB; i++) {
+    for (size_t i = 1; i < GL_MAX_VERTEX_ATTRIBS; i++) {
       GLint enabled;
-      glGetVertexAttribivARB(i, GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB, &enabled);
+      glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &enabled);
 
       if (enabled)
-        glDisableVertexAttribArrayARB(i);
+        glDisableVertexAttribArray(i);
       else
         break;
     }
   }
 }
 
+void say_buffer_unbind_vbo() {
+  say_context_ensure();
+  say_vbo_make_current(0);
+}
+
 void say_buffer_update_part(say_buffer *buf, size_t id, size_t size) {
   if (size == 0) return;
 
   say_context_ensure();
-  say_buffer_bind(buf);
 
-  size_t byte_size = say_array_get_elem_size(buf->buffer);
-  glBufferSubDataARB(GL_ARRAY_BUFFER_ARB,
-                     byte_size * id,
-                     byte_size * size,
-                     say_buffer_get_vertex(buf, id));
+  size_t byte_size = buf->buffer.el_size;
+  say_vbo_make_current(buf->vbo);
+  glBufferSubData(GL_ARRAY_BUFFER,
+                  byte_size * id,
+                  byte_size * size,
+                  say_buffer_get_vertex(buf, id));
 }
 
 void say_buffer_update(say_buffer *buf) {
-  say_buffer_update_part(buf, 0, say_array_get_size(buf->buffer));
+  say_buffer_update_part(buf, 0, buf->buffer.size);
 }
 
 size_t say_buffer_get_size(say_buffer *buf) {
-  return say_array_get_size(buf->buffer);
+  return buf->buffer.size;
 }
 
 void say_buffer_resize(say_buffer *buf, size_t size) {
-  say_array_resize(buf->buffer, size);
+  mo_array_resize(&buf->buffer, size);
+
+  say_context_ensure();
+  say_vbo_make_current(buf->vbo);
+  glBufferData(GL_ARRAY_BUFFER,
+               size * buf->buffer.el_size,
+               say_buffer_get_vertex(buf, 0),
+               buf->type);
+}
+
+void say_buffer_update_instance_part(say_buffer *buf, size_t id,
+                                     size_t size) {
+  if (size == 0) return;
+
+  say_context_ensure();
+
+  size_t byte_size = buf->instance_buffer->el_size;
+  say_vbo_make_current(buf->instance_vbo);
+  glBufferSubData(GL_ARRAY_BUFFER,
+                  byte_size * id,
+                  byte_size * size,
+                  say_buffer_get_instance(buf, id));
+}
+
+void say_buffer_update_instance(say_buffer *buf) {
+  say_buffer_update_instance_part(buf, 0,
+                                  buf->instance_buffer->size);
+}
+
+size_t say_buffer_get_instance_size(say_buffer *buf) {
+  return buf->instance_buffer->size;
+}
+
+void say_buffer_resize_instance(say_buffer *buf, size_t size) {
+  mo_array_resize(buf->instance_buffer, size);
+
+  say_context_ensure();
+  say_vbo_make_current(buf->instance_vbo);
+  glBufferData(GL_ARRAY_BUFFER,
+               size * buf->instance_buffer->el_size,
+               say_buffer_get_instance(buf, 0),
+               buf->type);
+}
+
+GLuint say_buffer_get_vbo(say_buffer *buf) {
+  return buf->vbo;
+}
 
-  say_buffer_bind(buf);
-  glBufferDataARB(GL_ARRAY_BUFFER_ARB,
-                  size * say_array_get_elem_size(buf->buffer),
-                  say_buffer_get_vertex(buf, 0),
-                  buf->type);
+GLuint say_buffer_get_instance_vbo(say_buffer *buf) {
+  return buf->instance_vbo;
 }