ray 0.2.0 → 0.2.1

data/ext/mo.h

@@ -14,6 +14,15 @@
 #include <assert.h>
 #include <string.h>
 #include <stdio.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if 0
+}
+#endif
 
 /**
  * Function pointer types
@@ -73,35 +82,61 @@ void mo_array_reserve(mo_array *ary, size_t size);
 void mo_array_shrink(mo_array *ary);
 
 /**
- * Doubly linked list.
+ * String.
  */
 
+typedef mo_array mo_string;
+
+void    mo_string_init(mo_string *str);
+void    mo_string_init_from_cstr(mo_string *str, const char *cstr);
+void    mo_string_init_from_buf(mo_string *str, const char *cstr, size_t size);
+void    mo_string_replace(mo_string *str, const char *cstr);
+size_t  mo_string_len(mo_string *str);
+void    mo_string_append(mo_string *str, const char *cstr);
+char   *mo_string_cstr(mo_string *str);
+int     mo_string_cmp(mo_string *a, mo_string *b);
+
+#define mo_string_at(str, i) mo_array_get_as(str, i, char)
+
+typedef struct mo_list_it {
+  struct mo_list_it *prev, *next;
+  uint8_t data[];
+} mo_list_it;
+
 typedef struct mo_list {
-  struct mo_list *prev, *next;
+  mo_list_it *head;
+  mo_list_it *last;
 
   mo_release release;
   mo_copy    copy;
 
   size_t el_size;
-  uint8_t data[];
 } mo_list;
 
+void mo_list_init(mo_list *list, size_t el_size);
+void mo_list_release(mo_list *list);
+
 mo_list *mo_list_create(size_t el_size);
 void mo_list_free(mo_list *list);
 
-mo_list *mo_list_prepend(mo_list *list, void *data);
-mo_list *mo_list_insert(mo_list *list, void *data);
-mo_list *mo_list_delete(mo_list *list);
+void mo_list_prepend(mo_list *list, mo_list_it *it, void *data);
+void mo_list_insert(mo_list *list, mo_list_it *it, void *data);
+void mo_list_delete(mo_list *list, mo_list_it *it);
 
-void mo_list_set(mo_list *list, void *data);
+void mo_list_set(mo_list *list, mo_list_it *it, void *data);
 
-#define mo_list_data_ptr(list, type) ( (type*)list->data)
-#define mo_list_data_as(list, type)  (*(type*)list->data)
+#define mo_list_it_data_ptr(it, type) ( (type*)it->data)
+#define mo_list_it_data_as(it, type)  (*(type*)it->data)
 
 /**
  * Hash table.
  */
 
+typedef struct mo_hash_list {
+  struct mo_hash_list *next;
+  uint8_t data[];
+} mo_hash_list;
+
 typedef struct mo_hash {
   mo_array buffer;
 
@@ -121,9 +156,9 @@ typedef struct mo_hash {
 } mo_hash;
 
 typedef struct mo_hash_it {
-  mo_hash *hash;
-  mo_list *list;
-  size_t   id;
+  mo_hash      *hash;
+  mo_hash_list *list;
+  size_t        id;
 } mo_hash_it;
 
 int mo_hash_of_pointer(void *ptr);
@@ -135,6 +170,9 @@ int mo_hash_u32_cmp(const void *a, const void *b);
 int mo_hash_of_size(void *ptr);
 int mo_hash_size_cmp(const void *a, const void *b);
 
+void mo_hash_init(mo_hash *hash, size_t key_size, size_t el_size);
+void mo_hash_release(mo_hash *hash);
+
 mo_hash *mo_hash_create(size_t key_size, size_t el_size);
 void     mo_hash_free(mo_hash *hash);
 
@@ -169,6 +207,9 @@ void mo_hash_it_next(mo_hash_it *it);
 typedef mo_hash    mo_set;
 typedef mo_hash_it mo_set_it;
 
+#define mo_set_init(set, key_size, el_size) mo_hash_init(set, key_size, el_size)
+#define mo_set_release(set)                 mo_hash_init(set)
+
 #define mo_set_create(size) mo_hash_create(size, 0)
 #define mo_set_free(set)    mo_hash_delete(set)
 
@@ -186,4 +227,8 @@ typedef mo_hash_it mo_set_it;
 #define mo_set_it_val_ptr(it, type) mo_hash_it_key_ptr(it, type)
 #define mo_set_it_val_as(it, type)  mo_hash_it_key_as(it, type)
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* MY OWN HEADER'S GUARD! */

data/ext/polygon.c

@@ -21,6 +21,7 @@ VALUE ray_polygon_alloc(VALUE self) {
 
   say_drawable_set_shader_proc(obj->drawable, ray_drawable_shader_proc);
   say_drawable_set_other_data(obj->drawable, (void*)rb);
+  rb_iv_set(rb, "@shader_attributes", Qnil);
 
   return rb;
 }
@@ -72,6 +73,7 @@ VALUE ray_polygon_line(int argc, VALUE *argv, VALUE self) {
 
   say_drawable_set_shader_proc(line->drawable, ray_drawable_shader_proc);
   say_drawable_set_other_data(line->drawable, (void*)rb);
+  rb_iv_set(rb, "@shader_attributes", Qnil);
 
   return rb;
 }
@@ -104,6 +106,7 @@ VALUE ray_polygon_rectangle(int argc, VALUE *argv, VALUE self) {
 
   say_drawable_set_shader_proc(poly->drawable, ray_drawable_shader_proc);
   say_drawable_set_other_data(poly->drawable, (void*)ret);
+  rb_iv_set(ret, "@shader_attributes", Qnil);
 
   return ret;
 }
@@ -141,6 +144,7 @@ VALUE ray_polygon_circle(int argc, VALUE *argv, VALUE self) {
 
   say_drawable_set_shader_proc(poly->drawable, ray_drawable_shader_proc);
   say_drawable_set_other_data(poly->drawable, (void*)ret);
+  rb_iv_set(ret, "@shader_attributes", Qnil);
 
   return ret;
 }
@@ -179,6 +183,7 @@ VALUE ray_polygon_ellipse(int argc, VALUE *argv, VALUE self) {
 
   say_drawable_set_shader_proc(poly->drawable, ray_drawable_shader_proc);
   say_drawable_set_other_data(poly->drawable, (void*)rb);
+  rb_iv_set(rb, "@shader_attributes", Qnil);
 
   return rb;
 }

data/ext/say_buffer.c

@@ -5,24 +5,15 @@ static bool say_has_vao() {
     GLEW_VERSION_3_0;
 }
 
-static GLuint say_current_vbo = 0;
-static say_context *say_vbo_last_context = NULL;
-
 static void say_vbo_make_current(GLuint vbo) {
   say_context *context = say_context_current();
 
-  if (context != say_vbo_last_context ||
-      vbo != say_current_vbo) {
-    say_current_vbo      = vbo;
-    say_vbo_last_context = context;
-
+  if (context->vbo != vbo) {
     glBindBuffer(GL_ARRAY_BUFFER, vbo);
+    context->vbo = vbo;
   }
 }
 
-static GLuint       say_current_vao      = 0;
-static say_context *say_vao_last_context = NULL;
-
 typedef struct {
   GLuint vao;
   say_context *context;
@@ -31,51 +22,51 @@ typedef struct {
 static void say_vao_make_current(GLuint vao) {
   say_context *context = say_context_current();
 
-  if (context != say_vao_last_context ||
-      vao != say_current_vao) {
-    say_current_vao      = vao;
-    say_vao_last_context = context;
-
+  if (context->vao != vao) {
     glBindVertexArray(vao);
-
     say_index_buffer_rebind();
+
+    context->vao = vao;
   }
 }
 
-static say_buffer  *say_current_buffer      = NULL;
-static say_context *say_buffer_last_context = NULL;
-
 static void say_buffer_setup_pointer(say_buffer *buf);
 
 static void say_buffer_make_current(say_buffer *buf) {
   say_context *context = say_context_current();
 
-  if (context != say_buffer_last_context ||
-      buf != say_current_buffer) {
-    say_current_buffer      = buf;
-    say_buffer_last_context = context;
-
+  if (context->buffer_obj != buf) {
     say_buffer_setup_pointer(buf);
+    context->buffer_obj = buf;
   }
 }
 
 static void say_vbo_will_delete(GLuint vbo) {
-  if (vbo == say_current_vbo)
-    say_current_vbo = 0;
+  mo_array *contexts = say_context_get_all();
+  for (size_t i = 0; i < contexts->size; i++) {
+    say_context *context = mo_array_get_as(contexts, i, say_context*);
+    if (context->vbo == vbo)
+      context->vbo = 0;
+  }
 }
 
 static void say_buffer_will_delete(say_buffer *buf) {
-  if (buf == say_current_buffer)
-    say_current_buffer = NULL;
+  mo_array *contexts = say_context_get_all();
+  for (size_t i = 0; i < contexts->size; i++) {
+    say_context *context = mo_array_get_as(contexts, i, say_context*);
+    if (context->buffer_obj == buf)
+      context->buffer_obj = NULL;
+  }
 }
 
 static void say_buffer_delete_vao_pair(say_vao_pair *pair) {
-  /* TODO: finding out if the context is still alive, to avoid leaks */
-  if (say_vao_last_context == pair->context && say_current_vao == pair->vao) {
-    say_current_vao = 0;
-    glDeleteVertexArrays(1, &pair->vao);
+  say_context *context = say_context_current();
 
+  if (context == pair->context && context->vao == pair->vao) {
+    glDeleteVertexArrays(1, &pair->vao);
     say_index_buffer_rebind();
+
+    context->vao = 0;
   }
 }
 
@@ -222,7 +213,6 @@ say_buffer *say_buffer_create(size_t vtype, GLenum type, size_t size) {
     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;

data/ext/say_buffer_slice.c

@@ -13,29 +13,28 @@ typedef struct {
 
 typedef struct {
   say_buffer *buf;
-  mo_list *ranges;
+  mo_list     ranges;
 } say_global_buffer;
 
 static mo_array *say_global_buffers = NULL;
 
 static void say_global_buffer_free(say_global_buffer *buf) {
   say_buffer_free(buf->buf);
-  if (buf->ranges) mo_list_free(buf->ranges);
+  mo_list_release(&buf->ranges);
 }
 
 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 = NULL;
+  buffer.buf = say_buffer_create(vtype, SAY_STREAM, size);
+  mo_list_init(&buffer.ranges, sizeof(say_range));
 
   mo_array_push(bufs, &buffer);
 
   return mo_array_at(bufs, bufs->size - 1);
 }
 
-
 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;
@@ -47,15 +46,16 @@ static void say_global_buffer_array_free(mo_array *ary) {
 
 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);
+  mo_list_prepend(&buf->ranges, buf->ranges.head, &range);
   return 0;
 }
 
-static size_t say_global_buffer_insert(mo_list *list, size_t n) {
-  say_range *previous = mo_list_data_ptr(list, say_range);
+static size_t say_global_buffer_insert(mo_list *list, mo_list_it *it,
+                                       size_t n) {
+  say_range *previous = mo_list_it_data_ptr(it, say_range);
 
   say_range range = say_make_range(previous->loc + previous->size, n);
-  mo_list_insert(list, &range);
+  mo_list_insert(list, it, &range);
 
   return range.loc;
 }
@@ -65,36 +65,34 @@ 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;
 
-  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);
+  if (!buf->ranges.head) {
+    return say_global_buffer_prepend(buf, n);
   }
 
-  say_range *first = mo_list_data_ptr(buf->ranges, say_range);
+  say_range *first = mo_list_it_data_ptr(buf->ranges.head, say_range);
 
   /* There's room at the begin of the buffer */
   if (first->loc >= n)
-    return say_global_buffer_prepend(buf, 0);
+    return say_global_buffer_prepend(buf, n);
 
-  mo_list *it = buf->ranges;
+  mo_list_it *it = buf->ranges.head;
   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);
+    say_range *current = mo_list_it_data_ptr(it, say_range);
+    say_range *next    = mo_list_it_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_insert(it, n);
+      return say_global_buffer_insert(&buf->ranges, it, n);
   }
 
-  say_range *last = mo_list_data_ptr(it, say_range);
+  say_range *last = mo_list_it_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_insert(it, n);
+    return say_global_buffer_insert(&buf->ranges, it, n);
   }
 
   /* Not enough room here */
@@ -106,14 +104,10 @@ static void say_global_buffer_delete_at(say_global_buffer *buf, size_t loc,
   if (!buf)
     return;
 
-  for (mo_list *it = buf->ranges; it; it = it->next) {
-    say_range *range = mo_list_data_ptr(it, say_range);
+  for (mo_list_it *it = buf->ranges.head; it; it = it->next) {
+    say_range *range = mo_list_it_data_ptr(it, say_range);
     if (range->loc == loc && range->size == range_size) {
-      mo_list *next = it->next;
-      mo_list_delete(it);
-
-      if (it == buf->ranges) buf->ranges = next;
-
+      mo_list_delete(&buf->ranges, it);
       return;
     }
   }
@@ -121,8 +115,8 @@ static void say_global_buffer_delete_at(say_global_buffer *buf, size_t loc,
 
 static void say_global_buffer_reduce_size(say_global_buffer *buf, size_t 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);
+  for (mo_list_it *it = buf->ranges.head; it; it = it->next) {
+    say_range *range = mo_list_it_data_ptr(it, say_range);
     if (range->loc == loc && range->size == size) {
       range->size = size;
       return;

data/ext/say_context.c

@@ -22,6 +22,7 @@ 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);
+static void say_context_setup_cache(say_context *context);
 static void say_context_glew_init();
 
 static uint32_t say_context_count = 0;
@@ -49,6 +50,15 @@ say_context *say_context_current() {
   return (say_context*)say_thread_variable_get(say_current_context);
 }
 
+mo_array *say_context_get_all() {
+  if (!say_all_ensured_contexts) {
+    say_all_ensured_contexts = mo_array_create(sizeof(say_context*));
+    say_all_ensured_contexts->release = say_context_free_el;
+  }
+
+  return say_all_ensured_contexts;
+}
+
 void say_context_ensure() {
   if (!say_ensured_context)
     say_ensured_context = say_thread_variable_create();
@@ -80,6 +90,7 @@ say_context *say_context_create() {
 
   say_context_setup(context);
   say_context_setup_states(context);
+  say_context_setup_cache(context);
 
   return context;
 }
@@ -95,6 +106,7 @@ say_context *say_context_create_for_window(say_window *window) {
   context->context = say_imp_context_create_for_window(shared,
                                                        window->win);
   say_context_setup_states(context);
+  say_context_setup_cache(context);
 
   return context;
 }
@@ -156,6 +168,32 @@ static void say_context_setup_states(say_context *context) {
   glReadBuffer(GL_FRONT);
 }
 
+static void say_context_setup_cache(say_context *context) {
+  context->texture_unit = 0;
+  for (size_t i = 0; i < 32; i++)
+    context->textures[i] = 0;
+
+  context->vao        = 0;
+  context->vbo        = 0;
+  context->buffer_obj = NULL;
+
+  context->program = 0;
+
+  context->ibo = 0;
+
+  context->pack_pbo   = 0;
+  context->unpack_pbo = 0;
+
+  context->target = NULL;
+
+  context->blend_enabled = false;
+  context->src_blend_func = GL_SRC_ALPHA;
+  context->dst_blend_func = GL_ONE_MINUS_SRC_ALPHA;
+
+  context->fbo = 0;
+  context->rbo = 0;
+}
+
 void say_context_clean_up() {
   if (say_all_ensured_contexts)
     mo_array_free(say_all_ensured_contexts);