ray 0.1.1 → 0.2.0

data/ext/say_buffer.h

@@ -2,8 +2,6 @@
 #define SAY_BUFFER_H_
 
 #include "say_basic_type.h"
-#include "say_array.h"
-#include "say_table.h"
 
 #define SAY_STATIC  GL_STATIC_DRAW_ARB
 #define SAY_STREAM  GL_STREAM_DRAW_ARB
@@ -12,21 +10,28 @@
 typedef struct {
   size_t vtype;
 
-  GLuint vbo;
+  GLuint vbo, instance_vbo;
   GLenum type;
 
-  say_table *vaos;
+  mo_hash *vaos;
 
-  say_array *buffer;
+  mo_array buffer, *instance_buffer;
 } say_buffer;
 
 say_buffer *say_buffer_create(size_t vtype, GLenum type, size_t size);
 void say_buffer_free(say_buffer *buf);
 
+bool say_buffer_has_instance(say_buffer *buf);
+
 void *say_buffer_get_vertex(say_buffer *buf, size_t id);
+void *say_buffer_get_instance(say_buffer *buf, size_t id);
 
 void say_buffer_bind(say_buffer *buf);
+void say_buffer_bind_vbo(say_buffer *buf);
+void say_buffer_bind_instance_vbo(say_buffer *buf);
+
 void say_buffer_unbind();
+void say_buffer_unbind_vbo();
 
 void say_buffer_update_part(say_buffer *buf, size_t index, size_t size);
 void say_buffer_update(say_buffer *buf);
@@ -34,4 +39,14 @@ void say_buffer_update(say_buffer *buf);
 size_t say_buffer_get_size(say_buffer *buf);
 void say_buffer_resize(say_buffer *buf, size_t size);
 
+void say_buffer_update_instance_part(say_buffer *buf, size_t index,
+                                     size_t size);
+void say_buffer_update_instance(say_buffer *buf);
+
+size_t say_buffer_get_instance_size(say_buffer *buf);
+void say_buffer_resize_instance(say_buffer *buf, size_t size);
+
+GLuint say_buffer_get_vbo(say_buffer *buf);
+GLuint say_buffer_get_instance_vbo(say_buffer *buf);
+
 #endif

data/ext/say_buffer_renderer.c

@@ -11,7 +11,8 @@ say_buffer_renderer *say_buffer_renderer_create(GLenum type,
 
   renderer->buffer       = say_buffer_create(vtype, type, 256);
   renderer->index_buffer = say_index_buffer_create(type, 128);
-  renderer->drawables = say_array_create(sizeof(say_drawable*), NULL, NULL);
+
+  mo_array_init(&renderer->drawables, sizeof(say_drawable*));
 
   renderer->vtype = vtype;
 
@@ -23,14 +24,15 @@ say_buffer_renderer *say_buffer_renderer_create(GLenum type,
 
 void say_buffer_renderer_free(say_buffer_renderer *renderer) {
   say_buffer_free(renderer->buffer);
-  say_array_free(renderer->drawables);
+  say_index_buffer_free(renderer->index_buffer);
+  mo_array_release(&renderer->drawables);
   free(renderer);
 }
 
 void say_buffer_renderer_clear(say_buffer_renderer *renderer) {
   renderer->current_vertex = 0;
   renderer->current_index  = 0;
-  say_array_resize(renderer->drawables, 0);
+  mo_array_resize(&renderer->drawables, 0);
 }
 
 bool say_buffer_renderer_push(say_buffer_renderer *renderer,
@@ -58,7 +60,7 @@ bool say_buffer_renderer_push(say_buffer_renderer *renderer,
   else if (current_size < index_new_size)
     say_index_buffer_resize(renderer->index_buffer, current_size * 2);
 
-  say_array_push(renderer->drawables, &drawable);
+  mo_array_push(&renderer->drawables, &drawable);
 
   say_drawable_fill_buffer(drawable,
                            say_buffer_get_vertex(renderer->buffer,
@@ -83,14 +85,15 @@ void say_buffer_renderer_update(say_buffer_renderer *renderer) {
 void say_buffer_renderer_render(say_buffer_renderer *renderer,
                                 say_shader *shader) {
   say_buffer_bind(renderer->buffer);
+  say_index_buffer_bind(renderer->index_buffer);
 
   int using_texture = 0;
   say_shader_set_int_id(shader, SAY_TEXTURE_ENABLED_LOC_ID, 0);
 
   size_t current_vertex = 0, current_index = 0;
-  for (size_t i = 0; i < say_array_get_size(renderer->drawables); i++) {
-    say_drawable **e = say_array_get(renderer->drawables, i);
-    say_drawable *drawable = *e;
+  for (size_t i = 0; i < renderer->drawables.size; i++) {
+    say_drawable *drawable = mo_array_get_as(&renderer->drawables, i,
+                                             say_drawable*);
 
     if (!drawable->shader &&
         using_texture != say_drawable_is_textured(drawable)) {

data/ext/say_buffer_renderer.h

@@ -8,7 +8,7 @@
 typedef struct {
   say_buffer       *buffer;
   say_index_buffer *index_buffer;
-  say_array        *drawables;
+  mo_array          drawables;
 
   size_t vtype;
 

data/ext/say_buffer_slice.c

@@ -13,53 +13,51 @@ typedef struct {
 
 typedef struct {
   say_buffer *buf;
-  say_array *ranges;
+  mo_list *ranges;
 } say_global_buffer;
 
-static say_array *say_global_buffers = NULL;
+static mo_array *say_global_buffers = NULL;
 
 static void say_global_buffer_free(say_global_buffer *buf) {
   say_buffer_free(buf->buf);
-  say_array_free(buf->ranges);
+  if (buf->ranges) mo_list_free(buf->ranges);
 }
 
-static say_global_buffer *say_global_buffer_create(say_array *bufs,
+static say_global_buffer *say_global_buffer_create(mo_array *bufs,
                                                    size_t vtype, size_t size) {
   say_global_buffer buffer;
 
   buffer.buf    = say_buffer_create(vtype, SAY_STREAM, size);
-  buffer.ranges = say_array_create(sizeof(say_range), NULL, NULL);
+  buffer.ranges = NULL;
 
-  say_array_push(bufs, &buffer);
+  mo_array_push(bufs, &buffer);
 
-  return say_array_get(bufs, say_array_get_size(bufs) - 1);
+  return mo_array_at(bufs, bufs->size - 1);
 }
 
 
-static void say_global_buffer_array_alloc(say_array **ary) {
-  *ary = say_array_create(sizeof(say_global_buffer),
-                          (say_destructor)say_global_buffer_free,
-                          NULL);
+static void say_global_buffer_array_alloc(mo_array *ary) {
+  mo_array_init(ary, sizeof(say_global_buffer));
+  ary->release = (say_destructor)say_global_buffer_free;
 }
 
-static void say_global_buffer_array_free(say_array **ary) {
-  if (*ary)
-    say_array_free(*ary);
+static void say_global_buffer_array_free(mo_array *ary) {
+  mo_array_release(ary);
 }
 
-static size_t say_global_buffer_add_range_before(say_global_buffer *buf,
-                                                 size_t before, size_t n) {
-  say_range tmp = say_make_range(0, n);
-  say_array_insert(buf->ranges, before, &tmp);
+static size_t say_global_buffer_prepend(say_global_buffer *buf, size_t n) {
+  say_range range = say_make_range(0, n);
+  buf->ranges = mo_list_prepend(buf->ranges, &range);
+  return 0;
+}
 
-  say_range *range = say_array_get(buf->ranges, before);
+static size_t say_global_buffer_insert(mo_list *list, size_t n) {
+  say_range *previous = mo_list_data_ptr(list, say_range);
 
-  if (before != 0) {
-    say_range *prev = say_array_get(buf->ranges, before - 1);
-    range->loc = prev->loc + prev->size;
-  }
+  say_range range = say_make_range(previous->loc + previous->size, n);
+  mo_list_insert(list, &range);
 
-  return range->loc;
+  return range.loc;
 }
 
 static size_t say_global_buffer_find(say_global_buffer *buf, size_t n) {
@@ -67,95 +65,92 @@ static size_t say_global_buffer_find(say_global_buffer *buf, size_t n) {
   if (n > say_buffer_get_size(buf->buf))
     return SAY_MAX_SIZE;
 
-  size_t     ary_size = say_array_get_size(buf->ranges);
-  say_range *first    = say_array_get(buf->ranges, 0);
-
-  /* There's room at the begin of the buffer */
-  if (ary_size == 0 || first->loc >= n) {
-    return say_global_buffer_add_range_before(buf, 0, n);
+  if (!buf->ranges) {
+    buf->ranges = mo_list_create(sizeof(say_range));
+    say_range *range = mo_list_data_ptr(buf->ranges, say_range);
+    *range = say_make_range(0, n);
   }
 
-  say_range *current = first, *next = NULL;
+  say_range *first = mo_list_data_ptr(buf->ranges, say_range);
 
-  for (size_t i = 0; i < ary_size - 1; i++) {
-    next = say_array_get(buf->ranges, i + 1);
+  /* There's room at the begin of the buffer */
+  if (first->loc >= n)
+    return say_global_buffer_prepend(buf, 0);
+
+  mo_list *it = buf->ranges;
+  for (; it->next; it = it->next) { /* stop before last element */
+    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 >= n) {
-      return say_global_buffer_add_range_before(buf, i + 1, n);
-    }
-
-    current = next;
+    if (end - begin >= n)
+      return say_global_buffer_insert(it, n);
   }
 
-  say_range *last = say_array_get(buf->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 + n) < say_buffer_get_size(buf->buf)) {
-    return say_global_buffer_add_range_before(buf, ary_size, n);
+    return say_global_buffer_insert(it, n);
   }
 
   /* Not enough room here */
   return SAY_MAX_SIZE;
 }
 
-static void say_global_buffer_delete_at(say_global_buffer *buf, size_t loc) {
+static void say_global_buffer_delete_at(say_global_buffer *buf, size_t loc,
+                                        size_t range_size) {
   if (!buf)
     return;
 
-  size_t n = 0, size = say_array_get_size(buf->ranges);
-  for (; n < size; n++) {
-    say_range *range = say_array_get(buf->ranges, n);
-    if (range->loc == loc)
-      break;
-  }
+  for (mo_list *it = buf->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 == buf->ranges) buf->ranges = next;
 
-  say_array_delete(buf->ranges, n);
+      return;
+    }
+  }
 }
 
 static void say_global_buffer_reduce_size(say_global_buffer *buf, size_t loc,
-                                          size_t size) {
-  for (say_range *range = say_array_get(buf->ranges, 0); range;
-       say_array_next(buf->ranges, (void**)&range)) {
-    if (range->loc == loc) {
+                                          size_t old_size, size_t size) {
+  for (mo_list *it = buf->ranges; it; it = it->next) {
+    say_range *range = mo_list_data_ptr(it, say_range);
+    if (range->loc == loc && range->size == size) {
       range->size = size;
       return;
     }
   }
 }
 
-static size_t say_global_buffer_reserve(size_t vtype, size_t size, size_t *ret_id) {
+static size_t say_global_buffer_reserve(size_t vtype, size_t size,
+                                        size_t *ret_id) {
   if (!say_global_buffers) {
-    say_global_buffers = say_array_create(sizeof(say_array*),
-                                          (say_destructor)say_global_buffer_array_free,
-                                          (say_creator)say_global_buffer_array_alloc);
+    say_global_buffers = mo_array_create(sizeof(mo_array));
+    say_global_buffers->init    = (mo_init)say_global_buffer_array_alloc;
+    say_global_buffers->release = (mo_release)say_global_buffer_array_free;
   }
 
-  if (say_array_get_size(say_global_buffers) <= vtype) {
-    say_array_resize(say_global_buffers, vtype + 1);
+  if (say_global_buffers->size <= vtype) {
+    mo_array_resize(say_global_buffers, vtype + 1);
   }
 
-  say_array *global_bufs = *(say_array**)say_array_get(say_global_buffers,
-                                                       vtype);
+  mo_array *global_bufs = mo_array_get_ptr(say_global_buffers, vtype, mo_array);
 
-  size_t i = 0;
-  for (say_global_buffer *buf = say_array_get(global_bufs, 0);
-       buf;
-       say_array_next(global_bufs, (void**)&buf)) {
-    size_t res = say_global_buffer_find(buf, size);
+  for (size_t i = 0; i < global_bufs->size; i++) {
+    size_t res = say_global_buffer_find(mo_array_at(global_bufs, i), size);
 
     if (res != SAY_MAX_SIZE) {
       *ret_id = i;
       return res;
     }
-
-    i++;
   }
 
   /* Existing buffers can't store this object, save it somewhere else */
@@ -169,7 +164,7 @@ static size_t say_global_buffer_reserve(size_t vtype, size_t size, size_t *ret_i
   say_global_buffer *buf = say_global_buffer_create(global_bufs,
                                                     vtype,
                                                     buf_size);
-  *ret_id = say_array_get_size(global_bufs) - 1;
+  *ret_id = global_bufs->size - 1;
   return say_global_buffer_find(buf, size);
 }
 
@@ -177,8 +172,7 @@ static say_global_buffer *say_global_buffer_at(size_t vtype, size_t id) {
   if (!say_global_buffers)
     return NULL;
 
-  return say_array_get(*(say_array**)say_array_get(say_global_buffers, vtype),
-                       id);
+  return mo_array_at(mo_array_at(say_global_buffers, vtype), id);
 }
 
 say_buffer_slice *say_buffer_slice_create(size_t vtype, size_t size) {
@@ -191,7 +185,7 @@ say_buffer_slice *say_buffer_slice_create(size_t vtype, size_t size) {
 
 void say_buffer_slice_free(say_buffer_slice *slice) {
   say_global_buffer_delete_at(say_global_buffer_at(slice->vtype, slice->buf_id),
-                              slice->loc);
+                              slice->loc, slice->size);
   free(slice);
 }
 
@@ -203,14 +197,14 @@ void say_buffer_slice_recreate(say_buffer_slice *slice, size_t size) {
   if (size > slice->size) {
     say_global_buffer_delete_at(say_global_buffer_at(slice->vtype,
                                                      slice->buf_id),
-                                slice->loc);
+                                slice->loc, slice->size);
 
     slice->loc = say_global_buffer_reserve(slice->vtype, size, &slice->buf_id);
   }
   else {
     say_global_buffer_reduce_size(say_global_buffer_at(slice->vtype,
                                                        slice->buf_id),
-                                  slice->loc, size);
+                                  slice->loc, slice->size, size);
   }
 
   slice->size = size;
@@ -241,7 +235,7 @@ void say_buffer_slice_bind(say_buffer_slice *slice) {
 
 void say_buffer_slice_clean_up() {
   if (say_global_buffers) {
-    say_array_free(say_global_buffers);
+    mo_array_free(say_global_buffers);
     say_global_buffers = NULL;
   }
 }

data/ext/say_context.c

@@ -17,6 +17,8 @@ static say_context *say_shared_context = NULL;
 static say_thread_variable *say_current_context = NULL;
 static say_thread_variable *say_ensured_context = NULL;
 
+static mo_array *say_all_ensured_contexts = NULL;
+
 static void say_context_create_initial();
 static void say_context_setup(say_context *context);
 static void say_context_setup_states(say_context *context);
@@ -24,18 +26,36 @@ static void say_context_glew_init();
 
 static uint32_t say_context_count = 0;
 
+say_context_config *say_context_get_config() {
+  static say_context_config conf = {
+    24, 0, /* 24 bit depth buffer, no stencil buffer */
+    2, 1,  /* Anything older than 3.x doesn't matter */
+    false, /* Let user call deprecated features */
+    false  /* Disable debugging */
+  };
+
+  return &conf;
+}
+
+void say_context_free_el(void *context) {
+  say_context_free(*(say_context**)context);
+}
+
 say_context *say_context_current() {
   if (!say_current_context) {
-    say_current_context = say_thread_variable_create(NULL);
+    say_current_context = say_thread_variable_create();
   }
 
   return (say_context*)say_thread_variable_get(say_current_context);
 }
 
 void say_context_ensure() {
-  if (!say_ensured_context) {
-    say_ensured_context =
-      say_thread_variable_create((say_destructor)say_context_free);
+  if (!say_ensured_context)
+    say_ensured_context = say_thread_variable_create();
+
+  if (!say_all_ensured_contexts) {
+    say_all_ensured_contexts = mo_array_create(sizeof(say_context*));
+    say_all_ensured_contexts->release = say_context_free_el;
   }
 
   if (!say_context_current()) {
@@ -44,6 +64,7 @@ void say_context_ensure() {
     if (!context) {
       context = say_context_create();
       say_thread_variable_set(say_ensured_context, context);
+      mo_array_push(say_all_ensured_contexts, &context);
     }
 
     say_context_make_current(context);
@@ -103,19 +124,14 @@ static void say_context_create_initial() {
   say_shared_context = (say_context*)malloc(sizeof(say_context));
 
   say_context_setup(say_shared_context);
-  say_context_setup_states(say_shared_context);
-
   say_context_make_current(say_shared_context);
   say_context_glew_init();
 
   /* Identify GLSL version to be used */
   const GLubyte *str = glGetString(GL_SHADING_LANGUAGE_VERSION);
-
-  /* if GLSL 1.40 and GL_EXT_gpu_shader4 are supported */
-  if (__GLEW_EXT_gpu_shader4) {
-    if (str && (str[0] > (GLubyte)'1' || str[2] >= (GLubyte)'4')) {
-      say_shader_enable_new_glsl();
-    }
+  if (str && (str[0] > (GLubyte)'1' || str[2] >= (GLubyte)'3') &&
+      glBindFragDataLocation) {
+    say_shader_enable_new_glsl();
   }
 }
 
@@ -141,23 +157,94 @@ static void say_context_setup_states(say_context *context) {
 }
 
 void say_context_clean_up() {
-  if (say_current_context)
-    say_thread_variable_free(say_current_context);
+  if (say_all_ensured_contexts)
+    mo_array_free(say_all_ensured_contexts);
 
   if (say_ensured_context)
     say_thread_variable_free(say_ensured_context);
 
-  say_current_context = NULL;
-  say_ensured_context = NULL;
+  if (say_current_context)
+    say_thread_variable_free(say_current_context);
+
+  say_current_context      = NULL;
+  say_ensured_context      = NULL;
+  say_all_ensured_contexts = NULL;
 }
 
 static void say_context_glew_init() {
+  /*
+   * Fetch any proc we can.
+   */
+  glewExperimental = true;
   glewInit();
 
-  if (__GLEW_APPLE_vertex_array_object &&
-      !__GLEW_ARB_vertex_array_object) {
-    glBindVertexArray    = glBindVertexArrayAPPLE;
-    glGenVertexArrays    = (PFNGLGENVERTEXARRAYSPROC)glGenVertexArraysAPPLE;
-    glDeleteVertexArrays = glDeleteVertexArraysAPPLE;
-  }
+  /**
+   * Load needed extensions.
+   *
+   * We need to replace pointers for code to work both using OpenGL core
+   * features and extensions.
+   */
+
+#define replace(old, new)                       \
+  if (!new && old)                              \
+    new = old;
+
+  /* Shaders */
+  replace(glCreateShaderObjectARB, glCreateShader);
+  replace(glShaderSourceARB, glShaderSource);
+  replace(glCompileShaderARB, glCompileShader);
+  replace(glGetObjectParameterivARB, glGetShaderiv);
+  replace(glGetObjectParameterivARB, glGetProgramiv);
+  replace(glGetInfoLogARB, glGetShaderInfoLog);
+  replace(glGetInfoLogARB, glGetProgramInfoLog);
+  replace(glGetUniformLocationARB, glGetUniformLocation);
+  replace(glCreateProgramObjectARB, glCreateProgram)
+  replace(glAttachObjectARB, glAttachShader);
+  replace(glDetachObjectARB, glDetachShader);
+  replace(glBindAttribLocationARB, glBindAttribLocation);
+  replace(glBindFragDataLocationEXT, glBindFragDataLocation);
+  replace(glLinkProgramARB, glLinkProgram);
+  replace(glUseProgramObjectARB, glUseProgram);
+  replace(glDeleteObjectARB, glDeleteShader);
+  replace(glDeleteObjectARB, glDeleteProgram);
+  replace(glUniform1iARB, glUniform1i);
+  replace(glUniform1fARB, glUniform1f);
+  replace(glUniform2fARB, glUniform2f);
+  replace(glUniform3fARB, glUniform3f);
+  replace(glUniform1fvARB, glUniform1fv);
+  replace(glUniform2fvARB, glUniform2fv);
+  replace(glUniform3fvARB, glUniform3fv);
+  replace(glUniform4fvARB, glUniform4fv);
+  replace(glUniformMatrix4fvARB, glUniformMatrix4fv);
+
+  /* Buffers */
+  replace(glGenBuffersARB, glGenBuffers);
+  replace(glDeleteBuffersARB, glDeleteBuffersARB);
+  replace(glBindBufferARB, glBindBuffer);
+  replace(glBufferDataARB, glBufferData);
+  replace(glBufferSubDataARB, glBufferSubData);
+  replace(glGetBufferSubDataARB, glGetBufferSubData);
+
+  /* Vertex attribs */
+  replace(glVertexAttribPointerARB, glVertexAttribPointer);
+  replace(glEnableVertexAttribArrayARB, glEnableVertexAttribArray);
+  replace(glVertexAttribDivisorARB, glVertexAttribDivisor);
+  replace(glGetVertexAttribivARB, glGetVertexAttribiv);
+  replace(glDisableVertexAttribArrayARB, glDisableVertexAttribArray);
+
+  /* Framebuffer objects */
+  replace(glGenFramebuffersEXT, glGenFramebuffers);
+  replace(glDeleteFramebuffersEXT, glDeleteFramebuffers);
+  replace(glBindFramebufferEXT, glBindFramebuffer);
+  replace(glFramebufferTexture2DEXT, glFramebufferTexture2D);
+  replace(glFramebufferRenderbufferEXT, glFramebufferRenderbuffer);
+
+  /* Renderbuffer objects */
+  replace(glGenRenderbuffersEXT, glGenRenderbuffers);
+  replace(glDeleteRenderbuffersEXT, glDeleteRenderbuffers);
+  replace(glBindRenderbufferEXT, glBindRenderbuffer);
+  replace(glRenderbufferStorageEXT, glRenderbufferStorage);
+
+  /* Mipmaps */
+  replace(glGenerateMipmapEXT, glGenerateMipmap);
 }