ray 0.2.0 → 0.2.1

data/ext/say_context.h

@@ -18,6 +18,29 @@ struct say_window;
 typedef struct {
   uint32_t count;
   say_imp_context context;
+
+  int    texture_unit;
+  GLuint textures[32];
+
+  GLuint  vao;
+  GLuint  vbo;
+  void   *buffer_obj;
+
+  GLuint program;
+
+  GLuint ibo;
+
+  GLuint pack_pbo;
+  GLuint unpack_pbo;
+
+  void *target;
+
+  bool blend_enabled;
+  GLenum src_blend_func;
+  GLenum dst_blend_func;
+
+  GLuint fbo;
+  GLuint rbo;
 } say_context;
 
 say_context_config *say_context_get_config();
@@ -27,6 +50,7 @@ void say_context_free_el(void *context);
 void say_context_ensure();
 
 say_context *say_context_current();
+mo_array    *say_context_get_all();
 
 say_context *say_context_create_for_window(struct say_window *window);
 say_context *say_context_create();

data/ext/say_drawable.c

@@ -8,55 +8,52 @@ static void say_drawable_update_matrix(say_drawable *drawable) {
     drawable->matrix_proc(drawable->data, drawable->matrix);
   }
   else {
-    say_matrix_reset(drawable->matrix);
-
-    say_matrix_translate_by(drawable->matrix,
-                            drawable->pos.x,
-                            drawable->pos.y,
-                            drawable->z_order);
-    say_matrix_rotate(drawable->matrix, drawable->angle, 0, 0, 1);
-    say_matrix_scale_by(drawable->matrix, drawable->scale.x, drawable->scale.y,
-                      1);
-    say_matrix_translate_by(drawable->matrix,
-                            -drawable->origin.x,
-                            -drawable->origin.y,
-                            0);
+    say_matrix_set_transformation(drawable->matrix,
+                                  drawable->origin,
+                                  drawable->pos, drawable->z_order,
+                                  drawable->scale,
+                                  drawable->angle);
   }
 
   drawable->matrix_updated = true;
 }
 
-static say_context *say_blend_last_context = NULL;
-static say_blend_mode say_last_blend = SAY_BLEND_NO;
-
 static void say_drawable_enable_blend_mode(say_blend_mode mode) {
   say_context *context = say_context_current();
 
-  if (mode != say_last_blend || context != say_blend_last_context) {
-    if (context != say_blend_last_context)
-      say_last_blend = SAY_BLEND_NO;
+  bool must_be_enabled = mode != SAY_BLEND_NO;
+  if (context->blend_enabled != must_be_enabled) {
+    context->blend_enabled = must_be_enabled;
 
-    if (mode == SAY_BLEND_NO)
-      glDisable(GL_BLEND);
-    else if (say_last_blend == SAY_BLEND_NO)
+    if (must_be_enabled)
       glEnable(GL_BLEND);
-
-    switch (mode) {
-    case SAY_BLEND_NO:
-      break;
-    case SAY_BLEND_ALPHA:
-      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-      break;
-    case SAY_BLEND_ADD:
-      glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-      break;
-    case SAY_BLEND_MULTIPLY:
-      glBlendFunc(GL_DST_COLOR, GL_ZERO);
-      break;
+    else {
+      glDisable(GL_BLEND);
+      return; /* No need to check depth function */
     }
+  }
 
-    say_last_blend         = mode;
-    say_blend_last_context = context;
+  GLenum src, dst;
+  switch (mode) {
+  case SAY_BLEND_ALPHA:
+    src = GL_SRC_ALPHA;
+    dst = GL_ONE_MINUS_SRC_ALPHA;
+    break;
+  case SAY_BLEND_ADD:
+    src = GL_SRC_ALPHA;
+    dst = GL_ONE;
+    break;
+  case SAY_BLEND_MULTIPLY:
+    src = GL_DST_COLOR;
+    dst = GL_ZERO;
+    break;
+  default: return;
+  }
+
+  if (context->src_blend_func != src || context->dst_blend_func != dst) {
+    glBlendFunc(src, dst);
+    context->src_blend_func = src;
+    context->dst_blend_func = dst;
   }
 }
 
@@ -410,6 +407,17 @@ say_matrix *say_drawable_get_matrix(say_drawable *drawable) {
   return drawable->matrix;
 }
 
+say_matrix *say_drawable_get_default_matrix(say_drawable *drawable) {
+  say_matrix *ret = say_matrix_identity();
+  say_matrix_set_transformation(ret,
+                                drawable->origin,
+                                drawable->pos, drawable->z_order,
+                                drawable->scale,
+                                drawable->angle);
+
+  return ret;
+}
+
 void say_drawable_set_matrix(say_drawable *drawable, say_matrix *matrix) {
   if (matrix) {
     drawable->custom_matrix = true;
@@ -428,7 +436,6 @@ say_vector3 say_drawable_transform(say_drawable *drawable, say_vector3 point) {
   return say_matrix_transform(drawable->matrix, point);
 }
 
-
 say_blend_mode say_drawable_get_blend_mode(say_drawable *drawable) {
   return drawable->blend_mode;
 }

data/ext/say_drawable.h

@@ -112,6 +112,7 @@ float say_drawable_get_z(say_drawable *drawable);
 float say_drawable_get_angle(say_drawable *drawable);
 
 say_matrix *say_drawable_get_matrix(say_drawable *drawable);
+say_matrix *say_drawable_get_default_matrix(say_drawable *drawable);
 void say_drawable_set_matrix(say_drawable *drawable, say_matrix *matrix);
 say_vector3 say_drawable_transform(say_drawable *drawable, say_vector3 point);
 

data/ext/say_image.c

@@ -5,31 +5,37 @@
 #define STB_IMAGE_WRITE_IMPLEMENTATION 1
 #include "stb_image_write.h"
 
-static GLuint say_current_texture = 0;
-static say_context *say_texture_last_context = NULL;
-
-static void say_texture_make_current(GLuint texture) {
+static void say_texture_make_current(GLuint texture, int unit) {
   say_context *context = say_context_current();
 
-  if (texture != say_current_texture ||
-      context != say_texture_last_context) {
-    say_texture_last_context = context;
-    say_current_texture = texture;
+  if (context->texture_unit != unit) {
+    glActiveTexture(GL_TEXTURE0 + unit);
+    context->texture_unit = unit;
+  }
 
+  if (context->textures[unit] != texture) {
     glBindTexture(GL_TEXTURE_2D, texture);
+    context->textures[unit] = texture;
   }
 }
 
 static void say_texture_will_delete(GLuint texture) {
-  if (say_current_texture == texture)
-    say_current_texture = 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*);
+
+    for (size_t i = 0; i < SAY_MAX_TEXTURE_UNIT; i++) {
+      if (context->textures[i] == texture)
+        context->textures[i] = 0;
+    }
+  }
 }
 
 static void say_image_update_buffer(say_image *img) {
   if (img->buffer_updated)
     return;
 
-  say_texture_make_current(img->texture);
+  say_texture_make_current(img->texture, 0);
   say_pixel_bus_unbind_pack();
   glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 img->pixels);
@@ -138,7 +144,7 @@ bool say_image_create_with_size(say_image *img, size_t w, size_t h) {
 
     img->pixels = malloc(sizeof(say_color) * w * h);
 
-    say_texture_make_current(img->texture);
+    say_texture_make_current(img->texture, 0);
     say_pixel_bus_unbind_unpack();
     glGetError(); /* Ignore potential previous errors */
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0,
@@ -289,7 +295,7 @@ void say_image_set_smooth(say_image *img, bool val) {
     img->smooth = val;
 
     say_context_ensure();
-    say_texture_make_current(img->texture);
+    say_texture_make_current(img->texture, 0);
 
     GLenum interp = val ? GL_LINEAR : GL_NEAREST;
 
@@ -328,8 +334,12 @@ void say_image_set(say_image *img, size_t x, size_t y, say_color color) {
 }
 
 void say_image_bind(say_image *img) {
+  say_image_bind_to(img, 0);
+}
+
+void say_image_bind_to(say_image *img, int unit) {
   say_context_ensure();
-  say_texture_make_current(img->texture);
+  say_texture_make_current(img->texture, unit);
 
   if (!img->texture_updated)
     say_image_update_texture(img);
@@ -339,7 +349,7 @@ void say_image_update_texture(say_image *img) {
   if (!img->pixels)
     return;
 
-  say_texture_make_current(img->texture);
+  say_texture_make_current(img->texture, 0);
   say_pixel_bus_unbind_unpack();
   glTexSubImage2D(GL_TEXTURE_2D, 0,
                   0, 0,
@@ -350,7 +360,14 @@ void say_image_update_texture(say_image *img) {
 }
 
 void say_image_unbind() {
-  say_texture_make_current(0);
+  say_context_ensure();
+  for (size_t i = 0; i < SAY_MAX_TEXTURE_UNIT; i++)
+    say_texture_make_current(0, i);
+}
+
+void say_image_unbind_from(int unit) {
+  say_context_ensure();
+  say_texture_make_current(0, unit);
 }
 
 GLuint say_image_get_texture(say_image *img) {

data/ext/say_image.h

@@ -3,6 +3,8 @@
 
 #include "say_basic_type.h"
 
+#define SAY_MAX_TEXTURE_UNIT 32
+
 typedef struct say_image {
   GLuint texture;
 
@@ -50,7 +52,9 @@ say_color *say_image_get_buffer(say_image *img);
 void say_image_mark_out_of_date(say_image *img);
 
 void say_image_bind(say_image *img);
+void say_image_bind_to(say_image *img, int unit);
 void say_image_unbind();
+void say_image_unbind_from(int unit);
 
 void say_image_update_texture(say_image *img);
 

data/ext/say_image_target.c

@@ -44,48 +44,37 @@ static void say_fbo_build(say_image_target *target, say_fbo *fbo) {
   fbo->img = target->img;
 }
 
-static GLuint say_current_fbo = 0;
-static say_context *say_fbo_last_context = NULL;
-
 void say_fbo_make_current(GLuint fbo) {
   say_context *context = say_context_current();
 
-  if (context != say_fbo_last_context ||
-      fbo != say_current_fbo) {
-    say_current_fbo = fbo;
-    say_fbo_last_context = context;
-
+  if (context->fbo != fbo) {
     glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+    context->fbo = fbo;
   }
 }
 
-static GLuint say_current_rbo = 0;
-static say_context *say_rbo_last_context = NULL;
-
 void say_rbo_make_current(GLuint rbo) {
   say_context *context = say_context_current();
 
-  if (context != say_rbo_last_context ||
-      rbo != say_current_rbo) {
-    say_current_rbo = rbo;
-    say_rbo_last_context = context;
-
+  if (context->rbo != rbo) {
     glBindRenderbuffer(GL_RENDERBUFFER, rbo);
+    context->rbo = rbo;
   }
 }
 
 void say_image_target_will_delete(mo_hash *fbos, GLuint rbo) {
-  mo_hash_it it = mo_hash_begin(fbos);
-  for (; !mo_hash_it_is_end(&it); mo_hash_it_next(&it)) {
-    say_fbo *fbo = mo_hash_it_val_ptr(&it, say_fbo);
-    if (fbo->id == say_current_fbo) {
-      say_current_fbo = 0;
-      break;
-    }
-  }
+  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 (say_current_rbo == rbo)
-    say_current_rbo = 0;
+    say_fbo *fbo = mo_hash_get_ptr(fbos, &context, say_fbo);
+    if (fbo && fbo->id == context->fbo)
+      context->fbo = 0;
+
+    if (context->rbo == rbo)
+      context->rbo = 0;
+  }
 }
 
 bool say_image_target_is_available() {

data/ext/say_index_buffer.c

@@ -1,23 +1,20 @@
 #include "say.h"
 
-static GLuint       say_current_ibo      = 0;
-static say_context *say_ibo_last_context = NULL;
-
 static void say_ibo_make_current(GLuint ibo) {
   say_context *context = say_context_current();
 
-  if (context != say_ibo_last_context ||
-      ibo != say_current_ibo) {
-    say_current_ibo      = ibo;
-    say_ibo_last_context = context;
-
+  if (context->ibo != ibo) {
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
+    context->ibo = ibo;
   }
 }
 
 static void say_ibo_will_delete(GLuint ibo) {
-  if (ibo == say_current_ibo) {
-    say_current_ibo = 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->ibo == ibo)
+      context->ibo = 0;
   }
 }
 
@@ -59,8 +56,7 @@ void say_index_buffer_unbind() {
 }
 
 void say_index_buffer_rebind() {
-  if (say_ibo_last_context == say_context_current())
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, say_current_ibo);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, say_context_current()->ibo);
 }
 
 void say_index_buffer_update_part(say_index_buffer *buf, size_t index,

data/ext/say_index_buffer_slice.c

@@ -12,7 +12,7 @@ typedef struct {
 
 typedef struct {
   say_index_buffer *buf;
-  mo_list          *ranges;
+  mo_list           ranges;
 } say_global_ibo;
 
 static mo_array *say_index_buffers = NULL;
@@ -20,7 +20,7 @@ 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 = NULL;
+  mo_list_init(&ret.ranges, sizeof(say_range));
 
   return ret;
 }
@@ -29,7 +29,7 @@ static void say_global_ibo_free(void *data) {
   say_global_ibo *ibo = (say_global_ibo*)data;
 
   say_index_buffer_free(ibo->buf);
-  if (ibo->ranges) mo_list_free(ibo->ranges);
+  mo_list_release(&ibo->ranges);
 }
 
 static say_global_ibo *say_global_ibo_at(size_t index) {
@@ -60,51 +60,49 @@ static bool say_global_ibo_fit_into(say_global_ibo *ibo, size_t used,
 
 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);
+  mo_list_prepend(&ibo->ranges, ibo->ranges.head, &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);
+static size_t say_global_ibo_insert(mo_list *list, mo_list_it *it,
+                                    size_t size) {
+  say_range *range = mo_list_it_data_ptr(it, say_range);
   say_range tmp = say_make_range(range->loc + range->size, size);
 
-  mo_list_insert(list, &tmp);
+  mo_list_insert(list, it, &tmp);
   return tmp.loc;
 }
 
 static size_t say_global_ibo_find_in(say_global_ibo *ibo, size_t size) {
-  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;
+  if (!ibo->ranges.head && say_global_ibo_fit_into(ibo, 0, size)) {
+    return say_global_ibo_prepend(ibo, size);
   }
 
-  say_range *first = mo_list_data_ptr(ibo->ranges, say_range);
+  say_range *first = mo_list_it_data_ptr(ibo->ranges.head, say_range);
 
   /* There's room at the begin of the buffer */
   if (first->loc >= size) {
     return say_global_ibo_prepend(ibo, size);
   }
 
-  mo_list *it = ibo->ranges;
+  mo_list_it *it = ibo->ranges.head;
   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);
+    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 >= size)
-      return say_global_ibo_insert(it, size);
+      return say_global_ibo_insert(&ibo->ranges, it, size);
   }
 
-  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 (say_global_ibo_fit_into(ibo, last->loc + last->size, size))
-    return say_global_ibo_insert(it, size);
+    return say_global_ibo_insert(&ibo->ranges, it, size);
   else
     return SAY_MAX_SIZE;
 }
@@ -148,14 +146,10 @@ static void say_global_ibo_delete_at(say_global_ibo *ibo, size_t loc,
   if (!ibo)
     return;
 
-  for (mo_list *it = ibo->ranges; it; it = it->next) {
-    say_range *range = mo_list_data_ptr(it, say_range);
+  for (mo_list_it *it = ibo->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 == ibo->ranges) ibo->ranges = next;
-
+      mo_list_delete(&ibo->ranges, it);
       return;
     }
   }
@@ -163,8 +157,8 @@ static void say_global_ibo_delete_at(say_global_ibo *ibo, size_t loc,
 
 static void say_global_ibo_reduce_size(say_global_ibo *ibo, size_t 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);
+  for (mo_list_it *it = ibo->ranges.head; it; it = it->next) {
+    say_range *range = mo_list_it_data_ptr(it, say_range);
     if (range->loc == loc && range->size == old_size) {
       range->size = size;
       return;