ray 0.1.1 → 0.2.0

data/ext/say_target.h

@@ -10,6 +10,8 @@ typedef say_context *(*say_context_proc)(void *data);
 typedef void (*say_bind_hook)(void *data);
 
 typedef struct {
+  mo_array all_contexts;
+
   say_thread_variable *context;
   say_context_proc context_proc;
   say_bind_hook bind_hook;
@@ -31,7 +33,7 @@ say_target *say_target_create();
 void say_target_free(say_target *target);
 
 void say_target_set_context_proc(say_target *target, say_context_proc proc);
-void say_target_need_own_contxt(say_target *target, uint8_t val);
+void say_target_need_own_contet(say_target *target, uint8_t val);
 say_context *say_target_get_context(say_target *target);
 
 void say_target_set_bind_hook(say_target *target, say_bind_hook proc);

data/ext/say_text.c

@@ -69,6 +69,12 @@ static void say_text_update_rect(say_text *text) {
   text->rect_size.y = height;
 
   text->rect_updated = 1;
+
+  if (text->auto_center) {
+    say_vector2 center = say_make_vector2(text->rect_size.x * text->center.x,
+                                          text->rect_size.y * text->center.y);
+    say_drawable_set_origin(text->drawable, center);
+  }
 }
 
 static void say_text_compute_vertex_count(say_text *text) {
@@ -249,8 +255,7 @@ static void say_text_fill_vertices(void *data, void *vertices_ptr) {
   }
 }
 
-static void say_text_draw(void *data, size_t first, size_t index,
-                          say_shader *shader) {
+static void say_text_draw(void *data, size_t first, size_t index) {
   say_text *text = (say_text*)data;
 
   if (!text->font)
@@ -317,6 +322,7 @@ say_text *say_text_create() {
   text->rect_size        = say_make_vector2(0, 0);
   text->rect_updated     = 1;
   text->underline_vertex = 0;
+  text->auto_center      = false;
 
   return text;
 }
@@ -344,9 +350,15 @@ void say_text_copy(say_text *text, say_text *src) {
   text->rect_size    = src->rect_size;
   text->rect_updated = src->rect_updated;
 
+  text->auto_center = src->auto_center;
+  text->center      = src->center;
+
   text->last_img_size = src->last_img_size;
 
   text->underline_vertex = src->underline_vertex;
+
+  say_text_compute_vertex_count(text);
+  say_text_update_rect(text);
 }
 
 uint32_t *say_text_get_string(say_text *text) {
@@ -368,6 +380,9 @@ void say_text_set_string(say_text *text, uint32_t *string, size_t length) {
   text->rect_updated = 0;
 
   say_text_compute_vertex_count(text);
+
+  if (text->auto_center)
+    say_text_update_rect(text);
 }
 
 say_font *say_text_get_font(say_text *text) {
@@ -394,6 +409,9 @@ void say_text_set_size(say_text *text, size_t size) {
   text->size = size;
   say_drawable_set_changed(text->drawable);
   text->rect_updated = 0;
+
+  if (text->auto_center)
+    say_text_update_rect(text);
 }
 
 uint8_t say_text_get_style(say_text *text) {
@@ -426,16 +444,36 @@ say_rect say_text_get_rect(say_text *text) {
   if (!text->rect_updated)
     say_text_update_rect(text);
 
-  say_vector2 pos   = say_drawable_get_pos(text->drawable);
-  say_vector2 scale = say_drawable_get_scale(text->drawable);
-  say_vector2 size  = text->rect_size;
+  say_vector2 pos    = say_drawable_get_pos(text->drawable);
+  say_vector2 origin = say_drawable_get_origin(text->drawable);
+  say_vector2 scale  = say_drawable_get_scale(text->drawable);
+  say_vector2 size   = text->rect_size;
 
   say_rect rect = (say_rect){
-    pos.x,
-    pos.y,
+    -origin.x * scale.x + pos.x,
+    -origin.y * scale.y + pos.y,
     size.x * scale.x,
     size.y * scale.y
   };
 
   return rect;
 }
+
+bool say_text_auto_center(say_text *text) {
+  return text->auto_center;
+}
+
+say_vector2 say_text_get_auto_center_ratio(say_text *text) {
+  return text->center;
+}
+
+void say_text_enable_auto_center(say_text *text, say_vector2 center) {
+  text->auto_center = true;
+  text->center      = center;
+
+  say_text_update_rect(text);
+}
+
+void say_text_disable_auto_center(say_text *text) {
+  text->auto_center = false;
+}

data/ext/say_text.h

@@ -13,17 +13,20 @@ typedef struct {
   say_drawable *drawable;
 
   say_font *font;
-  size_t size;
+  size_t    size;
 
   uint32_t *string;
-  size_t str_length;
+  size_t    str_length;
 
   uint8_t style;
 
   say_color color;
 
   say_vector2 rect_size;
-  uint8_t rect_updated;
+  uint8_t     rect_updated;
+
+  bool        auto_center;
+  say_vector2 center;
 
   say_vector2 last_img_size;
 
@@ -53,4 +56,10 @@ void say_text_set_color(say_text *text, say_color col);
 
 say_rect say_text_get_rect(say_text *text);
 
+bool        say_text_auto_center(say_text *text);
+say_vector2 say_text_get_auto_center_ratio(say_text *text);
+void        say_text_enable_auto_center(say_text *text, say_vector2 center);
+void        say_text_disable_auto_center(say_text *text);
+
+
 #endif /* SAY_TEXT_H_ */

data/ext/say_thread.c

@@ -1,22 +1,24 @@
 #include "say.h"
 
 #ifdef SAY_WIN
-static int say_thread_entry_point(void *data) {
+/* Windows threads */
+
+static unsigned int say_thread_entry_point(void *data) {
   say_thread *th = (say_thread*)data;
   th->func(th->data);
   _endthreadex(0);
-  
+
   return 0;
 }
 
 say_thread *say_thread_create(void *data, say_thread_func func) {
   say_thread *th = malloc(sizeof(say_thread));
-  
+
   th->func = func;
   th->data = data;
-  
+
   th->th = _beginthreadex(NULL, 0, say_thread_entry_point, th, 0, NULL);
-  
+
   return th;
 }
 
@@ -28,7 +30,11 @@ void say_thread_free(say_thread *th) {
 void say_thread_join(say_thread *th) {
   WaitForSingleObject(th->th, INFINITE);
 }
+
 #else
+
+/* POSIX threads */
+
 say_thread *say_thread_create(void *data, say_thread_func func) {
   say_thread *th = malloc(sizeof(say_thread));
   pthread_create(&th->th, NULL, func, data);
@@ -43,4 +49,5 @@ void say_thread_free(say_thread *th) {
 void say_thread_join(say_thread *th) {
   pthread_join(th->th, NULL);
 }
-#endif
+
+#endif

data/ext/say_thread.h

@@ -25,7 +25,7 @@ typedef struct {
 } say_thread;
 #endif
 
-say_thread_variable *say_thread_variable_create(say_destructor destructor);
+say_thread_variable *say_thread_variable_create();
 void say_thread_variable_free(say_thread_variable *var);
 
 void say_thread_variable_set(say_thread_variable *var, void *val);

data/ext/say_thread_variable.c

@@ -1,10 +1,10 @@
 #include "say.h"
 
 #ifdef SAY_WIN
-say_thread_variable *say_thread_variable_create(say_destructor destructor) {
+say_thread_variable *say_thread_variable_create() {
   say_thread_variable *var = malloc(sizeof(say_thread_variable));
   var->key = TlsAlloc();
-  
+
   return var;
 }
 
@@ -21,10 +21,10 @@ void *say_thread_variable_get(say_thread_variable *var) {
   return TlsGetValue(var->key);
 }
 #else
-say_thread_variable *say_thread_variable_create(say_destructor destructor) {
+say_thread_variable *say_thread_variable_create() {
   say_thread_variable *var = malloc(sizeof(say_thread_variable));
 
-  pthread_key_create(&(var->key), destructor);
+  pthread_key_create(&(var->key), NULL);
 
   return var;
 }
@@ -41,4 +41,4 @@ void say_thread_variable_set(say_thread_variable *var, void *val) {
 void *say_thread_variable_get(say_thread_variable *var) {
   return pthread_getspecific(var->key);
 }
-#endif
+#endif

data/ext/say_vertex_type.c

@@ -1,27 +1,28 @@
 #include "say.h"
 
-static say_array *say_vertex_types = NULL;
+static mo_array *say_vertex_types = NULL;
 
 static void say_vertex_type_delete(say_vertex_type *type) {
-  say_array_free(type->elements);
+  mo_array_release(&type->elements);
 }
 
 static void say_vertex_elem_free(say_vertex_elem *elem) {
   free(elem->name);
 }
 
-static say_array *say_vertex_type_get_all() {
+static mo_array *say_vertex_type_get_all() {
   if (!say_vertex_types) {
-    say_vertex_types = say_array_create(sizeof(say_vertex_type),
-                                        NULL,
-                                        (say_destructor)say_vertex_type_delete);
+    say_vertex_types = mo_array_create(sizeof(say_vertex_type));
+    say_vertex_types->release = (say_destructor)say_vertex_type_delete;
 
     say_vertex_type type;
-    type.elements = say_array_create(sizeof(say_vertex_elem),
-                                     (say_destructor)say_vertex_elem_free, NULL);
+    mo_array_init(&type.elements, sizeof(say_vertex_elem));
+    type.elements.release = (say_destructor)say_vertex_elem_free;
 
     say_vertex_elem el;
 
+    el.per_instance = false;
+
     el.type = SAY_VECTOR2;
     el.name = say_strdup(SAY_POS_ATTR);
     say_vertex_type_push(&type, el);
@@ -34,80 +35,117 @@ static say_array *say_vertex_type_get_all() {
     el.name = say_strdup(SAY_TEX_COORD_ATTR);
     say_vertex_type_push(&type, el);
 
-    say_array_push(say_vertex_types, &type);
+    mo_array_push(say_vertex_types, &type);
   }
 
   return say_vertex_types;
 }
 
+static size_t say_vertex_type_size_of(say_vertex_elem_type type) {
+  switch (type) {
+  case SAY_FLOAT: return sizeof(GLfloat);
+  case SAY_INT:   return sizeof(GLint);
+  case SAY_UBYTE: return sizeof(GLubyte);
+  case SAY_BOOL:  return sizeof(GLint);
+
+  case SAY_COLOR:   return(sizeof(GLubyte) * 4);
+  case SAY_VECTOR2: return(sizeof(GLfloat) * 2);
+  case SAY_VECTOR3: return(sizeof(GLfloat) * 3);
+  }
+
+  return 0;
+}
+
 size_t say_vertex_type_make_new() {
   say_vertex_type type;
-  type.elements = say_array_create(sizeof(say_vertex_elem), NULL, NULL);
+  mo_array_init(&type.elements, sizeof(say_vertex_elem));
+  type.elements.release = (say_destructor)say_vertex_elem_free;
 
-  say_array_push(say_vertex_type_get_all(), &type);
-  return say_array_get_size(say_vertex_types) - 1;
+  mo_array_push(say_vertex_type_get_all(), &type);
+  return say_vertex_types->size - 1;
 }
 
 say_vertex_type *say_get_vertex_type(size_t i) {
-  return say_array_get(say_vertex_type_get_all(), i);
+  return mo_array_at(say_vertex_type_get_all(), i);
 }
 
 void say_vertex_type_push(say_vertex_type *type, say_vertex_elem elem) {
-  say_array_push(type->elements, &elem);
+  mo_array_push(&type->elements, &elem);
 }
 
 say_vertex_elem_type say_vertex_type_get_type(say_vertex_type *type, size_t i) {
-  return ((say_vertex_elem*)say_array_get(type->elements, i))->type;
+  return mo_array_get_as(&type->elements, i, say_vertex_elem).type;
 }
 
 const char *say_vertex_type_get_name(say_vertex_type *type, size_t i) {
-  return ((say_vertex_elem*)say_array_get(type->elements, i))->name;
+  return mo_array_get_as(&type->elements, i, say_vertex_elem).name;
+}
+
+bool say_vertex_type_is_per_instance(say_vertex_type *type, size_t i) {
+  return mo_array_get_as(&type->elements, i, say_vertex_elem).per_instance;
 }
 
 size_t say_vertex_type_get_elem_count(say_vertex_type *type) {
-  return say_array_get_size(type->elements);
+  return type->elements.size;
 }
 
 size_t say_vertex_type_get_size(say_vertex_type *type) {
   size_t sum = 0;
-  for (say_vertex_elem *e = say_array_get(type->elements, 0);
-       e;
-       say_array_next(type->elements, (void**)&e)) {
-    switch (e->type) {
-    case SAY_FLOAT: sum += sizeof(GLfloat); continue;
-    case SAY_INT:   sum += sizeof(GLint);   continue;
-    case SAY_UBYTE: sum += sizeof(GLubyte); continue;
-    case SAY_BOOL:  sum += sizeof(GLint);   continue;
-
-    case SAY_COLOR:   sum += sizeof(GLubyte) * 4; continue;
-    case SAY_VECTOR2: sum += sizeof(GLfloat) * 2; continue;
-    case SAY_VECTOR3: sum += sizeof(GLfloat) * 3; continue;
-    }
+
+  say_vertex_elem *end = mo_array_end(&type->elements);
+  for (say_vertex_elem *e = mo_array_at(&type->elements, 0);
+       e && e < end;
+       mo_array_next(&type->elements, (void**)&e)) {
+    if (e->per_instance)
+      continue;
+    sum += say_vertex_type_size_of(e->type);
+  }
+
+  return sum;
+}
+
+size_t say_vertex_type_get_instance_size(say_vertex_type *type) {
+  size_t sum = 0;
+
+  say_vertex_elem *end = mo_array_end(&type->elements);
+  for (say_vertex_elem *e = mo_array_at(&type->elements, 0);
+       e && e < end;
+       mo_array_next(&type->elements, (void**)&e)) {
+    if (!e->per_instance)
+      continue;
+    sum += say_vertex_type_size_of(e->type);
   }
 
   return sum;
 }
 
 size_t say_vertex_type_get_offset(say_vertex_type *type, size_t elem) {
+  bool per_instance = say_vertex_type_is_per_instance(type, elem);
+
   size_t sum = 0;
   for (size_t i = 0; i < elem; i++) {
-    switch (say_vertex_type_get_type(type, i)) {
-    case SAY_FLOAT: sum += sizeof(GLfloat); continue;
-    case SAY_INT:   sum += sizeof(GLint);   continue;
-    case SAY_UBYTE: sum += sizeof(GLubyte); continue;
-    case SAY_BOOL:  sum += sizeof(GLint);   continue;
-
-    case SAY_COLOR:   sum += sizeof(GLubyte) * 4; continue;
-    case SAY_VECTOR2: sum += sizeof(GLfloat) * 2; continue;
-    case SAY_VECTOR3: sum += sizeof(GLfloat) * 3; continue;
-    }
+    if (per_instance != say_vertex_type_is_per_instance(type, i))
+      continue;
+    sum += say_vertex_type_size_of(say_vertex_type_get_type(type, i));
   }
 
   return sum;
 }
 
+bool say_vertex_type_has_instance_data(say_vertex_type *type) {
+  say_vertex_elem *end = mo_array_end(&type->elements);
+  for (say_vertex_elem *e = mo_array_at(&type->elements, 0);
+       e && e < end;
+       mo_array_next(&type->elements, (void**)&e)) {
+    if (e->per_instance)
+      return true;
+  }
+
+  return false;
+}
+
 void say_vertex_type_clean_up() {
   if (say_vertex_types)
-    say_array_free(say_vertex_types);
+    mo_array_free(say_vertex_types);
   say_vertex_types = NULL;
 }

data/ext/say_vertex_type.h

@@ -17,10 +17,11 @@ typedef enum {
 typedef struct {
   say_vertex_elem_type  type;
   char                 *name;
+  bool                  per_instance;
 } say_vertex_elem;
 
 typedef struct {
-  say_array *elements;
+  mo_array elements;
 } say_vertex_type;
 
 size_t say_vertex_type_make_new();
@@ -31,9 +32,12 @@ void say_vertex_type_push(say_vertex_type *type, say_vertex_elem elem);
 
 say_vertex_elem_type say_vertex_type_get_type(say_vertex_type *type, size_t i);
 const char *say_vertex_type_get_name(say_vertex_type *type, size_t i);
+bool say_vertex_type_is_per_instance(say_vertex_type *type, size_t i);
+size_t say_vertex_type_get_offset(say_vertex_type *type, size_t elem);
 size_t say_vertex_type_get_elem_count(say_vertex_type *type);
 size_t say_vertex_type_get_size(say_vertex_type *type);
-size_t say_vertex_type_get_offset(say_vertex_type *type, size_t elem);
+size_t say_vertex_type_get_instance_size(say_vertex_type *type);
+bool say_vertex_type_has_instance_data(say_vertex_type *type);
 
 void say_vertex_type_clean_up();