ray 0.1.1 → 0.2.0

data/ext/say_font.h

@@ -1,9 +1,6 @@
 #ifndef SAY_FONT_H_
 #define SAY_FONT_H_
 
-#include "say_table.h"
-#include "say_array.h"
-
 #include "say_image.h"
 
 typedef struct {
@@ -16,8 +13,8 @@ typedef struct {
 } say_font_row;
 
 typedef struct {
-  say_table *glyphs;
-  say_array *rows;
+  mo_hash  *glyphs;
+  mo_array  rows;
 
   say_image *image;
 
@@ -28,7 +25,7 @@ typedef struct {
   FT_Library library;
   FT_Face face;
 
-  say_table *pages;
+  mo_hash *pages;
 } say_font;
 
 say_font *say_font_create();

data/ext/say_get_proc.c

@@ -0,0 +1,35 @@
+/*
+ * Code stolen from GLEW, to do what GLEW should be doing.
+ */
+#include "say.h"
+
+#ifdef SAY_WIN
+void *say_get_proc(const char *name) {
+  return (void*)wglGetProcAddress((LPCSTR)name);
+}
+#else
+# ifdef SAY_OSX
+
+#include <dlfcn.h>
+void *say_get_proc(const char *name) {
+  static void *handle = NULL;
+  if (!handle) {
+    handle = dlopen("/System/Library/Frameworks/OpenGL.framework/"
+                    "Versions/Current/OpenGL", RTLD_LAZY);
+  }
+
+  /* prepend a '_' for the Unix C symbol mangling convention */
+  char *symbol_name = malloc(strlen(name) + 2);
+  strcpy(symbol_name + 1, name);
+  symbol_name[0] = '_';
+
+  void *ptr = dlsym(handle, symbol_name);
+  free(symbol_name);
+  return ptr;
+}
+# else
+void *say_get_proc(const char *name) {
+  return (void*)glXGetProcAddress((GLubyte*)name);
+}
+# endif
+#endif

data/ext/say_image.c

@@ -25,6 +25,19 @@ static void say_texture_will_delete(GLuint texture) {
     say_current_texture = 0;
 }
 
+static void say_image_update_buffer(say_image *img) {
+  if (img->buffer_updated)
+    return;
+
+  say_texture_make_current(img->texture);
+  say_pixel_bus_unbind_pack();
+  glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                img->pixels);
+
+  img->buffer_updated  = true;
+  img->texture_updated = true;
+}
+
 say_image *say_image_create() {
   say_context_ensure();
 
@@ -34,13 +47,14 @@ say_image *say_image_create() {
   glGenTextures(1, &(img->texture));
 
   img->pixels          = NULL;
-  img->texture_updated = 1;
+  img->texture_updated = true;
+  img->buffer_updated  = true;
 
   img->width  = 0;
   img->height = 0;
 
-  img->smooth = 1;
-  say_image_set_smooth(img, 0);
+  img->smooth = true;
+  say_image_set_smooth(img, false);
 
   return img;
 }
@@ -57,12 +71,29 @@ void say_image_free(say_image *img) {
   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))
+bool say_image_load_raw(say_image *img, size_t w, size_t h, say_color *pixels) {
+  if (!say_image_create_with_size(img, w, h))
     return false;
 
-  memcpy(img->pixels, pixels, sizeof(say_color) * width * height);
+  img->texture_updated = false;
+
+  memcpy(img->pixels, pixels, sizeof(say_color) * w * h);
+
+  /*
+   * Vertical flip to fit OpenGL convention.
+   */
+  say_flip_color_buffer(img->pixels, w, h);
+
+  return true;
+}
+
+bool say_image_load_flipped_raw(say_image *img, size_t w, size_t h,
+                                say_color *pixels) {
+  if (!say_image_create_with_size(img, w, h))
+    return false;
+
+  img->texture_updated = false;
+  memcpy(img->pixels, pixels, sizeof(say_color) * w * h);
   return true;
 }
 
@@ -104,9 +135,11 @@ bool say_image_create_with_size(say_image *img, size_t w, size_t h) {
 
   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);
+    say_pixel_bus_unbind_unpack();
     glGetError(); /* Ignore potential previous errors */
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, NULL);
@@ -120,7 +153,8 @@ bool say_image_create_with_size(say_image *img, size_t w, size_t h) {
   img->width  = w;
   img->height = h;
 
-  img->texture_updated = 0;
+  img->texture_updated = true;
+  img->buffer_updated  = true;
 
   return true;
 }
@@ -134,11 +168,19 @@ static bool say_image_assert_non_empty(say_image *img) {
   return true;
 }
 
+static say_color *say_image_reversed_buffer(say_image *img) {
+  return say_flip_color_buffer_copy(img->pixels, img->width,
+                                    img->height);
+}
+
 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);
+  say_image_update_buffer(img);
+  say_color *buf = say_image_reversed_buffer(img);
+  stbi_write_bmp(filename, img->width, img->height, 4, buf);
+  free(buf);
 
   return true;
 }
@@ -147,7 +189,15 @@ 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);
+#ifdef SAY_WIN
+  say_error_set("can't save image as a PNG on windows");
+  return false;
+#endif
+
+  say_image_update_buffer(img);
+  say_color *buf = say_image_reversed_buffer(img);
+  stbi_write_png(filename, img->width, img->height, 4, buf, 0);
+  free(buf);
 
   return true;
 }
@@ -156,7 +206,10 @@ 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);
+  say_image_update_buffer(img);
+  say_color *buf = say_image_reversed_buffer(img);
+  stbi_write_tga(filename, img->width, img->height, 4, buf);
+  free(buf);
 
   return true;
 }
@@ -170,10 +223,10 @@ bool say_image_write(say_image *img, const char *filename) {
     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 if (strcmp(ext, ".bmp") == 0 || strcmp(ext, ".BMP") == 0)
+      return say_image_write_bmp(img, filename);
     else
-      say_image_write_bmp(img, filename);
+      say_image_write_tga(img, filename);
   }
 
   return true;
@@ -192,6 +245,8 @@ say_vector2 say_image_get_size(say_image *img) {
 }
 
 bool say_image_resize(say_image *img, size_t w, size_t h) {
+  say_image_update_buffer(img);
+
   size_t old_w = img->width, old_h = img->height;
 
   say_color *cpy = malloc(sizeof(say_color) * img->width * img->height);
@@ -200,17 +255,24 @@ bool say_image_resize(say_image *img, size_t w, size_t h) {
   if (!say_image_create_with_size(img, w, h))
     return false;
 
+  img->texture_updated = 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);
+    memcpy(&img->pixels[(h - y - 1) * img->width],
+           &cpy[(old_h - y - 1) * old_h], row_size);
+    for (size_t x = old_w; x < img->width; x++) {
+      img->pixels[(h - y - 1) * 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);
+    for (size_t x = 0; x < img->width; x++) {
+      img->pixels[(h - y - 1) * img->height + x] =
+        say_make_color(255, 255, 255, 0);
+    }
   }
 
   free(cpy);
@@ -218,11 +280,11 @@ bool say_image_resize(say_image *img, size_t w, size_t h) {
   return true;
 }
 
-uint8_t say_image_is_smooth(say_image *img) {
+bool say_image_is_smooth(say_image *img) {
   return img->smooth;
 }
 
-void say_image_set_smooth(say_image *img, uint8_t val) {
+void say_image_set_smooth(say_image *img, bool val) {
   if (img->smooth != val) {
     img->smooth = val;
 
@@ -240,21 +302,29 @@ 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);
+  return say_make_rect(rect.x / img->width, 1 - (rect.y / img->height),
+                       rect.w / img->width, -(rect.h / img->height));
 }
 
 say_color *say_image_get_buffer(say_image *img) {
+  say_image_update_buffer(img);
   return img->pixels;
 }
 
+void say_image_mark_out_of_date(say_image *img) {
+  img->buffer_updated = false;
+}
+
 say_color say_image_get(say_image *img, size_t x, size_t y) {
-  return img->pixels[y * img->width + x];
+  say_image_update_buffer(img);
+  return img->pixels[(img->height - y - 1) * 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;
+  say_image_update_buffer(img);
+
+  img->pixels[(img->height - y - 1) * img->width + x] = color;
+  img->texture_updated = false;
 }
 
 void say_image_bind(say_image *img) {
@@ -270,14 +340,19 @@ void say_image_update_texture(say_image *img) {
     return;
 
   say_texture_make_current(img->texture);
+  say_pixel_bus_unbind_unpack();
   glTexSubImage2D(GL_TEXTURE_2D, 0,
                   0, 0,
                   img->width, img->height,
                   GL_RGBA, GL_UNSIGNED_BYTE, img->pixels);
 
-  img->texture_updated = 1;
+  img->texture_updated = true;
 }
 
 void say_image_unbind() {
   say_texture_make_current(0);
 }
+
+GLuint say_image_get_texture(say_image *img) {
+  return img->texture;
+}

data/ext/say_image.h

@@ -7,11 +7,12 @@ typedef struct say_image {
   GLuint texture;
 
   say_color *pixels;
-  uint8_t texture_updated;
+  bool texture_updated;
+  bool buffer_updated;
 
   size_t width, height;
 
-  uint8_t smooth;
+  bool smooth;
 } say_image;
 
 say_image *say_image_create();
@@ -25,6 +26,8 @@ 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_flipped_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);
@@ -34,8 +37,8 @@ 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);
+bool say_image_is_smooth(say_image *img);
+void say_image_set_smooth(say_image *img, bool 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);
@@ -44,9 +47,13 @@ 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_mark_out_of_date(say_image *img);
+
 void say_image_bind(say_image *img);
 void say_image_unbind();
 
 void say_image_update_texture(say_image *img);
 
+GLuint say_image_get_texture(say_image *img);
+
 #endif

data/ext/say_image_target.c

@@ -1,9 +1,49 @@
 #include "say.h"
 
+typedef struct {
+  GLuint       id;
+  say_image   *img;
+  say_context *ctxt;
+} say_fbo;
+
 static say_context *say_image_target_make_context(void *data) {
   return say_context_create();
 }
 
+static void say_fbo_delete_current(void *data) {
+  say_fbo *fbo = (say_fbo*)data;
+
+  if (fbo->ctxt == say_context_current() && fbo->id) {
+    glDeleteFramebuffers(1, &fbo->id);
+  }
+}
+
+void say_fbo_make_current(GLuint fbo);
+void say_rbo_make_current(GLuint rbo);
+
+static void say_fbo_build(say_image_target *target, say_fbo *fbo) {
+  if (!fbo->id)
+    glGenFramebuffers(1, &fbo->id);
+
+  say_fbo_make_current(fbo->id);
+
+  say_image_bind(target->img);
+  glGenerateMipmap(GL_TEXTURE_2D);
+
+  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                         GL_TEXTURE_2D, target->img->texture, 0);
+
+  say_rbo_make_current(target->rbo);
+  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT,
+                        say_image_get_width(target->img),
+                        say_image_get_height(target->img));
+
+  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                            GL_RENDERBUFFER, target->rbo);
+
+  fbo->img = target->img;
+}
+
 static GLuint say_current_fbo = 0;
 static say_context *say_fbo_last_context = NULL;
 
@@ -15,7 +55,7 @@ void say_fbo_make_current(GLuint fbo) {
     say_current_fbo = fbo;
     say_fbo_last_context = context;
 
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
+    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
   }
 }
 
@@ -30,13 +70,19 @@ void say_rbo_make_current(GLuint rbo) {
     say_current_rbo = rbo;
     say_rbo_last_context = context;
 
-    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbo);
+    glBindRenderbuffer(GL_RENDERBUFFER, rbo);
   }
 }
 
-void say_image_target_will_delete(GLuint fbo, GLuint rbo) {
-  if (say_current_fbo == fbo)
-    say_current_fbo = 0;
+void say_image_target_will_delete(mo_hash *fbos, GLuint rbo) {
+  mo_hash_it it = mo_hash_begin(fbos);
+  for (; !mo_hash_it_is_end(&it); mo_hash_it_next(&it)) {
+    say_fbo *fbo = mo_hash_it_val_ptr(&it, say_fbo);
+    if (fbo->id == say_current_fbo) {
+      say_current_fbo = 0;
+      break;
+    }
+  }
 
   if (say_current_rbo == rbo)
     say_current_rbo = 0;
@@ -44,7 +90,7 @@ void say_image_target_will_delete(GLuint fbo, GLuint rbo) {
 
 bool say_image_target_is_available() {
   say_context_ensure();
-  return __GLEW_EXT_framebuffer_object != 0;
+  return GLEW_EXT_framebuffer_object || GLEW_VERSION_3_0;
 }
 
 say_image_target *say_image_target_create() {
@@ -54,18 +100,22 @@ say_image_target *say_image_target_create() {
   target->target = say_target_create();
   target->img    = NULL;
 
-  glGenFramebuffersEXT(1, &(target->fbo));
-  glGenRenderbuffersEXT(1, &(target->rbo));
+  target->fbos = mo_hash_create(sizeof(say_context*), sizeof(say_fbo));
+  target->fbos->release = say_fbo_delete_current;
+  target->fbos->hash_of = mo_hash_of_pointer;
+  target->fbos->key_cmp = mo_hash_pointer_cmp;
+
+  glGenRenderbuffers(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);
+  say_image_target_will_delete(target->fbos, target->rbo);
 
-  glDeleteRenderbuffersEXT(1, &(target->rbo));
-  glDeleteFramebuffersEXT(1, &(target->fbo));
+  glDeleteRenderbuffers(1, &target->rbo);
+  mo_hash_free(target->fbos);
 
   say_target_free(target->target);
   free(target);
@@ -77,7 +127,6 @@ void say_image_target_set_image(say_image_target *target, say_image *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);
 
@@ -87,24 +136,8 @@ void say_image_target_set_image(say_image_target *target, say_image *image) {
     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_target_make_current(target->target);
   }
 }
 
@@ -115,16 +148,37 @@ say_image *say_image_target_get_image(say_image_target *target) {
 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));
+    say_image_mark_out_of_date(target->img);
   }
 }
 
 void say_image_target_bind(say_image_target *target) {
   say_context_ensure();
-  say_fbo_make_current(target->fbo);
+
+  /*
+   * As FBOs aren't shared, we need to fetch the FBO for the current context. If
+   * we don't find one, we need to build it.
+   */
+  say_context *ctxt = say_context_current();
+
+  if (!mo_hash_has_key(target->fbos, &ctxt)) {
+    say_fbo tmp = {0, NULL, NULL};
+    mo_hash_set(target->fbos, &ctxt, &tmp);
+
+    say_fbo_build(target, mo_hash_get(target->fbos, &ctxt));
+  }
+  else {
+    say_fbo *fbo = mo_hash_get(target->fbos, &ctxt);
+
+    if (fbo->img != target->img && target->img)
+      say_fbo_build(target, fbo);
+    else
+      say_fbo_make_current(fbo->id);
+  }
+
+  /*
+   * Needed to avoid having garbage data there.
+   */
   glClear(GL_DEPTH_BUFFER_BIT);
 }