ray 0.1.0.pre1 → 0.1.0

data/ext/say_thread.c

@@ -0,0 +1,46 @@
+#include "say.h"
+
+#ifdef SAY_WIN
+static 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;
+}
+
+void say_thread_free(say_thread *th) {
+  CloseHandle(th->th);
+  free(th);
+}
+
+void say_thread_join(say_thread *th) {
+  WaitForSingleObject(th->th, INFINITE);
+}
+#else
+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);
+
+  return th;
+}
+
+void say_thread_free(say_thread *th) {
+  free(th);
+}
+
+void say_thread_join(say_thread *th) {
+  pthread_join(th->th, NULL);
+}
+#endif

data/ext/say_thread.h

@@ -0,0 +1,39 @@
+#ifndef SAY_THREAD_H_
+#define SAY_THREAD_H_
+
+#include "say_basic_type.h"
+
+typedef void *(*say_thread_func)(void *data);
+
+#ifdef SAY_WIN
+typedef struct {
+  DWORD key;
+} say_thread_variable;
+
+typedef struct {
+  HANDLE th;
+  say_thread_func func;
+  void *data;
+  } say_thread;
+#else
+typedef struct {
+  pthread_key_t key;
+} say_thread_variable;
+
+typedef struct {
+  pthread_t th;
+} say_thread;
+#endif
+
+say_thread_variable *say_thread_variable_create(say_destructor destructor);
+void say_thread_variable_free(say_thread_variable *var);
+
+void say_thread_variable_set(say_thread_variable *var, void *val);
+void *say_thread_variable_get(say_thread_variable *var);
+
+say_thread *say_thread_create(void *data, say_thread_func func);
+void say_thread_free(say_thread *th);
+
+void say_thread_join(say_thread *th);
+
+#endif

data/ext/say_thread_variable.c

@@ -0,0 +1,44 @@
+#include "say.h"
+
+#ifdef SAY_WIN
+say_thread_variable *say_thread_variable_create(say_destructor destructor) {
+  say_thread_variable *var = malloc(sizeof(say_thread_variable));
+  var->key = TlsAlloc();
+  
+  return var;
+}
+
+void say_thread_variable_free(say_thread_variable *var) {
+  TlsFree(var->key);
+  free(var);
+}
+
+void say_thread_variable_set(say_thread_variable *var, void *val) {
+  TlsSetValue(var->key, val);
+}
+
+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 *var = malloc(sizeof(say_thread_variable));
+
+  pthread_key_create(&(var->key), destructor);
+
+  return var;
+}
+
+void say_thread_variable_free(say_thread_variable *var) {
+  pthread_key_delete(var->key);
+  free(var);
+}
+
+void say_thread_variable_set(say_thread_variable *var, void *val) {
+  pthread_setspecific(var->key, val);
+}
+
+void *say_thread_variable_get(say_thread_variable *var) {
+  return pthread_getspecific(var->key);
+}
+#endif

data/ext/say_utf.c

@@ -0,0 +1,62 @@
+#include "say.h"
+
+/*
+  Based on source code found on unicode.org:
+    http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
+    http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.h
+*/
+
+#define UNI_REPLACEMENT_CHAR (uint32_t)0x0000FFFD
+#define UNI_MAX_BMP (uint32_t)0x0000FFFF
+#define UNI_MAX_UTF16 (uint32_t)0x0010FFFF
+#define UNI_MAX_UTF32 (uint32_t)0x7FFFFFFF
+#define UNI_MAX_LEGAL_UTF32 (uint32_t)0x0010FFFF
+
+#define UNI_SUR_HIGH_START  (uint32_t)0xD800
+#define UNI_SUR_HIGH_END    (uint32_t)0xDBFF
+#define UNI_SUR_LOW_START   (uint32_t)0xDC00
+#define UNI_SUR_LOW_END     (uint32_t)0xDFFF
+
+static const char say_utf8_trailing_bytes[256] = {
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+static const uint32_t say_utf8_offsets[6] = {
+  0x00000000UL, 0x00003080UL, 0x000E2080UL,
+  0x03C82080UL, 0xFA082080UL, 0x82082080UL
+};
+
+uint32_t say_utf8_to_utf32(const uint8_t *string) {
+  uint32_t ret = 0;
+
+  char trailing_bytes = say_utf8_trailing_bytes[(int)(*string)];
+
+  switch (trailing_bytes) { /* notice the fall through */
+    case 5: ret += *string++; ret <<= 6;
+    case 4: ret += *string++; ret <<= 6;
+    case 3: ret += *string++; ret <<= 6;
+    case 2: ret += *string++; ret <<= 6;
+    case 1: ret += *string++; ret <<= 6;
+    case 0: ret += *string++;
+  }
+
+  ret -= say_utf8_offsets[(int)trailing_bytes];
+
+  if (ret <= UNI_MAX_LEGAL_UTF32) {
+    if (ret >= UNI_SUR_HIGH_START && ret <= UNI_SUR_LOW_END) {
+      ret = UNI_REPLACEMENT_CHAR;
+    }
+  }
+  else {
+    ret = UNI_REPLACEMENT_CHAR;
+  }
+
+  return ret;
+}

data/ext/say_vertex_type.c

@@ -0,0 +1,113 @@
+#include "say.h"
+
+static say_array *say_vertex_types = NULL;
+
+static void say_vertex_type_delete(say_vertex_type *type) {
+  say_array_free(type->elements);
+}
+
+static void say_vertex_elem_free(say_vertex_elem *elem) {
+  free(elem->name);
+}
+
+static say_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_type type;
+    type.elements = say_array_create(sizeof(say_vertex_elem),
+                                     (say_destructor)say_vertex_elem_free, NULL);
+
+    say_vertex_elem el;
+
+    el.type = SAY_VECTOR2;
+    el.name = say_strdup(SAY_POS_ATTR);
+    say_vertex_type_push(&type, el);
+
+    el.type = SAY_COLOR;
+    el.name = say_strdup(SAY_COLOR_ATTR);
+    say_vertex_type_push(&type, el);
+
+    el.type = SAY_VECTOR2;
+    el.name = say_strdup(SAY_TEX_COORD_ATTR);
+    say_vertex_type_push(&type, el);
+
+    say_array_push(say_vertex_types, &type);
+  }
+
+  return say_vertex_types;
+}
+
+size_t say_vertex_type_make_new() {
+  say_vertex_type type;
+  type.elements = say_array_create(sizeof(say_vertex_elem), NULL, NULL);
+
+  say_array_push(say_vertex_type_get_all(), &type);
+  return say_array_get_size(say_vertex_types) - 1;
+}
+
+say_vertex_type *say_get_vertex_type(size_t i) {
+  return say_array_get(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);
+}
+
+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;
+}
+
+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;
+}
+
+size_t say_vertex_type_get_elem_count(say_vertex_type *type) {
+  return say_array_get_size(type->elements);
+}
+
+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;
+    }
+  }
+
+  return sum;
+}
+
+size_t say_vertex_type_get_offset(say_vertex_type *type, size_t 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;
+    }
+  }
+
+  return sum;
+}
+
+void say_vertex_type_clean_up() {
+  if (say_vertex_types)
+    say_array_free(say_vertex_types);
+  say_vertex_types = NULL;
+}

data/ext/say_vertex_type.h

@@ -0,0 +1,40 @@
+#ifndef SAY_VERTEX_TYPE_H_
+#define SAY_VERTEX_TYPE_H_
+
+#include "say_basic_type.h"
+
+typedef enum {
+  SAY_FLOAT,
+  SAY_INT,
+  SAY_UBYTE,
+  SAY_BOOL,
+
+  SAY_COLOR,
+  SAY_VECTOR2,
+  SAY_VECTOR3
+} say_vertex_elem_type;
+
+typedef struct {
+  say_vertex_elem_type  type;
+  char                 *name;
+} say_vertex_elem;
+
+typedef struct {
+  say_array *elements;
+} say_vertex_type;
+
+size_t say_vertex_type_make_new();
+
+say_vertex_type *say_get_vertex_type(size_t i);
+
+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);
+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);
+
+void say_vertex_type_clean_up();
+
+#endif

data/ext/say_vfile.c

@@ -0,0 +1,57 @@
+#include "say.h"
+
+sf_count_t say_vfile_get_size(say_vfile *file) {
+  return file->size;
+}
+
+sf_count_t say_vfile_seek(sf_count_t offset, int whence, say_vfile *file) {
+  sf_count_t start = 0;
+
+  switch (whence) {
+  case SEEK_CUR: start = file->pos;
+  case SEEK_SET: start = 0;
+  case SEEK_END: start = file->size;
+  default: return file->pos;
+  }
+
+  sf_count_t new_pos = start + offset;
+
+  if (new_pos < 0)
+    file->pos = 0;
+  else if (new_pos > file->size)
+    file->pos = file->size;
+  else
+    file->pos = new_pos;
+
+  return file->pos;
+}
+
+sf_count_t say_vfile_read(void *buf, sf_count_t count, say_vfile *file) {
+  if (count + file->pos >= file->size) {
+    count = file->size - file->pos;
+  }
+
+  if (count != 0)
+    memcpy(buf, &(((char*)file->buf)[file->pos]), count);
+
+  file->pos += count;
+
+  return count;
+}
+
+sf_count_t say_vfile_write(const void *buf, sf_count_t count, say_vfile *file) {
+  if (count + file->pos >= file->size) {
+    count = file->size - file->pos;
+  }
+
+  if (count != 0)
+    memcpy(&(((char*)file->buf)[file->pos]), buf, count);
+
+  file->pos += count;
+
+  return count;
+}
+
+sf_count_t say_vfile_tell(say_vfile *file) {
+  return file->pos;
+}

data/ext/say_view.c

@@ -0,0 +1,150 @@
+#include "say.h"
+
+static void say_view_update_matrix(say_view *view) {
+  if (!view->custom_matrix) {
+    say_matrix_reset(view->matrix);
+
+    if (view->flip_y) {
+      say_matrix_set_ortho(view->matrix,
+                           view->center.x - view->size.x / 2,
+                           view->center.x + view->size.x / 2,
+                           view->center.y + view->size.y / 2,
+                           view->center.y - view->size.y / 2,
+                           -1, 1);
+    }
+    else {
+      say_matrix_set_ortho(view->matrix,
+                           view->center.x - view->size.x / 2,
+                           view->center.x + view->size.x / 2,
+                           view->center.y - view->size.y / 2,
+                           view->center.y + view->size.y / 2,
+                           -1, 1);
+    }
+  }
+
+  view->matrix_updated = 1;
+}
+
+say_view *say_view_create() {
+  say_view *view = (say_view*)malloc(sizeof(say_view));
+
+  view->matrix = say_matrix_identity();
+  view->matrix_updated = 0;
+  view->custom_matrix  = 0;
+
+  view->size   = say_make_vector2(2, 2);
+  view->center = say_make_vector2(0, 0);
+
+  view->viewport = say_make_rect(0, 0, 1, 1);
+
+  view->flip_y = 1;
+
+  return view;
+}
+
+void say_view_free(say_view *view) {
+  say_matrix_free(view->matrix);
+  free(view);
+}
+
+void say_view_copy(say_view *view, say_view *other) {
+  say_matrix_set_content(view->matrix, other->matrix->content);
+
+  view->matrix_updated = other->matrix_updated;
+  view->custom_matrix  = other->custom_matrix;
+
+  view->size   = other->size;
+  view->center = other->center;
+
+  view->viewport = other->viewport;
+}
+
+void say_view_zoom_by(say_view *view, say_vector2 scale) {
+  say_view_set_size(view, say_make_vector2(view->size.x * scale.x,
+                                           view->size.y * scale.y));
+}
+
+void say_view_set_size(say_view *view, say_vector2 size) {
+  if (say_vector2_eq(view->size, size))
+    return;
+
+  view->size = size;
+  view->matrix_updated = 0;
+  view->has_changed = 1;
+}
+
+void say_view_set_center(say_view *view, say_vector2 center) {
+  if (say_vector2_eq(view->center, center))
+    return;
+
+  view->center = center;
+  view->matrix_updated = 0;
+  view->has_changed = 1;
+}
+
+void say_view_set_viewport(say_view *view, say_rect viewport) {
+  if (say_rect_eq(view->viewport, viewport))
+    return;
+
+  view->viewport = viewport;
+  view->has_changed = 1;
+}
+
+say_vector2 say_view_get_size(say_view *view) {
+  return view->size;
+}
+
+say_vector2 say_view_get_center(say_view *view) {
+  return view->center;
+}
+
+say_rect say_view_get_viewport(say_view *view) {
+  return view->viewport;
+}
+
+
+void say_view_flip_y(say_view *view, uint8_t val) {
+  view->flip_y = val;
+  view->matrix_updated = 0;
+  view->has_changed = 1;
+}
+
+uint8_t say_view_is_y_flipped(say_view *view) {
+  return view->flip_y;
+}
+
+say_matrix *say_view_get_matrix(say_view *view) {
+  if (!view->matrix_updated)
+    say_view_update_matrix(view);
+  return view->matrix;
+}
+
+void say_view_set_matrix(say_view *view, say_matrix *matrix) {
+  if (matrix) {
+    view->custom_matrix = 1;
+    say_matrix_set_content(view->matrix, matrix->content);
+  }
+  else {
+    say_matrix_reset(view->matrix);
+    view->custom_matrix = 0;
+  }
+
+  view->matrix_updated = 1;
+  view->has_changed = 1;
+}
+
+uint8_t say_view_has_changed(say_view *view) {
+  return view->has_changed;
+}
+
+void say_view_apply(say_view *view, say_shader *shader, say_vector2 size) {
+  say_shader_set_matrix_id(shader, SAY_PROJECTION_LOC_ID,
+                           say_view_get_matrix(view));
+
+  glViewport(view->viewport.x * size.x,
+             size.y - (view->viewport.y + view->viewport.h) * size.y,
+             view->viewport.w * size.x,
+             view->viewport.h * size.y);
+
+  view->has_changed = 0;
+}