ray 0.1.0.pre1 → 0.1.0

data/ext/say_font.h

@@ -0,0 +1,51 @@
+#ifndef SAY_FONT_H_
+#define SAY_FONT_H_
+
+#include "say_table.h"
+#include "say_array.h"
+
+#include "say_image.h"
+
+typedef struct {
+  int offset;
+  say_rect bounds, sub_rect;
+} say_glyph;
+
+typedef struct {
+  size_t current_width, height, y;
+} say_font_row;
+
+typedef struct {
+  say_table *glyphs;
+  say_array *rows;
+
+  say_image *image;
+
+  size_t current_height;
+} say_font_page;
+
+typedef struct {
+  FT_Library library;
+  FT_Face face;
+
+  say_table *pages;
+} say_font;
+
+say_font *say_font_create();
+void say_font_free(say_font *font);
+
+say_font *say_font_default();
+
+int say_font_load_from_file(say_font *font, const char *file);
+int say_font_load_from_memory(say_font *font, void *buf, size_t size);
+
+say_glyph *say_font_get_glyph(say_font *font, uint32_t codepoint, size_t size,
+                              uint8_t bold);
+size_t say_font_get_kerning(say_font *font, uint32_t first, uint32_t second,
+                            size_t size);
+size_t say_font_get_line_height(say_font *font, size_t size);
+say_image *say_font_get_image(say_font *font, size_t size);
+
+void say_font_clean_up();
+
+#endif

data/ext/say_image.c

@@ -0,0 +1,283 @@
+#include "say.h"
+
+#include "stb_image.h"
+
+#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) {
+  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;
+
+    glBindTexture(GL_TEXTURE_2D, texture);
+  }
+}
+
+static void say_texture_will_delete(GLuint texture) {
+  if (say_current_texture == texture)
+    say_current_texture = 0;
+}
+
+say_image *say_image_create() {
+  say_context_ensure();
+
+  say_image *img = (say_image*)malloc(sizeof(say_image));
+
+  img->texture = 0;
+  glGenTextures(1, &(img->texture));
+
+  img->pixels          = NULL;
+  img->texture_updated = 1;
+
+  img->width  = 0;
+  img->height = 0;
+
+  img->smooth = 1;
+  say_image_set_smooth(img, 0);
+
+  return img;
+}
+
+void say_image_free(say_image *img) {
+  say_context_ensure();
+
+  say_texture_will_delete(img->texture);
+  glDeleteTextures(1, &(img->texture));
+
+  if (img->pixels)
+    free(img->pixels);
+
+  free(img);
+}
+
+bool say_image_load_raw(say_image *img, size_t width, size_t height,
+                        say_color *pixels) {
+  if (!say_image_create_with_size(img, width, height))
+    return false;
+
+  memcpy(img->pixels, pixels, sizeof(say_color) * width * height);
+  return true;
+}
+
+bool say_image_load_file(say_image *img, const char *filename) {
+  int width, height, comp = 4;
+
+  stbi_uc *buf = stbi_load(filename, &width, &height, &comp, 4);
+  if (!buf)
+    return false;
+
+  if (!say_image_load_raw(img, width, height, (say_color*)buf))
+    return false;
+  stbi_image_free(buf);
+
+  return true;
+}
+
+bool say_image_load_from_memory(say_image *img, size_t size,
+                                const char *buffer) {
+  int width, height, comp = 4;
+
+  stbi_uc *buf = stbi_load_from_memory((const uint8_t*)buffer, size,
+                                       &width, &height, &comp, 4);
+  if (!buf)
+    return false;
+
+  if (!say_image_load_raw(img, width, height, (say_color*)buf))
+    return false;
+  stbi_image_free(buf);
+
+  return true;
+}
+
+bool say_image_create_with_size(say_image *img, size_t w, size_t h) {
+  if (w == 0 || h == 0) {
+    say_error_set("can't create empty image");
+    return false;
+  }
+
+  if (img->width != w || img->height != h) {
+    if (img->pixels) free(img->pixels);
+    img->pixels = malloc(sizeof(say_color) * w * h);
+
+    say_texture_make_current(img->texture);
+    glGetError(); /* Ignore potential previous errors */
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0,
+                 GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+
+    if (glGetError()) {
+      say_error_set("could not create texture");
+      return false;
+    }
+  }
+
+  img->width  = w;
+  img->height = h;
+
+  img->texture_updated = 0;
+
+  return true;
+}
+
+static bool say_image_assert_non_empty(say_image *img) {
+  if (img->width == 0 || img->height == 0) {
+    say_error_set("can't save empty image");
+    return false;
+  }
+
+  return true;
+}
+
+bool say_image_write_bmp(say_image *img, const char *filename) {
+  if (!say_image_assert_non_empty(img))
+    return false;
+
+  stbi_write_bmp(filename, img->width, img->height, 4, img->pixels);
+
+  return true;
+}
+
+bool say_image_write_png(say_image *img, const char *filename) {
+  if (!say_image_assert_non_empty(img))
+    return false;
+
+  stbi_write_png(filename, img->width, img->height, 4, img->pixels, 0);
+
+  return true;
+}
+
+bool say_image_write_tga(say_image *img, const char *filename) {
+  if (!say_image_assert_non_empty(img))
+    return false;
+
+  stbi_write_tga(filename, img->width, img->height, 4, img->pixels);
+
+  return true;
+}
+
+bool say_image_write(say_image *img, const char *filename) {
+  size_t len = strlen(filename);
+
+  if (len < 4)
+    return say_image_write_bmp(img, filename);
+  else {
+    const char *ext = (filename + len - 4);
+    if (strcmp(ext, ".png") == 0 || strcmp(ext, ".PNG") == 0)
+      return say_image_write_png(img, filename);
+    else if (strcmp(ext, ".tga") == 0 || strcmp(ext, ".TGA") == 0)
+      return say_image_write_tga(img, filename);
+    else
+      say_image_write_bmp(img, filename);
+  }
+
+  return true;
+}
+
+size_t say_image_get_width(say_image *img) {
+  return img->width;
+}
+
+size_t say_image_get_height(say_image *img) {
+  return img->height;
+}
+
+say_vector2 say_image_get_size(say_image *img) {
+  return say_make_vector2(img->width, img->height);
+}
+
+bool say_image_resize(say_image *img, size_t w, size_t h) {
+  size_t old_w = img->width, old_h = img->height;
+
+  say_color *cpy = malloc(sizeof(say_color) * img->width * img->height);
+  memcpy(cpy, img->pixels, sizeof(say_color) * img->width * img->height);
+
+  if (!say_image_create_with_size(img, w, h))
+    return false;
+
+  size_t row_size = sizeof(say_color) * old_h;
+
+  for (size_t y = 0; y < old_h; y++) {
+    memcpy(&img->pixels[y * img->width], &cpy[y * old_h], row_size);
+    for (size_t x = old_w; x < img->width; x++)
+      img->pixels[y * img->height + x] = say_make_color(255, 255, 255, 0);
+  }
+
+  for (size_t y = old_h; y < img->height; y++) {
+    for (size_t x = 0; x < img->width; x++)
+      img->pixels[y * img->height + x] = say_make_color(255, 255, 255, 0);
+  }
+
+  free(cpy);
+
+  return true;
+}
+
+uint8_t say_image_is_smooth(say_image *img) {
+  return img->smooth;
+}
+
+void say_image_set_smooth(say_image *img, uint8_t val) {
+  if (img->smooth != val) {
+    img->smooth = val;
+
+    say_context_ensure();
+    say_texture_make_current(img->texture);
+
+    GLenum interp = val ? GL_LINEAR : GL_NEAREST;
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, interp);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, interp);
+  }
+}
+
+say_rect say_image_get_tex_rect(say_image *img, say_rect rect) {
+  if (img->width == 0 || img->height == 0)
+    return say_make_rect(0, 0, 0, 0);
+
+  return say_make_rect(rect.x / img->width, rect.y / img->height,
+                       rect.w / img->width, rect.h / img->height);
+}
+
+say_color *say_image_get_buffer(say_image *img) {
+  return img->pixels;
+}
+
+say_color say_image_get(say_image *img, size_t x, size_t y) {
+  return img->pixels[y * img->width + x];
+}
+
+void say_image_set(say_image *img, size_t x, size_t y, say_color color) {
+  img->pixels[y * img->width + x] = color;
+  img->texture_updated = 0;
+}
+
+void say_image_bind(say_image *img) {
+  say_context_ensure();
+  say_texture_make_current(img->texture);
+
+  if (!img->texture_updated)
+    say_image_update_texture(img);
+}
+
+void say_image_update_texture(say_image *img) {
+  if (!img->pixels)
+    return;
+
+  say_texture_make_current(img->texture);
+  glTexSubImage2D(GL_TEXTURE_2D, 0,
+                  0, 0,
+                  img->width, img->height,
+                  GL_RGBA, GL_UNSIGNED_BYTE, img->pixels);
+
+  img->texture_updated = 1;
+}
+
+void say_image_unbind() {
+  say_texture_make_current(0);
+}

data/ext/say_image.h

@@ -0,0 +1,52 @@
+#ifndef SAY_IMAGE_H_
+#define SAY_IMAGE_H_
+
+#include "say_basic_type.h"
+
+typedef struct say_image {
+  GLuint texture;
+
+  say_color *pixels;
+  uint8_t texture_updated;
+
+  size_t width, height;
+
+  uint8_t smooth;
+} say_image;
+
+say_image *say_image_create();
+void say_image_free(say_image *img);
+
+size_t say_image_get_width(say_image *img);
+size_t say_image_get_height(say_image *img);
+say_vector2 say_image_get_size(say_image *img);
+
+bool say_image_resize(say_image *img, size_t w, size_t h);
+
+bool say_image_load_raw(say_image *img, size_t width, size_t height,
+                        say_color *pixels);
+bool say_image_load_file(say_image *img, const char *filename);
+bool say_image_load_from_memory(say_image *img, size_t size, const char *buffer);
+bool say_image_create_with_size(say_image *img, size_t w, size_t h);
+
+bool say_image_write_bmp(say_image *img, const char *filename);
+bool say_image_write_png(say_image *img, const char *filename);
+bool say_image_write_tga(say_image *img, const char *filename);
+bool say_image_write(say_image *img, const char *filename);
+
+uint8_t say_image_is_smooth(say_image *img);
+void say_image_set_smooth(say_image *img, uint8_t val);
+
+say_color say_image_get(say_image *img, size_t x, size_t y);
+void say_image_set(say_image *img, size_t x, size_t y, say_color color);
+
+say_rect say_image_get_tex_rect(say_image *img, say_rect rect);
+
+say_color *say_image_get_buffer(say_image *img);
+
+void say_image_bind(say_image *img);
+void say_image_unbind();
+
+void say_image_update_texture(say_image *img);
+
+#endif

data/ext/say_image_target.c

@@ -0,0 +1,134 @@
+#include "say.h"
+
+static say_context *say_image_target_make_context(void *data) {
+  return say_context_create();
+}
+
+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;
+
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 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;
+
+    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbo);
+  }
+}
+
+void say_image_target_will_delete(GLuint fbo, GLuint rbo) {
+  if (say_current_fbo == fbo)
+    say_current_fbo = 0;
+
+  if (say_current_rbo == rbo)
+    say_current_rbo = 0;
+}
+
+bool say_image_target_is_available() {
+  say_context_ensure();
+  return __GLEW_EXT_framebuffer_object != 0;
+}
+
+say_image_target *say_image_target_create() {
+  say_context_ensure();
+  say_image_target *target = malloc(sizeof(say_image_target));
+
+  target->target = say_target_create();
+  target->img    = NULL;
+
+  glGenFramebuffersEXT(1, &(target->fbo));
+  glGenRenderbuffersEXT(1, &(target->rbo));
+
+  return target;
+}
+
+void say_image_target_free(say_image_target *target) {
+  say_context_ensure();
+  say_image_target_will_delete(target->fbo, target->rbo);
+
+  glDeleteRenderbuffersEXT(1, &(target->rbo));
+  glDeleteFramebuffersEXT(1, &(target->fbo));
+
+  say_target_free(target->target);
+  free(target);
+}
+
+void say_image_target_set_image(say_image_target *target, say_image *image) {
+  say_context_ensure();
+  target->img = image;
+
+  if (target->img) {
+    say_target_set_custom_data(target->target, target);
+    //say_target_need_own_contxt(target->target, 0);
+    say_target_set_context_proc(target->target, say_image_target_make_context);
+    say_target_set_bind_hook(target->target, (say_bind_hook)say_image_target_bind);
+
+    say_vector2 size = say_image_get_size(image);
+
+    say_target_set_size(target->target, size);
+    say_view_set_size(target->target->view, size);
+    say_view_set_center(target->target->view, say_make_vector2(size.x / 2.0,
+                                                               size.y / 2.0));
+    say_view_flip_y(target->target->view, 0);
+
+    say_fbo_make_current(target->fbo);
+
+    say_image_bind(image);
+    glGenerateMipmapEXT(GL_TEXTURE_2D);
+
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+                              GL_TEXTURE_2D, image->texture, 0);
+
+    say_rbo_make_current(target->rbo);
+    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
+                             say_image_get_width(image),
+                             say_image_get_height(image));
+
+    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
+                                 GL_RENDERBUFFER_EXT, target->rbo);
+
+  }
+}
+
+say_image *say_image_target_get_image(say_image_target *target) {
+  return target->img;
+}
+
+void say_image_target_update(say_image_target *target) {
+  if (target->img) {
+    say_target_update(target->target);
+
+    say_image_bind(target->img);
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                  say_image_get_buffer(target->img));
+  }
+}
+
+void say_image_target_bind(say_image_target *target) {
+  say_context_ensure();
+  say_fbo_make_current(target->fbo);
+  glClear(GL_DEPTH_BUFFER_BIT);
+}
+
+void say_image_target_unbind() {
+  if (say_image_target_is_available())
+    say_fbo_make_current(0);
+}