ray 0.1.0.pre1 → 0.1.0

data/ext/say_image_target.h

@@ -0,0 +1,25 @@
+#ifndef SAY_IMAGE_TARGET_H_
+#define SAY_IMAGE_TARGET_H_
+
+#include "say_target.h"
+#include "say_image.h"
+
+typedef struct {
+  GLuint fbo, rbo;
+  say_image *img;
+  say_target *target;
+} say_image_target;
+
+bool say_image_target_is_available();
+
+say_image_target *say_image_target_create();
+void say_image_target_free(say_image_target *target);
+
+void say_image_target_set_image(say_image_target *target, say_image *image);
+say_image *say_image_target_get_image(say_image_target *target);
+void say_image_target_update(say_image_target *taget);
+
+void say_image_target_bind(say_image_target *target);
+void say_image_target_unbind();
+
+#endif

data/ext/say_imp.h

@@ -0,0 +1,70 @@
+#ifndef SAY_IMP_H_
+#define SAY_IMP_H_
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef SAY_OSX
+@class SayWindow;
+@class SayContext;
+
+typedef SayWindow  *say_imp_window;
+typedef SayContext *say_imp_context;
+#endif
+
+#ifdef SAY_X11
+struct say_x11_window;
+struct say_x11_context;
+
+typedef struct say_x11_window  *say_imp_window;
+typedef struct say_x11_context *say_imp_context;
+#endif
+
+#ifdef SAY_WIN
+struct say_win_window;
+struct say_win_context;
+
+typedef struct say_win_window  *say_imp_window;
+typedef struct say_win_context *say_imp_context;
+#endif
+
+struct say_event;
+struct say_input;
+struct say_image;
+
+size_t say_imp_screen_get_width();
+size_t say_imp_screen_get_height();
+
+say_imp_window say_imp_window_create();
+void say_imp_window_free(say_imp_window win);
+
+bool say_imp_window_open(say_imp_window win, const char *title,
+                         size_t w, size_t h,
+                         uint8_t flags);
+void say_imp_window_close(say_imp_window win);
+
+void say_imp_window_show_cursor(say_imp_window win);
+void say_imp_window_hide_cursor(say_imp_window win);
+
+bool say_imp_window_set_icon(say_imp_window win, struct say_image *img);
+
+void say_imp_window_set_title(say_imp_window win, const char *title);
+bool say_imp_window_resize(say_imp_window win, size_t w, size_t h);
+
+bool say_imp_window_poll_event(say_imp_window win, struct say_event *ev,
+                               struct say_input *input);
+void say_imp_window_wait_event(say_imp_window win, struct say_event *ev,
+                               struct say_input *input);
+
+void say_imp_context_free(say_imp_context ctxt);
+
+say_imp_context say_imp_context_create();
+say_imp_context say_imp_context_create_shared(say_imp_context shared);
+say_imp_context  say_imp_context_create_for_window(say_imp_context shared,
+                                                   say_imp_window  win);
+
+void say_imp_context_make_current(say_imp_context ctxt);
+void say_imp_context_update(say_imp_context ctxt);
+
+#endif

data/ext/say_index_buffer.c

@@ -0,0 +1,90 @@
+#include "say.h"
+
+static GLuint       say_current_ibo      = 0;
+static say_context *say_ibo_last_context = NULL;
+
+static void say_ibo_make_current(GLuint ibo) {
+  say_context *context = say_context_current();
+
+  if (context != say_ibo_last_context ||
+      ibo != say_current_ibo) {
+    say_current_ibo      = ibo;
+    say_ibo_last_context = context;
+
+    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ibo);
+  }
+}
+
+static void say_ibo_will_delete(GLuint ibo) {
+  if (ibo == say_current_ibo) {
+    say_current_ibo = 0;
+  }
+}
+
+say_index_buffer *say_index_buffer_create(GLenum type, size_t size) {
+  say_context_ensure();
+
+  say_index_buffer *buf = malloc(sizeof(say_index_buffer));
+
+  glGenBuffersARB(1, &buf->ibo);
+  buf->type = type;
+
+  buf->buffer = say_array_create(sizeof(GLuint), NULL, NULL);
+  say_array_resize(buf->buffer, size);
+
+  say_ibo_make_current(buf->ibo);
+  glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, size * sizeof(GLuint),
+                  NULL, type);
+
+  return buf;
+}
+
+void say_index_buffer_free(say_index_buffer *buf) {
+  say_context_ensure();
+
+  say_ibo_will_delete(buf->ibo);
+  glDeleteBuffersARB(1, &buf->ibo);
+  say_array_free(buf->buffer);
+  free(buf);
+}
+
+void say_index_buffer_bind(say_index_buffer *buf) {
+  say_context_ensure();
+  say_ibo_make_current(buf->ibo);
+}
+
+void say_index_buffer_unbind(say_index_buffer *buf) {
+  say_context_ensure();
+  say_ibo_make_current(0);
+}
+
+void say_index_buffer_update_part(say_index_buffer *buf, size_t index,
+                                  size_t size) {
+  say_context_ensure();
+
+  say_index_buffer_bind(buf);
+  glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
+                     index * sizeof(GLuint),
+                     size * sizeof(GLuint),
+                     say_array_get(buf->buffer, index));
+}
+
+void say_index_buffer_update(say_index_buffer *buf) {
+  say_index_buffer_update_part(buf, 0, say_array_get_size(buf->buffer));
+}
+
+size_t say_index_buffer_get_size(say_index_buffer *buf) {
+  return say_array_get_size(buf->buffer);
+}
+
+void say_index_buffer_resize(say_index_buffer *buf, size_t size) {
+  say_context_ensure();
+
+  say_array_resize(buf->buffer, size);
+  glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, size * sizeof(GLuint), NULL,
+                  buf->type);
+}
+
+GLuint *say_index_buffer_get(say_index_buffer *buf, size_t i) {
+  return say_array_get(buf->buffer, i);
+}

data/ext/say_index_buffer.h

@@ -0,0 +1,29 @@
+#ifndef SAY_INDEX_BUFFER_H_
+#define SAY_INDEX_BUFFER_H_
+
+#include "say_basic_type.h"
+#include "say_array.h"
+
+typedef struct {
+  GLuint ibo;
+  GLenum type;
+
+  say_array *buffer;
+} say_index_buffer;
+
+say_index_buffer *say_index_buffer_create(GLenum type, size_t size);
+void say_index_buffer_free(say_index_buffer *buf);
+
+void say_index_buffer_bind(say_index_buffer *buf);
+void say_index_buffer_unbind();
+
+void say_index_buffer_update_part(say_index_buffer *buf, size_t index,
+                                  size_t size);
+void say_index_buffer_update(say_index_buffer *buf);
+
+size_t say_index_buffer_get_size(say_index_buffer *buf);
+void   say_index_buffer_resize(say_index_buffer *buf, size_t size);
+
+GLuint *say_index_buffer_get(say_index_buffer *buf, size_t i);
+
+#endif

data/ext/say_index_buffer_slice.c

@@ -0,0 +1,227 @@
+#include "say.h"
+
+#define SAY_MAX_SIZE        ((size_t)-1)
+#define SAY_BUFFER_MAX_SIZE ((4 * 1024 * 1024) / sizeof(GLuint))
+#define SAY_BUFFER_MIN_SIZE ((4 * 1024) / sizeof(GLuint))
+
+typedef struct {
+  size_t loc, size;
+} say_range;
+
+#define say_make_range(begin, size) ((say_range){begin, size})
+
+typedef struct {
+  say_index_buffer *buf;
+  say_array        *ranges;
+} say_global_ibo;
+
+static say_array *say_index_buffers = NULL;
+
+static say_global_ibo say_global_ibo_create(size_t size) {
+  say_global_ibo ret;
+  ret.buf    = say_index_buffer_create(SAY_STREAM, size);
+  ret.ranges = say_array_create(sizeof(say_range), NULL, NULL);
+
+  return ret;
+}
+
+static void say_global_ibo_free(void *data) {
+  say_global_ibo *ibo = (say_global_ibo*)data;
+
+  say_index_buffer_free(ibo->buf);
+  say_array_free(ibo->ranges);
+}
+
+static say_global_ibo *say_global_ibo_at(size_t index) {
+  if (!say_index_buffers)
+    return NULL;
+  return say_array_get(say_index_buffers, index);
+}
+
+static size_t say_global_ibo_insert(say_global_ibo *ibo, size_t i,
+                                    size_t size) {
+  say_range tmp = say_make_range(0, size);
+  say_array_insert(ibo->ranges, i, &tmp);
+
+  say_range *range = say_array_get(ibo->ranges, i);
+
+  if (i != 0) {
+    say_range *prev = say_array_get(ibo->ranges, i - 1);
+    range->loc = prev->loc + prev->size;
+  }
+
+  return range->loc;
+}
+
+static size_t say_global_ibo_find_in(say_global_ibo *ibo, size_t size) {
+  size_t buffer_size = say_index_buffer_get_size(ibo->buf);
+
+  size_t     ary_size = say_array_get_size(ibo->ranges);
+  say_range *first    = say_array_get(ibo->ranges, 0);
+
+  /* There's room at the begin of the buffer */
+  if (ary_size == 0 || first->loc >= size) {
+    return say_global_ibo_insert(ibo, 0, size);
+  }
+
+  say_range *current = first, *next = NULL;
+
+  for (size_t i = 0; i < ary_size - 1; i++) {
+    next = say_array_get(ibo->ranges, i + 1);
+
+    size_t begin = current->loc + current->size;
+    size_t end   = next->loc;
+
+    /* There's enough room between those two elements */
+    if (end - begin >= size) {
+      return say_global_ibo_insert(ibo, i + 1, size);
+    }
+
+    current = next;
+  }
+
+  say_range *last = say_array_get(ibo->ranges, ary_size - 1);
+
+  /* There's enough room at the end of the buffer */
+  if ((last->loc + last->size + size) < say_index_buffer_get_size(ibo->buf)) {
+    return say_global_ibo_insert(ibo, ary_size, size);
+  }
+
+  /* Not enough room here. But perhaps we can make some? */
+  if (buffer_size < SAY_BUFFER_MAX_SIZE && size <= SAY_BUFFER_MAX_SIZE) {
+    size_t sought_size = last->loc + last->size + size;
+    size_t right_size = say_index_buffer_get_size(ibo->buf);
+
+    while (right_size < sought_size)
+      right_size *= 2;
+
+    say_index_buffer_resize(ibo->buf, right_size);
+    return say_global_ibo_insert(ibo, ary_size, size);
+  }
+  else
+    return SAY_MAX_SIZE;
+}
+
+static size_t say_global_ibo_find(size_t size, size_t *buf_id) {
+  if (!say_index_buffers) {
+    say_index_buffers = say_array_create(sizeof(say_global_ibo),
+                                         say_global_ibo_free,
+                                         NULL);
+  }
+
+  size_t i = 0;
+  for (say_global_ibo *ibo = say_array_get(say_index_buffers, 0);
+       ibo;
+       say_array_next(say_index_buffers, (void**)&ibo)) {
+    size_t loc;
+    if ((loc = say_global_ibo_find_in(ibo, size)) != SAY_MAX_SIZE) {
+      *buf_id = i;
+      return loc;
+    }
+
+    i++;
+  }
+
+  /* Could not find enough room in previous buffers. Let's create a new one. */
+  size_t buf_size = SAY_BUFFER_MIN_SIZE;
+  if (size > SAY_BUFFER_MAX_SIZE)
+    buf_size = size;
+  else {
+    while (buf_size < size)
+      buf_size *= 2;
+  }
+
+  say_global_ibo ibo = say_global_ibo_create(buf_size);
+  say_array_push(say_index_buffers, &ibo);
+
+  *buf_id = say_array_get_size(say_index_buffers) - 1;
+  return say_global_ibo_find_in(say_global_ibo_at(*buf_id), size);
+}
+
+static void say_global_ibo_delete_at(say_global_ibo *ibo, size_t loc) {
+  if (!ibo)
+    return;
+
+  size_t n = 0, size = say_array_get_size(ibo->ranges);
+  for (; n < size; n++) {
+    say_range *range = say_array_get(ibo->ranges, n);
+    if (range->loc == loc)
+      break;
+  }
+
+  if (n == size)
+    return; /* Element could not be found */
+
+  say_array_delete(ibo->ranges, n);
+}
+
+static void say_global_ibo_reduce_size(say_global_ibo *ibo, size_t loc,
+                                       size_t size) {
+  for (say_range *range = say_array_get(ibo->ranges, 0); range;
+       say_array_next(ibo->ranges, (void**)&range)) {
+    if (range->loc == loc) {
+      range->size = size;
+      return;
+    }
+  }
+}
+
+static say_index_buffer *say_ibo_at(size_t index) {
+  if (!say_index_buffers)
+    return NULL;
+  return say_global_ibo_at(index)->buf;
+}
+
+say_index_buffer_slice *say_index_buffer_slice_create(size_t size) {
+  say_index_buffer_slice *slice = malloc(sizeof(say_index_buffer_slice));
+  slice->loc  = say_global_ibo_find(size, &slice->buf_id);
+  slice->size = size;
+  return slice;
+}
+
+void say_index_buffer_slice_free(say_index_buffer_slice *slice) {
+  say_global_ibo_delete_at(say_global_ibo_at(slice->buf_id), slice->loc);
+  free(slice);
+}
+
+void say_index_buffer_slice_recreate(say_index_buffer_slice *slice,
+                                     size_t size) {
+ if (size > slice->size) {
+   say_global_ibo_delete_at(say_global_ibo_at(slice->buf_id), slice->loc);
+   slice->loc = say_global_ibo_find(size, &slice->buf_id);
+  }
+ else {
+   say_global_ibo_reduce_size(say_global_ibo_at(slice->buf_id),
+                                 slice->loc, size);
+ }
+
+  slice->size = size;
+}
+
+size_t say_index_buffer_slice_get_loc(say_index_buffer_slice *slice) {
+  return slice->loc;
+}
+
+size_t say_index_buffer_slice_get_size(say_index_buffer_slice *slice) {
+  return slice->size;
+}
+
+GLuint *say_index_buffer_slice_get(say_index_buffer_slice *slice, size_t id) {
+  return say_index_buffer_get(say_ibo_at(slice->buf_id), slice->loc + id);
+}
+
+void say_index_buffer_slice_update(say_index_buffer_slice *slice) {
+  say_index_buffer_update_part(say_ibo_at(slice->buf_id), slice->loc,
+                               slice->size);
+}
+
+void say_index_buffer_slice_bind(say_index_buffer_slice *slice) {
+  say_index_buffer_bind(say_ibo_at(slice->buf_id));
+}
+
+void say_index_buffer_slice_clean_up() {
+  if (say_index_buffers) {
+    say_array_free(say_index_buffers);
+    say_index_buffers = NULL;
+  }
+}

data/ext/say_index_buffer_slice.h

@@ -0,0 +1,28 @@
+#ifndef SAY_INDEX_BUFFER_SLICE_H_
+#define SAY_INDEX_BUFFER_SLICE_H_
+
+#include "say_basic_type.h"
+
+typedef struct {
+  size_t buf_id;
+  size_t loc;
+  size_t size;
+} say_index_buffer_slice;
+
+say_index_buffer_slice *say_index_buffer_slice_create(size_t size);
+void say_index_buffer_slice_free(say_index_buffer_slice *slice);
+
+void say_index_buffer_slice_recreate(say_index_buffer_slice *slice,
+                                     size_t size);
+
+size_t say_index_buffer_slice_get_loc(say_index_buffer_slice *slice);
+size_t say_index_buffer_slice_get_size(say_index_buffer_slice *slice);
+
+GLuint *say_index_buffer_slice_get(say_index_buffer_slice *slice, size_t id);
+
+void say_index_buffer_slice_update(say_index_buffer_slice *slice);
+void say_index_buffer_slice_bind(say_index_buffer_slice *slice);
+
+void say_index_buffer_slice_clean_up();
+
+#endif