ray 0.1.1 → 0.2.0

data/ext/say_context.h

@@ -3,6 +3,16 @@
 
 #include "say_basic_type.h"
 
+typedef struct {
+  size_t depth_size;
+  size_t stencil_size;
+
+  size_t major_version, minor_version;
+
+  bool core_profile;
+  bool debug;
+} say_context_config;
+
 struct say_window;
 
 typedef struct {
@@ -10,6 +20,10 @@ typedef struct {
   say_imp_context context;
 } say_context;
 
+say_context_config *say_context_get_config();
+
+void say_context_free_el(void *context);
+
 void say_context_ensure();
 
 say_context *say_context_current();

data/ext/say_drawable.c

@@ -4,21 +4,60 @@ static void say_drawable_update_matrix(say_drawable *drawable) {
   if (drawable->custom_matrix)
     return;
 
-  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,
+  if (drawable->matrix_proc) {
+    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_translate_by(drawable->matrix,
+                            -drawable->origin.x,
+                            -drawable->origin.y,
+                            0);
+  }
 
-  drawable->matrix_updated = 1;
+  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;
+
+    if (mode == SAY_BLEND_NO)
+      glDisable(GL_BLEND);
+    else if (say_last_blend == SAY_BLEND_NO)
+      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;
+    }
+
+    say_last_blend         = mode;
+    say_blend_last_context = context;
+  }
 }
 
 say_drawable *say_drawable_create(size_t vtype) {
@@ -33,8 +72,11 @@ say_drawable *say_drawable_create(size_t vtype) {
 
   drawable->data = NULL;
 
-  drawable->fill_proc   = NULL;
-  drawable->render_proc = NULL;
+  drawable->matrix_proc     = NULL;
+  drawable->index_fill_proc = NULL;
+  drawable->fill_proc       = NULL;
+  drawable->render_proc     = NULL;
+  drawable->shader_proc     = NULL;
 
   drawable->shader = NULL;
   drawable->matrix = say_matrix_identity();
@@ -50,6 +92,8 @@ say_drawable *say_drawable_create(size_t vtype) {
   drawable->angle   = 0;
   drawable->z_order = 0;
 
+  drawable->blend_mode = SAY_BLEND_ALPHA;
+
   return drawable;
 }
 
@@ -59,9 +103,9 @@ void say_drawable_copy(say_drawable *drawable, say_drawable *other) {
 
   drawable->index_count = other->index_count;
 
-  drawable->data = other->data;
-
+  drawable->matrix_proc     = other->matrix_proc;
   drawable->fill_proc       = other->fill_proc;
+  drawable->shader_proc     = other->shader_proc;
   drawable->render_proc     = other->render_proc;
   drawable->index_fill_proc = other->index_fill_proc;
 
@@ -73,6 +117,8 @@ void say_drawable_copy(say_drawable *drawable, say_drawable *other) {
   drawable->z_order = other->z_order;
   drawable->angle   = other->angle;
 
+  drawable->blend_mode = other->blend_mode;
+
   drawable->use_texture = other->use_texture;
 
   drawable->matrix_updated = false;
@@ -94,6 +140,14 @@ void say_drawable_set_custom_data(say_drawable *drawable, void *data) {
   drawable->has_changed = 1;
 }
 
+void say_drawable_set_other_data(say_drawable *drawable, void *data) {
+  drawable->other_data = data;
+}
+
+void *say_drawable_get_other_data(say_drawable *drawable) {
+  return drawable->other_data;
+}
+
 void say_drawable_set_vertex_count(say_drawable *drawable, size_t size) {
   if (size == drawable->vertex_count)
     return;
@@ -122,6 +176,11 @@ size_t say_drawable_get_index_count(say_drawable *drawable) {
   return drawable->index_count;
 }
 
+void say_drawable_set_matrix_proc(say_drawable *drawable, say_matrix_proc proc) {
+  drawable->matrix_proc    = proc;
+  drawable->matrix_updated = false;
+}
+
 void say_drawable_set_fill_proc(say_drawable *drawable, say_fill_proc proc) {
   drawable->fill_proc   = proc;
   drawable->has_changed = 1;
@@ -135,7 +194,10 @@ void say_drawable_set_index_fill_proc(say_drawable *drawable,
 
 void say_drawable_set_render_proc(say_drawable *drawable, say_render_proc proc) {
   drawable->render_proc = proc;
-  drawable->has_changed = 1;
+}
+
+void say_drawable_set_shader_proc(say_drawable *drawable, say_shader_proc proc) {
+  drawable->shader_proc = proc;
 }
 
 void say_drawable_fill_buffer(say_drawable *drawable, void *vertices) {
@@ -203,6 +265,8 @@ void say_drawable_fill_own_index_buffer(say_drawable *drawable) {
 void say_drawable_draw_at(say_drawable *drawable,
                           size_t vertex_id, size_t id,
                           say_shader *shader) {
+  say_drawable_enable_blend_mode(drawable->blend_mode);
+
   if (!drawable->matrix_updated)
     say_drawable_update_matrix(drawable);
 
@@ -216,11 +280,16 @@ void say_drawable_draw_at(say_drawable *drawable,
                             drawable->use_texture);
     }
 
-    drawable->render_proc(drawable->data, vertex_id, id, shader);
+    if (drawable->shader_proc)
+      drawable->shader_proc(drawable->data, shader);
+
+    drawable->render_proc(drawable->data, vertex_id, id);
   }
 }
 
 void say_drawable_draw(say_drawable *drawable, say_shader *shader) {
+  say_drawable_enable_blend_mode(drawable->blend_mode);
+
   if (drawable->has_changed) {
     say_drawable_fill_own_buffer(drawable);
     say_drawable_fill_own_index_buffer(drawable);
@@ -242,16 +311,22 @@ void say_drawable_draw(say_drawable *drawable, say_shader *shader) {
                             drawable->use_texture);
     }
 
-    if (drawable->vertex_count != 0)
+    size_t loc = 0, index_loc = 0;
+
+    if (drawable->vertex_count != 0) {
       say_buffer_slice_bind(drawable->slice);
+      loc = say_buffer_slice_get_loc(drawable->slice);
+    }
 
-    if (drawable->index_count != 0)
+    if (drawable->index_count != 0) {
       say_index_buffer_slice_bind(drawable->index_slice);
+      index_loc = say_index_buffer_slice_get_loc(drawable->index_slice);
+    }
+
+    if (drawable->shader_proc)
+      drawable->shader_proc(drawable->data, shader);
 
-    drawable->render_proc(drawable->data,
-                          say_buffer_slice_get_loc(drawable->slice),
-                          say_index_buffer_slice_get_loc(drawable->index_slice),
-                          used_shader);
+    drawable->render_proc(drawable->data, loc, index_loc);
   }
 }
 
@@ -263,6 +338,10 @@ uint8_t say_drawable_has_changed(say_drawable *drawable) {
   return drawable->has_changed;
 }
 
+void say_drawable_set_matrix_changed(say_drawable *drawable) {
+  drawable->matrix_updated = false;
+}
+
 void say_drawable_set_textured(say_drawable *drawable, uint8_t val) {
   drawable->use_texture = val;
 }
@@ -348,3 +427,12 @@ 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;
+}
+
+void say_drawable_set_blend_mode(say_drawable *drawable, say_blend_mode mode) {
+  drawable->blend_mode = mode;
+}

data/ext/say_drawable.h

@@ -7,10 +7,18 @@
 #include "say_matrix.h"
 #include "say_shader.h"
 
+typedef void (*say_matrix_proc)(void *data, say_matrix *matrix);
 typedef void (*say_fill_proc)(void *data, void *vertices);
 typedef void (*say_index_fill_proc)(void *data, GLuint *indices, size_t from);
-typedef void (*say_render_proc)(void *data, size_t first, size_t index,
-                                say_shader *shader);
+typedef void (*say_render_proc)(void *data, size_t first, size_t index);
+typedef void (*say_shader_proc)(void *data, say_shader *shader);
+
+typedef enum {
+  SAY_BLEND_NO,
+  SAY_BLEND_ALPHA,
+  SAY_BLEND_ADD,
+  SAY_BLEND_MULTIPLY
+} say_blend_mode;
 
 typedef struct {
   size_t            vertex_count;
@@ -21,10 +29,13 @@ typedef struct {
   say_index_buffer_slice *index_slice;
 
   void *data;
+  void *other_data;
 
+  say_matrix_proc     matrix_proc;
   say_fill_proc       fill_proc;
   say_index_fill_proc index_fill_proc;
   say_render_proc     render_proc;
+  say_shader_proc     shader_proc;
 
   say_shader *shader;
   say_matrix *matrix;
@@ -39,6 +50,8 @@ typedef struct {
   bool matrix_updated;
   bool custom_matrix;
   bool has_changed;
+
+  say_blend_mode blend_mode;
 } say_drawable;
 
 say_drawable *say_drawable_create(size_t vtype);
@@ -47,6 +60,8 @@ void say_drawable_free(say_drawable *drawable);
 void say_drawable_copy(say_drawable *drawable, say_drawable *other);
 
 void say_drawable_set_custom_data(say_drawable *drawable, void *data);
+void say_drawable_set_other_data(say_drawable *drawable, void *data);
+void *say_drawable_get_other_data(say_drawable *drawable);
 
 void say_drawable_set_vertex_count(say_drawable *drawable, size_t size);
 size_t say_drawable_get_vertex_count(say_drawable *drawable);
@@ -56,8 +71,10 @@ size_t say_drawable_get_vertex_type(say_drawable *drawable);
 void say_drawable_set_index_count(say_drawable *drawable, size_t size);
 size_t say_drawable_get_index_count(say_drawable *drawable);
 
+void say_drawable_set_matrix_proc(say_drawable *drawable, say_matrix_proc proc);
 void say_drawable_set_fill_proc(say_drawable *drawable, say_fill_proc proc);
 void say_drawable_set_render_proc(say_drawable *drawable, say_render_proc proc);
+void say_drawable_set_shader_proc(say_drawable *drawable, say_shader_proc proc);
 void say_drawable_set_index_fill_proc(say_drawable *drawable,
                                         say_index_fill_proc proc);
 
@@ -74,6 +91,7 @@ void say_drawable_draw(say_drawable *drawable, say_shader *shader);
 
 void say_drawable_set_changed(say_drawable *drawable);
 uint8_t say_drawable_has_changed(say_drawable *drawable);
+void say_drawable_set_matrix_changed(say_drawable *drawable);
 
 void say_drawable_set_textured(say_drawable *drawable, uint8_t val);
 uint8_t say_drawable_is_textured(say_drawable *drawable);
@@ -97,4 +115,7 @@ say_matrix *say_drawable_get_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);
 
+say_blend_mode say_drawable_get_blend_mode(say_drawable *drawable);
+void say_drawable_set_blend_mode(say_drawable *drawable, say_blend_mode mode);
+
 #endif

data/ext/say_error.c

@@ -11,7 +11,7 @@ const char *say_error_get_last() {
 
 void say_error_set(const char *message) {
   if (!say_last_error)
-    say_last_error = say_thread_variable_create(free);
+    say_last_error = say_thread_variable_create();
 
   void *old = say_thread_variable_get(say_last_error);
   if (old)
@@ -21,7 +21,12 @@ void say_error_set(const char *message) {
 }
 
 void say_error_clean_up() {
-  if (say_last_error)
+  if (say_last_error) {
+    void *error = say_thread_variable_get(say_last_error);
+    if (error) free(error);
+
     say_thread_variable_free(say_last_error);
+  }
+
   say_last_error = NULL;
 }

data/ext/say_font.c

@@ -1,12 +1,11 @@
 #include "say.h"
 
-static say_font_page *say_page_create() {
-  say_font_page *page = malloc(sizeof(say_font_page));
+static void say_page_init(say_font_page *page) {
+  page->glyphs = mo_hash_create(sizeof(uint32_t), sizeof(say_glyph));
+  page->glyphs->hash_of = mo_hash_of_u32;
+  page->glyphs->key_cmp = mo_hash_u32_cmp;
 
-  page->glyphs = say_table_create(free);
-  page->rows   = say_array_create(sizeof(say_font_row),
-                                  NULL,
-                                  NULL);
+  mo_array_init(&page->rows, sizeof(say_font_row));
 
   page->current_height = 2;
 
@@ -25,17 +24,13 @@ static say_font_page *say_page_create() {
       say_image_set(page->image, x, y, say_make_color(255, 255, 255, 255));
     }
   }
-
-  return page;
 }
 
 static void say_page_free(say_font_page *page) {
   say_image_free(page->image);
 
-  say_array_free(page->rows);
-  say_table_free(page->glyphs);
-
-  free(page);
+  mo_array_release(&page->rows);
+  mo_hash_free(page->glyphs);
 }
 
 static say_rect say_page_find_rect(say_font_page *page, size_t width, size_t height) {
@@ -43,9 +38,10 @@ static say_rect say_page_find_rect(say_font_page *page, size_t width, size_t hei
 
   float best_ratio = 0;
 
-  for (say_font_row *row = say_array_get(page->rows, 0);
-       row;
-       say_array_next(page->rows, (void**)&row)) {
+  say_font_row *end = mo_array_end(&page->rows);
+  for (say_font_row *row = mo_array_at(&page->rows, 0);
+       row && row < end;
+       mo_array_next(&page->rows, (void**)&row)) {
     float ratio = height / (float)row->height;
 
     if (ratio < 0.7 || ratio > 1.0 || ratio < best_ratio)
@@ -61,7 +57,7 @@ static say_rect say_page_find_rect(say_font_page *page, size_t width, size_t hei
   if (!found_row) {
     int row_height = height + height / 10;
 
-    if (page->current_height + row_height >= say_image_get_height(page->image)) {
+    while (page->current_height + row_height >= say_image_get_height(page->image)) {
       say_vector2 size = say_image_get_size(page->image);
       say_image_resize(page->image, size.x * 2, size.y * 2);
     }
@@ -72,8 +68,8 @@ static say_rect say_page_find_rect(say_font_page *page, size_t width, size_t hei
     row.y             = page->current_height;
     row.height        = row_height;
 
-    say_array_push(page->rows, &row);
-    found_row = say_array_get(page->rows, say_array_get_size(page->rows) - 1);
+    mo_array_push(&page->rows, &row);
+    found_row = mo_array_at(&page->rows, page->rows.size - 1);
 
     page->current_height += row_height;
   }
@@ -112,8 +108,10 @@ static say_glyph *say_font_load_glyph(say_font *font, say_font_page *page,
                                       size_t size) {
   uint32_t bold_codepoint = ((bold ? 1 : 0) << 31) | codepoint;
 
-  say_glyph *glyph = malloc(sizeof(say_glyph));
-  say_table_set(page->glyphs, bold_codepoint, glyph);
+  say_glyph tmp;
+  mo_hash_set(page->glyphs, &bold_codepoint, &tmp);
+
+  say_glyph *glyph = mo_hash_get(page->glyphs, &bold_codepoint);
 
   glyph->offset   = 0;
   glyph->bounds   = say_make_rect(2, 0, 2, 2);
@@ -217,7 +215,10 @@ say_font *say_font_create() {
 
   font->face = NULL;
 
-  font->pages = say_table_create((say_destructor)say_page_free);
+  font->pages = mo_hash_create(sizeof(size_t), sizeof(say_font_page));
+  font->pages->release = (say_destructor)say_page_free;
+  font->pages->hash_of = mo_hash_of_size;
+  font->pages->key_cmp = mo_hash_size_cmp;
 
   return font;
 }
@@ -242,7 +243,7 @@ void say_font_free(say_font *font) {
   if (font->library)
     FT_Done_FreeType(font->library);
 
-  say_table_free(font->pages);
+  mo_hash_free(font->pages);
   free(font);
 }
 
@@ -274,13 +275,15 @@ int say_font_load_from_memory(say_font *font, void *buf, size_t size) {
 
 say_font_page *say_font_get_page(say_font *font, size_t size) {
   say_font_page *page = NULL;
-  if ((page = say_table_get(font->pages, size)))
+  if ((page = mo_hash_get(font->pages, &size)))
     return page;
   else {
-    page = say_page_create();
-    say_table_set(font->pages, size, page);
+    say_font_page page;
+    say_page_init(&page);
 
-    return page;
+    mo_hash_set(font->pages, &size, &page);
+
+    return mo_hash_get(font->pages, &size);
   }
 }
 
@@ -289,7 +292,7 @@ say_glyph *say_font_get_glyph(say_font *font, uint32_t codepoint, size_t size, u
   uint32_t bold_codepoint = ((bold ? 1 : 0) << 31) | codepoint;
 
   say_glyph *glyph = NULL;
-  if ((glyph = say_table_get(page->glyphs, bold_codepoint)))
+  if ((glyph = mo_hash_get(page->glyphs, &bold_codepoint)))
     return glyph;
   else {
     return say_font_load_glyph(font, page, codepoint, bold, size);