ray 0.1.1 → 0.2.0

data/ext/say_image_target.h

@@ -5,8 +5,9 @@
 #include "say_image.h"
 
 typedef struct {
-  GLuint fbo, rbo;
-  say_image *img;
+  mo_hash    *fbos;
+  GLuint      rbo;
+  say_image  *img;
   say_target *target;
 } say_image_target;
 

data/ext/say_index_buffer.c

@@ -11,7 +11,7 @@ static void say_ibo_make_current(GLuint ibo) {
     say_current_ibo      = ibo;
     say_ibo_last_context = context;
 
-    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ibo);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
   }
 }
 
@@ -26,15 +26,15 @@ say_index_buffer *say_index_buffer_create(GLenum type, size_t size) {
 
   say_index_buffer *buf = malloc(sizeof(say_index_buffer));
 
-  glGenBuffersARB(1, &buf->ibo);
+  glGenBuffers(1, &buf->ibo);
   buf->type = type;
 
-  buf->buffer = say_array_create(sizeof(GLuint), NULL, NULL);
-  say_array_resize(buf->buffer, size);
+  mo_array_init(&buf->buffer, sizeof(GLuint));
+  mo_array_resize(&buf->buffer, size);
 
   say_ibo_make_current(buf->ibo);
-  glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, size * sizeof(GLuint),
-                  NULL, type);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, size * sizeof(GLuint),
+               NULL, type);
 
   return buf;
 }
@@ -43,8 +43,8 @@ void say_index_buffer_free(say_index_buffer *buf) {
   say_context_ensure();
 
   say_ibo_will_delete(buf->ibo);
-  glDeleteBuffersARB(1, &buf->ibo);
-  say_array_free(buf->buffer);
+  glDeleteBuffers(1, &buf->ibo);
+  mo_array_release(&buf->buffer);
   free(buf);
 }
 
@@ -53,38 +53,50 @@ void say_index_buffer_bind(say_index_buffer *buf) {
   say_ibo_make_current(buf->ibo);
 }
 
-void say_index_buffer_unbind(say_index_buffer *buf) {
+void say_index_buffer_unbind() {
   say_context_ensure();
   say_ibo_make_current(0);
 }
 
+void say_index_buffer_rebind() {
+  if (say_ibo_last_context == say_context_current())
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, say_current_ibo);
+}
+
 void say_index_buffer_update_part(say_index_buffer *buf, size_t index,
                                   size_t size) {
   say_context_ensure();
 
   say_index_buffer_bind(buf);
-  glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
-                     index * sizeof(GLuint),
-                     size * sizeof(GLuint),
-                     say_array_get(buf->buffer, index));
+  glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,
+                  index * sizeof(GLuint),
+                  size * sizeof(GLuint),
+                  mo_array_at(&buf->buffer, index));
 }
 
 void say_index_buffer_update(say_index_buffer *buf) {
-  say_index_buffer_update_part(buf, 0, say_array_get_size(buf->buffer));
+  say_index_buffer_update_part(buf, 0, buf->buffer.size);
 }
 
 size_t say_index_buffer_get_size(say_index_buffer *buf) {
-  return say_array_get_size(buf->buffer);
+  return buf->buffer.size;
 }
 
 void say_index_buffer_resize(say_index_buffer *buf, size_t size) {
   say_context_ensure();
 
-  say_array_resize(buf->buffer, size);
-  glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, size * sizeof(GLuint), NULL,
-                  buf->type);
+  mo_array_resize(&buf->buffer, size);
+  mo_array_shrink(&buf->buffer);
+
+  say_index_buffer_bind(buf);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, size * sizeof(GLuint),
+               mo_array_at(&buf->buffer, 0), buf->type);
 }
 
 GLuint *say_index_buffer_get(say_index_buffer *buf, size_t i) {
-  return say_array_get(buf->buffer, i);
+  return mo_array_get_ptr(&buf->buffer, i, GLuint);
+}
+
+GLuint say_index_buffer_get_ibo(say_index_buffer *buf) {
+  return buf->ibo;
 }

data/ext/say_index_buffer.h

@@ -2,13 +2,12 @@
 #define SAY_INDEX_BUFFER_H_
 
 #include "say_basic_type.h"
-#include "say_array.h"
 
 typedef struct {
   GLuint ibo;
   GLenum type;
 
-  say_array *buffer;
+  mo_array buffer;
 } say_index_buffer;
 
 say_index_buffer *say_index_buffer_create(GLenum type, size_t size);
@@ -16,6 +15,7 @@ void say_index_buffer_free(say_index_buffer *buf);
 
 void say_index_buffer_bind(say_index_buffer *buf);
 void say_index_buffer_unbind();
+void say_index_buffer_rebind();
 
 void say_index_buffer_update_part(say_index_buffer *buf, size_t index,
                                   size_t size);
@@ -26,4 +26,6 @@ void   say_index_buffer_resize(say_index_buffer *buf, size_t size);
 
 GLuint *say_index_buffer_get(say_index_buffer *buf, size_t i);
 
+GLuint say_index_buffer_get_ibo(say_index_buffer *buf);
+
 #endif

data/ext/say_index_buffer_slice.c

@@ -12,15 +12,15 @@ typedef struct {
 
 typedef struct {
   say_index_buffer *buf;
-  say_array        *ranges;
+  mo_list          *ranges;
 } say_global_ibo;
 
-static say_array *say_index_buffers = NULL;
+static mo_array *say_index_buffers = NULL;
 
 static say_global_ibo say_global_ibo_create(size_t size) {
   say_global_ibo ret;
   ret.buf    = say_index_buffer_create(SAY_STREAM, size);
-  ret.ranges = say_array_create(sizeof(say_range), NULL, NULL);
+  ret.ranges = NULL;
 
   return ret;
 }
@@ -29,90 +29,95 @@ static void say_global_ibo_free(void *data) {
   say_global_ibo *ibo = (say_global_ibo*)data;
 
   say_index_buffer_free(ibo->buf);
-  say_array_free(ibo->ranges);
+  if (ibo->ranges) mo_list_free(ibo->ranges);
 }
 
 static say_global_ibo *say_global_ibo_at(size_t index) {
   if (!say_index_buffers)
     return NULL;
-  return say_array_get(say_index_buffers, index);
+  return mo_array_at(say_index_buffers, index);
 }
 
-static size_t say_global_ibo_insert(say_global_ibo *ibo, size_t i,
+static bool say_global_ibo_fit_into(say_global_ibo *ibo, size_t used,
                                     size_t size) {
-  say_range tmp = say_make_range(0, size);
-  say_array_insert(ibo->ranges, i, &tmp);
+  size_t buffer_size = say_index_buffer_get_size(ibo->buf);
+
+  if (used + size < buffer_size)
+    return true;
+  else if (used + size < SAY_BUFFER_MAX_SIZE &&
+           buffer_size <= SAY_BUFFER_MAX_SIZE) {
+    size_t sought_size = used + size;
+    size_t right_size  = buffer_size;
 
-  say_range *range = say_array_get(ibo->ranges, i);
+    while (right_size < sought_size) right_size *= 2;
 
-  if (i != 0) {
-    say_range *prev = say_array_get(ibo->ranges, i - 1);
-    range->loc = prev->loc + prev->size;
+    say_index_buffer_resize(ibo->buf, right_size);
+    return true;
   }
+  else
+    return false;
+}
+
+static size_t say_global_ibo_prepend(say_global_ibo *ibo, size_t size) {
+  say_range range = say_make_range(0, size);
+  ibo->ranges = mo_list_prepend(ibo->ranges, &range);
+  return 0;
+}
+
+static size_t say_global_ibo_insert(mo_list *list, size_t size) {
+  say_range *range = mo_list_data_ptr(list, say_range);
+  say_range tmp = say_make_range(range->loc + range->size, size);
 
-  return range->loc;
+  mo_list_insert(list, &tmp);
+  return tmp.loc;
 }
 
 static size_t say_global_ibo_find_in(say_global_ibo *ibo, size_t size) {
-  size_t buffer_size = say_index_buffer_get_size(ibo->buf);
+  if (!ibo->ranges && say_global_ibo_fit_into(ibo, 0, size)) {
+    ibo->ranges = mo_list_create(sizeof(say_range));
+    say_range *range = mo_list_data_ptr(ibo->ranges, say_range);
+    *range = say_make_range(0, size);
+    return 0;
+  }
 
-  size_t     ary_size = say_array_get_size(ibo->ranges);
-  say_range *first    = say_array_get(ibo->ranges, 0);
+  say_range *first = mo_list_data_ptr(ibo->ranges, say_range);
 
   /* There's room at the begin of the buffer */
-  if (ary_size == 0 || first->loc >= size) {
-    return say_global_ibo_insert(ibo, 0, size);
+  if (first->loc >= size) {
+    return say_global_ibo_prepend(ibo, size);
   }
 
-  say_range *current = first, *next = NULL;
-
-  for (size_t i = 0; i < ary_size - 1; i++) {
-    next = say_array_get(ibo->ranges, i + 1);
+  mo_list *it = ibo->ranges;
+  for (; it->next; it = it->next) {
+    say_range *current = mo_list_data_ptr(it, say_range);
+    say_range *next    = mo_list_data_ptr(it->next, say_range);
 
     size_t begin = current->loc + current->size;
     size_t end   = next->loc;
 
     /* There's enough room between those two elements */
-    if (end - begin >= size) {
-      return say_global_ibo_insert(ibo, i + 1, size);
-    }
-
-    current = next;
+    if (end - begin >= size)
+      return say_global_ibo_insert(it, size);
   }
 
-  say_range *last = say_array_get(ibo->ranges, ary_size - 1);
+  say_range *last = mo_list_data_ptr(it, say_range);
 
   /* There's enough room at the end of the buffer */
-  if ((last->loc + last->size + size) < say_index_buffer_get_size(ibo->buf)) {
-    return say_global_ibo_insert(ibo, ary_size, size);
-  }
-
-  /* Not enough room here. But perhaps we can make some? */
-  if (buffer_size < SAY_BUFFER_MAX_SIZE && size <= SAY_BUFFER_MAX_SIZE) {
-    size_t sought_size = last->loc + last->size + size;
-    size_t right_size = say_index_buffer_get_size(ibo->buf);
-
-    while (right_size < sought_size)
-      right_size *= 2;
-
-    say_index_buffer_resize(ibo->buf, right_size);
-    return say_global_ibo_insert(ibo, ary_size, size);
-  }
+  if (say_global_ibo_fit_into(ibo, last->loc + last->size, size))
+    return say_global_ibo_insert(it, size);
   else
     return SAY_MAX_SIZE;
 }
 
 static size_t say_global_ibo_find(size_t size, size_t *buf_id) {
   if (!say_index_buffers) {
-    say_index_buffers = say_array_create(sizeof(say_global_ibo),
-                                         say_global_ibo_free,
-                                         NULL);
+    say_index_buffers = mo_array_create(sizeof(say_global_ibo));
+    say_index_buffers->release = say_global_ibo_free;
   }
 
-  size_t i = 0;
-  for (say_global_ibo *ibo = say_array_get(say_index_buffers, 0);
-       ibo;
-       say_array_next(say_index_buffers, (void**)&ibo)) {
+  for (size_t i = 0; i < say_index_buffers->size; i++) {
+    say_global_ibo *ibo = mo_array_at(say_index_buffers, 0);
+
     size_t loc;
     if ((loc = say_global_ibo_find_in(ibo, size)) != SAY_MAX_SIZE) {
       *buf_id = i;
@@ -132,34 +137,35 @@ static size_t say_global_ibo_find(size_t size, size_t *buf_id) {
   }
 
   say_global_ibo ibo = say_global_ibo_create(buf_size);
-  say_array_push(say_index_buffers, &ibo);
+  mo_array_push(say_index_buffers, &ibo);
 
-  *buf_id = say_array_get_size(say_index_buffers) - 1;
+  *buf_id = say_index_buffers->size - 1;
   return say_global_ibo_find_in(say_global_ibo_at(*buf_id), size);
 }
 
-static void say_global_ibo_delete_at(say_global_ibo *ibo, size_t loc) {
+static void say_global_ibo_delete_at(say_global_ibo *ibo, size_t loc,
+                                     size_t range_size) {
   if (!ibo)
     return;
 
-  size_t n = 0, size = say_array_get_size(ibo->ranges);
-  for (; n < size; n++) {
-    say_range *range = say_array_get(ibo->ranges, n);
-    if (range->loc == loc)
-      break;
-  }
+  for (mo_list *it = ibo->ranges; it; it = it->next) {
+    say_range *range = mo_list_data_ptr(it, say_range);
+    if (range->loc == loc && range->size == range_size) {
+      mo_list *next = it->next;
+      mo_list_delete(it);
 
-  if (n == size)
-    return; /* Element could not be found */
+      if (it == ibo->ranges) ibo->ranges = next;
 
-  say_array_delete(ibo->ranges, n);
+      return;
+    }
+  }
 }
 
 static void say_global_ibo_reduce_size(say_global_ibo *ibo, size_t loc,
-                                       size_t size) {
-  for (say_range *range = say_array_get(ibo->ranges, 0); range;
-       say_array_next(ibo->ranges, (void**)&range)) {
-    if (range->loc == loc) {
+                                       size_t old_size, size_t size) {
+  for (mo_list *it = ibo->ranges; it; it = it->next) {
+    say_range *range = mo_list_data_ptr(it, say_range);
+    if (range->loc == loc && range->size == old_size) {
       range->size = size;
       return;
     }
@@ -180,19 +186,21 @@ say_index_buffer_slice *say_index_buffer_slice_create(size_t size) {
 }
 
 void say_index_buffer_slice_free(say_index_buffer_slice *slice) {
-  say_global_ibo_delete_at(say_global_ibo_at(slice->buf_id), slice->loc);
+  say_global_ibo_delete_at(say_global_ibo_at(slice->buf_id), slice->loc,
+                           slice->size);
   free(slice);
 }
 
 void say_index_buffer_slice_recreate(say_index_buffer_slice *slice,
                                      size_t size) {
  if (size > slice->size) {
-   say_global_ibo_delete_at(say_global_ibo_at(slice->buf_id), slice->loc);
+   say_global_ibo_delete_at(say_global_ibo_at(slice->buf_id), slice->loc,
+                            slice->size);
    slice->loc = say_global_ibo_find(size, &slice->buf_id);
   }
  else {
    say_global_ibo_reduce_size(say_global_ibo_at(slice->buf_id),
-                                 slice->loc, size);
+                              slice->loc, slice->size, size);
  }
 
   slice->size = size;
@@ -221,7 +229,7 @@ void say_index_buffer_slice_bind(say_index_buffer_slice *slice) {
 
 void say_index_buffer_slice_clean_up() {
   if (say_index_buffers) {
-    say_array_free(say_index_buffers);
+    mo_array_free(say_index_buffers);
     say_index_buffers = NULL;
   }
 }

data/ext/say_music.c

@@ -78,12 +78,12 @@ static void *say_music_playback_thread(say_music *music) {
         }
       }
     }
-    
+
     /* sleep for 0.25s */
 #ifdef SAY_WIN
     Sleep(250);
 #else
-    usleep(250 * 1000); 
+    usleep(250 * 1000);
 #endif
   }
 
@@ -116,7 +116,9 @@ say_music *say_music_create() {
 void say_music_free(say_music *music) {
   music->continue_running = false;
 
+#ifndef SAY_WIN
   say_thread_join(music->thread);
+#endif
   say_thread_free(music->thread);
 
   alSourceStop(music->src->src);

data/ext/say_osx.h

@@ -2,8 +2,9 @@
 
 #import <Cocoa/Cocoa.h>
 
+#include "mo.h"
+
 struct say_event;
-struct say_array;
 struct say_image;
 
 void say_osx_flip_pool();
@@ -31,7 +32,7 @@ void say_osx_flip_pool();
   NSWindow *window;
   NSOpenGLView *view;
 
-  struct say_array *events;
+  mo_array events;
 
   BOOL allow_close;
 

data/ext/say_osx_context.h

@@ -8,6 +8,8 @@
   static NSOpenGLPixelFormat *format = nil;
 
   if (!format) {
+    say_context_config *conf = say_context_get_config();
+
     NSOpenGLPixelFormatAttribute attr[] = {
       NSOpenGLPFAClosestPolicy,
       NSOpenGLPFADoubleBuffer,
@@ -16,11 +18,43 @@
       NSOpenGLPFAColorSize, 24,
       NSOpenGLPFAAlphaSize, 8,
 
-      NSOpenGLPFADepthSize, 24,
+      /*
+       * Next elements must be set depending on user configuration.
+       */
+
+      0, 0, /* depth */
+      0, 0, /* stencil */
+
+      0, 0, /* profile */
 
-      0
+      0 /* terminator */
     };
 
+    size_t i = 7;
+
+    if (conf->depth_size) {
+      attr[i + 0] = NSOpenGLPFADepthSize;
+      attr[i + 1] = conf->depth_size;
+
+      i += 2;
+    }
+
+    if (conf->stencil_size) {
+      attr[i + 0] = NSOpenGLPFAStencilSize;
+      attr[i + 1] = conf->stencil_size;
+
+      i += 2;
+    }
+
+#ifdef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER
+    if (conf->core_profile) { /* OpenGL 3.2! */
+      attr[i + 0] = NSOpenGLPFAOpenGLProfile;
+      attr[i + 1] = NSOpenGLProfileVersion3_2Core;
+
+      i += 2;
+    }
+#endif
+
     format = [[NSOpenGLPixelFormat alloc] initWithAttributes:attr];
   }
 
@@ -62,10 +96,9 @@
 }
 
 - (void)dealloc {
-  NSAutoreleasePool *pool = [NSAutoreleasePool new];
+  say_osx_flip_pool();
   [context release];
   [super dealloc];
-  [pool drain];
 }
 
 @end