ray 0.1.0.pre1 → 0.1.0

data/ext/say_error.c

@@ -0,0 +1,27 @@
+#include "say.h"
+
+static say_thread_variable *say_last_error = NULL;
+
+const char *say_error_get_last() {
+  if (!say_last_error)
+    return NULL;
+
+  return say_thread_variable_get(say_last_error);
+}
+
+void say_error_set(const char *message) {
+  if (!say_last_error)
+    say_last_error = say_thread_variable_create(free);
+
+  void *old = say_thread_variable_get(say_last_error);
+  if (old)
+    free(old);
+
+  say_thread_variable_set(say_last_error, say_strdup(message));
+}
+
+void say_error_clean_up() {
+  if (say_last_error)
+    say_thread_variable_free(say_last_error);
+  say_last_error = NULL;
+}

data/ext/say_event.h

@@ -0,0 +1,213 @@
+#ifndef SAY_EVENT_H_
+#define SAY_EVENT_H_
+
+#include "say_basic_type.h"
+
+typedef enum {
+  SAY_EVENT_NONE = 0,
+
+  SAY_EVENT_QUIT,
+
+  SAY_EVENT_RESIZE,
+
+  SAY_EVENT_MOUSE_ENTERED,
+  SAY_EVENT_MOUSE_LEFT,
+  SAY_EVENT_FOCUS_GAIN,
+  SAY_EVENT_FOCUS_LOSS,
+
+  SAY_EVENT_WHEEL_MOTION,
+  SAY_EVENT_MOUSE_MOTION,
+
+  SAY_EVENT_BUTTON_PRESS,
+  SAY_EVENT_BUTTON_RELEASE,
+
+  SAY_EVENT_TEXT_ENTERED,
+
+  SAY_EVENT_KEY_PRESS,
+  SAY_EVENT_KEY_RELEASE
+} say_event_type;
+
+typedef enum {
+  SAY_BUTTON_UNKNOWN = 0,
+
+  SAY_BUTTON_LEFT,
+  SAY_BUTTON_RIGHT,
+  SAY_BUTTON_MIDDLE
+} say_button;
+
+typedef enum {
+  SAY_KEY_UNKNOWN = 0,
+
+  SAY_KEY_A,
+  SAY_KEY_B,
+  SAY_KEY_C,
+  SAY_KEY_D,
+  SAY_KEY_E,
+  SAY_KEY_F,
+  SAY_KEY_G,
+  SAY_KEY_H,
+  SAY_KEY_I,
+  SAY_KEY_J,
+  SAY_KEY_K,
+  SAY_KEY_L,
+  SAY_KEY_M,
+  SAY_KEY_N,
+  SAY_KEY_O,
+  SAY_KEY_P,
+  SAY_KEY_Q,
+  SAY_KEY_R,
+  SAY_KEY_S,
+  SAY_KEY_T,
+  SAY_KEY_U,
+  SAY_KEY_V,
+  SAY_KEY_W,
+  SAY_KEY_X,
+  SAY_KEY_Y,
+  SAY_KEY_Z,
+
+  SAY_KEY_NUM_0,
+  SAY_KEY_NUM_1,
+  SAY_KEY_NUM_2,
+  SAY_KEY_NUM_3,
+  SAY_KEY_NUM_4,
+  SAY_KEY_NUM_5,
+  SAY_KEY_NUM_6,
+  SAY_KEY_NUM_7,
+  SAY_KEY_NUM_8,
+  SAY_KEY_NUM_9,
+
+  SAY_KEY_KP_0,
+  SAY_KEY_KP_1,
+  SAY_KEY_KP_2,
+  SAY_KEY_KP_3,
+  SAY_KEY_KP_4,
+  SAY_KEY_KP_5,
+  SAY_KEY_KP_6,
+  SAY_KEY_KP_7,
+  SAY_KEY_KP_8,
+  SAY_KEY_KP_9,
+
+  SAY_KEY_ESCAPE,
+  SAY_KEY_BACKSPACE,
+  SAY_KEY_TAB,
+  SAY_KEY_RETURN,
+  SAY_KEY_PAGE_UP,
+  SAY_KEY_PAGE_DOWN,
+  SAY_KEY_END,
+  SAY_KEY_HOME,
+  SAY_KEY_INSERT,
+  SAY_KEY_DELETE,
+  SAY_KEY_PAUSE,
+
+  SAY_KEY_LCONTROL,
+  SAY_KEY_LSHIFT,
+  SAY_KEY_LMETA,
+  SAY_KEY_LSUPER,
+
+  SAY_KEY_RCONTROL,
+  SAY_KEY_RSHIFT,
+  SAY_KEY_RMETA,
+  SAY_KEY_RSUPER,
+
+  SAY_KEY_MENU,
+  SAY_KEY_LBRACKET,
+  SAY_KEY_RBRACKET,
+  SAY_KEY_SEMICOLON,
+  SAY_KEY_COMMA,
+  SAY_KEY_PERIOD,
+  SAY_KEY_QUOTE,
+  SAY_KEY_SLASH,
+  SAY_KEY_BACKSLASH,
+  SAY_KEY_TILDE,
+  SAY_KEY_EQUAL,
+  SAY_KEY_MINUS,
+  SAY_KEY_PLUS,
+  SAY_KEY_ASTERISK,
+  SAY_KEY_SPACE,
+
+  SAY_KEY_LEFT,
+  SAY_KEY_RIGHT,
+  SAY_KEY_UP,
+  SAY_KEY_DOWN,
+
+  SAY_KEY_F1,
+  SAY_KEY_F2,
+  SAY_KEY_F3,
+  SAY_KEY_F4,
+  SAY_KEY_F5,
+  SAY_KEY_F6,
+  SAY_KEY_F7,
+  SAY_KEY_F8,
+  SAY_KEY_F9,
+  SAY_KEY_F10,
+  SAY_KEY_F11,
+  SAY_KEY_F12,
+  SAY_KEY_F13,
+  SAY_KEY_F14,
+  SAY_KEY_F15,
+
+  SAY_KEY_COUNT
+} say_key;
+
+#define SAY_MOD_META    0x1
+#define SAY_MOD_CONTROL 0x2
+#define SAY_MOD_SHIFT   0x4
+#define SAY_MOD_SUPER   0x8
+
+typedef struct {
+  say_vector2 pos;
+} say_event_mouse_motion;
+
+typedef struct {
+  say_vector2 pos;
+  int delta;
+} say_event_wheel_motion;
+
+typedef struct {
+  say_vector2 pos;
+  say_button button;
+} say_event_button;
+
+typedef struct {
+  uint32_t text;
+} say_event_text;
+
+typedef struct {
+  say_key  code;
+  uint8_t  mod;
+  uint32_t native_code;
+} say_event_key;
+
+typedef struct {
+  say_vector2 size;
+} say_event_resize;
+
+typedef struct say_event {
+  say_event_type type;
+
+  union {
+    say_event_mouse_motion motion;
+    say_event_wheel_motion wheel;
+    say_event_button       button;
+    say_event_text         text;
+    say_event_key          key;
+    say_event_resize       resize;
+  } ev;
+} say_event;
+
+typedef struct say_input {
+  uint8_t keys[SAY_KEY_COUNT - 1]; /* Don't count SAY_KEY_UNKNOWN */
+  say_vector2 mouse_pos;
+} say_input;
+
+uint8_t say_input_is_holding(say_input *input, say_key key);
+say_vector2 say_input_get_mouse_pos(say_input *input);
+
+void say_input_reset(say_input *input);
+
+void say_input_press(say_input *input, say_key key);
+void say_input_release(say_input *input, say_key key);
+
+void say_input_set_mouse_pos(say_input *input, say_vector2 pos);
+
+#endif

data/ext/say_font.c

@@ -0,0 +1,335 @@
+#include "say.h"
+
+static say_font_page *say_page_create() {
+  say_font_page *page = malloc(sizeof(say_font_page));
+
+  page->glyphs = say_table_create(free);
+  page->rows   = say_array_create(sizeof(say_font_row),
+                                  NULL,
+                                  NULL);
+
+  page->current_height = 2;
+
+  page->image = say_image_create();
+  say_image_set_smooth(page->image, 1);
+  say_image_create_with_size(page->image, 128, 128);
+
+  for (int y = 0; y < 128; y++) {
+    for (int x = 0; x < 128; x++) {
+      say_image_set(page->image, x, y, say_make_color(255, 255, 255, 0));
+    }
+  }
+
+  for (int y = 0; y < 2; y++) {
+    for (int x = 0; x < 2; x++) {
+      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);
+}
+
+static say_rect say_page_find_rect(say_font_page *page, size_t width, size_t height) {
+  say_font_row *found_row = NULL;
+
+  float best_ratio = 0;
+
+  for (say_font_row *row = say_array_get(page->rows, 0);
+       row;
+       say_array_next(page->rows, (void**)&row)) {
+    float ratio = height / (float)row->height;
+
+    if (ratio < 0.7 || ratio > 1.0 || ratio < best_ratio)
+      continue;
+
+    if (width > say_image_get_width(page->image) - row->current_width)
+      continue;
+
+    found_row  = row;
+    best_ratio = ratio;
+  }
+
+  if (!found_row) {
+    int row_height = height + height / 10;
+
+    if (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);
+    }
+
+    say_font_row row;
+
+    row.current_width = 0;
+    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);
+
+    page->current_height += row_height;
+  }
+
+  say_rect rect = say_make_rect(found_row->current_width, found_row->y,
+                                width, height);
+  found_row->current_width += width;
+
+  return rect;
+}
+
+static size_t say_font_get_size(say_font *font) {
+  return font->face->size->metrics.x_ppem;
+}
+
+static int say_font_set_size(say_font *font, size_t size) {
+  if (say_font_get_size(font) != size) {
+    int err = FT_Set_Pixel_Sizes(font->face, 0, size);
+    if (err) {
+      say_error_set("could not set font size");
+      return 0;
+    }
+  }
+
+  int err = FT_Select_Charmap(font->face, FT_ENCODING_UNICODE);
+  if (err) {
+    say_error_set("could not select unicode charmap");
+    return 0;
+  }
+
+  return 1;
+}
+
+static say_glyph *say_font_load_glyph(say_font *font, say_font_page *page,
+                                      uint32_t codepoint, uint8_t bold,
+                                      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);
+
+  glyph->offset   = 0;
+  glyph->bounds   = say_make_rect(2, 0, 2, 2);
+  glyph->sub_rect = say_make_rect(2, 0, 2, 2);
+
+  if (!(font->face && say_font_set_size(font, size)))
+    return glyph;
+
+  if (FT_Load_Char(font->face, codepoint, FT_LOAD_TARGET_NORMAL) != 0)
+    return glyph;
+
+  FT_Glyph ft_glyph;
+  if (FT_Get_Glyph(font->face->glyph, &ft_glyph) != 0)
+    return glyph;
+
+  FT_Pos weight = 1 << 6;
+  uint8_t outline = ft_glyph->format == FT_GLYPH_FORMAT_OUTLINE;
+
+  if (bold && outline) {
+    FT_OutlineGlyph outline_glyph = (FT_OutlineGlyph)ft_glyph;
+    FT_Outline_Embolden(&outline_glyph->outline, weight);
+  }
+
+  FT_Glyph_To_Bitmap(&ft_glyph, FT_RENDER_MODE_NORMAL, 0, 1);
+  FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)ft_glyph;
+  FT_Bitmap *bitmap = &bitmap_glyph->bitmap;
+
+  if (bold && !outline) {
+    FT_Bitmap_Embolden(font->library, bitmap, weight, weight);
+  }
+
+  glyph->offset = ft_glyph->advance.x >> 16;
+  if (bold)
+    glyph->offset += weight >> 6;
+
+  int width  = bitmap->width;
+  int height = bitmap->rows;
+
+  if (width > 0 && height > 0) {
+    static const int padding = 1;
+    glyph->sub_rect = say_page_find_rect(page,
+                                         width  + (2 * padding),
+                                         height + (2 * padding));
+
+    glyph->bounds.x = +bitmap_glyph->left - padding;
+    glyph->bounds.y = -bitmap_glyph->top - padding;
+    glyph->bounds.w = width   + (2 * padding);
+    glyph->bounds.h = height  + (2 * padding);
+
+    say_rect actual_rect = glyph->sub_rect;
+    actual_rect.x += padding;
+    actual_rect.y += padding;
+    actual_rect.w -= 2 * padding;
+    actual_rect.h -= 2 * padding;
+
+    uint8_t *pixels = bitmap->buffer;
+
+    if (bitmap->pixel_mode == FT_PIXEL_MODE_MONO) {
+      for (int y = actual_rect.y; y < actual_rect.y + actual_rect.h; y++) {
+        for (int x = actual_rect.x; x < actual_rect.x + actual_rect.w; x++) {
+          int pixel_x = x - actual_rect.x;
+          uint8_t alpha = ((pixels[pixel_x / 8]) &
+                           (1 << (7 - (pixel_x % 8)))) ? 255 : 0;
+          say_image_set(page->image, x, y,
+                        say_make_color(255, 255, 255, alpha));
+        }
+
+        pixels += bitmap->pitch;
+      }
+    }
+    else {
+      for (int y = actual_rect.y; y < actual_rect.y + actual_rect.h;
+           y++) {
+        for (int x = actual_rect.x; x < actual_rect.x + actual_rect.w;
+             x++) {
+          int pixel_x = x - actual_rect.x;
+          say_image_set(page->image, x, y,
+                        say_make_color(255, 255, 255, pixels[pixel_x]));
+        }
+
+        pixels += bitmap->pitch;
+      }
+    }
+  }
+
+  FT_Done_Glyph(ft_glyph);
+
+  return glyph;
+}
+
+say_font *say_font_create() {
+  say_font *font = malloc(sizeof(say_font));
+
+  int err = FT_Init_FreeType(&font->library);
+  if (err) {
+    free(font);
+
+    say_error_set("could not initialize freetype library");
+    return NULL;
+  }
+
+  font->face = NULL;
+
+  font->pages = say_table_create((say_destructor)say_page_free);
+
+  return font;
+}
+
+static say_font *say_default_font = NULL;
+#include "say_arial.h"
+
+say_font *say_font_default() {
+  if (!say_default_font) {
+    say_default_font = say_font_create();
+    say_font_load_from_memory(say_default_font, say_arial_content,
+                              sizeof(say_arial_content));
+  }
+
+  return say_default_font;
+}
+
+void say_font_free(say_font *font) {
+  if (font->face)
+    FT_Done_Face(font->face);
+
+  if (font->library)
+    FT_Done_FreeType(font->library);
+
+  say_table_free(font->pages);
+  free(font);
+}
+
+int say_font_load_from_file(say_font *font, const char *file) {
+  int err = FT_New_Face(font->library, file, 0, &font->face);
+  if (err) {
+    say_error_set("could not create face");
+    return 0;
+  }
+
+  return 1;
+}
+
+int say_font_load_from_memory(say_font *font, void *buf, size_t size) {
+  int err = FT_New_Memory_Face(font->library, buf, size, 0, &font->face);
+  if (err) {
+    say_error_set("could not create face");
+    return 0;
+  }
+
+  err = FT_Select_Charmap(font->face, FT_ENCODING_UNICODE);
+  if (err) {
+    say_error_set("could not select unicode charmap");
+    return 0;
+  }
+
+  return 1;
+}
+
+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)))
+    return page;
+  else {
+    page = say_page_create();
+    say_table_set(font->pages, size, page);
+
+    return page;
+  }
+}
+
+say_glyph *say_font_get_glyph(say_font *font, uint32_t codepoint, size_t size, uint8_t bold) {
+  say_font_page *page = say_font_get_page(font, size);
+  uint32_t bold_codepoint = ((bold ? 1 : 0) << 31) | codepoint;
+
+  say_glyph *glyph = NULL;
+  if ((glyph = say_table_get(page->glyphs, bold_codepoint)))
+    return glyph;
+  else {
+    return say_font_load_glyph(font, page, codepoint, bold, size);
+  }
+}
+
+size_t say_font_get_kerning(say_font *font, uint32_t first, uint32_t second,
+                            size_t size) {
+  if (first == 0 || second == 0)
+    return 0;
+
+  if (font->face && FT_HAS_KERNING(font->face) &&
+      say_font_set_size(font, size)) {
+    size_t first_index = FT_Get_Char_Index(font->face, first);
+    size_t sec_index   = FT_Get_Char_Index(font->face, second);
+
+    FT_Vector kerning;
+    FT_Get_Kerning(font->face, first_index, sec_index, FT_KERNING_DEFAULT,
+                   &kerning);
+
+    return kerning.x >> 6;
+  }
+
+  return 0;
+}
+
+size_t say_font_get_line_height(say_font *font, size_t size) {
+  if (font->face && say_font_set_size(font, size))
+    return font->face->size->metrics.height >> 6;
+
+  return 0;
+}
+
+say_image *say_font_get_image(say_font *font, size_t size) {
+  say_font_page *page = say_font_get_page(font, size);
+  return page->image;
+}
+
+void say_font_clean_up() {
+  if (say_default_font)
+    say_font_free(say_default_font);
+  say_default_font = NULL;
+}