ray 0.2.0 → 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c843cd687fe51478f64ee9e801e9ee9132f6ee4b
+  data.tar.gz: dc17809793037e626252a10c884847236cd0834b
+SHA512:
+  metadata.gz: b94b4d5571a75a68ddd840ddae8987c0ac4e71a7823f5019021ac9ea127f03658c7c582c9c6bba81ecc44732d4e4510a8c557964c242373d194d8d9bcca3377e
+  data.tar.gz: 8c4e58c2d0d9df0817349e4e1cc662b7e1645876435b44dd4f2dd62ab364e3510b0468f8ec5ab87ea9e1ef2631c9cececdd6ae0d18dfca38693eb5fd439e68fb

data/LICENSE

@@ -0,0 +1,21 @@
+Ray - Copyright (c) 2011 - Mon ouïe
+
+This software is provided 'as-is', without any express or
+implied warranty. In no event will the authors be held
+liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute
+it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented;
+   you must not claim that you wrote the original software.
+   If you use this software in a product, an acknowledgment
+   in the product documentation would be appreciated but
+   is not required.
+
+2. Altered source versions must be plainly marked as such,
+   and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any
+   source distribution.

data/README.md

@@ -261,4 +261,3 @@ using Ray's animation objects:
 
 (They can really be used to animate any change, not just those that are visible,
 and not just those applied to a drawable.)
-

data/ext/drawable.c

@@ -123,6 +123,8 @@ VALUE ray_drawable_alloc(VALUE self) {
 
   VALUE rb = Data_Wrap_Struct(self, NULL, ray_drawable_free, obj);
 
+  rb_iv_set(rb, "@shader_attributes", Qnil);
+
   obj->drawable = NULL;
   obj->obj      = rb;
 
@@ -389,6 +391,23 @@ VALUE ray_drawable_set_matrix(VALUE self, VALUE val) {
   return val;
 }
 
+/*
+ * @overload default_matrix
+ *   Default transformation matrix
+ *
+ *   This is useful when matrix is set to a custom matrix or matrix_proc is
+ *   non-nil. It allows to retrieve the matrix that would be used otherwise, for
+ *   instance to multiply it by another matrix to apply more transformations.
+ *
+ *   @return [Ray::Matrix]
+ */
+static
+VALUE ray_drawable_default_matrix(VALUE self) {
+  say_matrix *mat = say_drawable_get_default_matrix(ray_rb2drawable(self));
+  return Data_Wrap_Struct(rb_path2class("Ray::Matrix"), NULL, say_matrix_free,
+                          mat);
+}
+
 /*
  *  @overload transform(point)
  *    Applies the transformations to a point
@@ -577,6 +596,8 @@ void Init_ray_drawable() {
 
   rb_define_method(ray_cDrawable, "matrix", ray_drawable_matrix, 0);
   rb_define_method(ray_cDrawable, "matrix=", ray_drawable_set_matrix, 1);
+  rb_define_method(ray_cDrawable, "default_matrix",
+                   ray_drawable_default_matrix, 0);
   rb_define_method(ray_cDrawable, "transform", ray_drawable_transform, 1);
   /* @endgroup */
 

data/ext/extconf.rb

@@ -1,6 +1,6 @@
 require 'mkmf'
 
-$CFLAGS  << " -Wextra -Wall -Wno-unused-parameter -std=gnu99"
+$CFLAGS  << " -Wextra -Wall -Wno-unused-parameter -std=gnu99 "
 
 unless RUBY_PLATFORM =~ /mingw/
   $CFLAGS  << " " << `freetype-config --cflags`.chomp

data/ext/image.c

@@ -230,12 +230,29 @@ VALUE ray_image_tex_rect(VALUE self, VALUE rect) {
 /*
  * Binds the texture, which will be used as GL_TEXTURE_2D when drawing with
  * OpenGL
+ *
+ * This is equivalent to calling #bind_to with unit set to 0.
  */
 VALUE ray_image_bind(VALUE self) {
   say_image_bind(ray_rb2image(self));
   return self;
 }
 
+/*
+ * @overload bind_to(unit)
+ *   Binds the texture to a given unit (0 <= unit < 32)
+ *   @param [Integer] unit Texture unit
+ */
+VALUE ray_image_bind_to(VALUE self, VALUE unit) {
+  int c_unit = NUM2INT(unit);
+  if (c_unit >= 32 || c_unit < 0)
+    rb_raise(rb_eRangeError, "texture unit %d out of bounds", c_unit);
+
+  say_image_bind_to(ray_rb2image(self), c_unit);
+
+  return self;
+}
+
 /*
  * @return [Integer] Identifer of the image's texture
  */
@@ -322,6 +339,7 @@ void Init_ray_image() {
 
   /* @group OpenGL access */
   rb_define_method(ray_cImage, "bind", ray_image_bind, 0);
+  rb_define_method(ray_cImage, "bind_to", ray_image_bind_to, 1);
   rb_define_method(ray_cImage, "texture", ray_image_texture, 0);
   /* @endgroup */
 }

data/ext/matrix.c

@@ -336,6 +336,33 @@ VALUE ray_matrix_perspective(VALUE self,
   return self;
 }
 
+/*
+ * @overload set_transformation(origin, pos, z, scale, angle)
+ *   Resets the matrix content to a 2D transformation matrix
+ *
+ *   @param [Vector2] origin Origin of all the transformations
+ *   @param [Vector2] pos Position of the object
+ *   @param [Float] z Z ordering
+ *   @param [Vector2] scale Scaling factor
+ *   @param [Float] angle Rotation
+ */
+static
+VALUE ray_matrix_set_transformation(VALUE self,
+                                    VALUE origin,
+                                    VALUE pos, VALUE z,
+                                    VALUE scale,
+                                    VALUE angle) {
+  rb_check_frozen(self);
+
+  say_matrix_set_transformation(ray_rb2matrix(self),
+                                ray_convert_to_vector2(origin),
+                                ray_convert_to_vector2(pos),
+                                NUM2DBL(z),
+                                ray_convert_to_vector2(scale),
+                                NUM2DBL(angle));
+
+  return self;
+}
 
 /*
   Document-class: Ray::Matrix
@@ -371,4 +398,6 @@ void Init_ray_matrix() {
   rb_define_method(ray_cMatrix, "look_at", ray_matrix_look_at, 3);
   rb_define_method(ray_cMatrix, "orthogonal", ray_matrix_orthogonal, 6);
   rb_define_method(ray_cMatrix, "perspective", ray_matrix_perspective, 4);
+  rb_define_method(ray_cMatrix, "set_transformation",
+                   ray_matrix_set_transformation, 5);
 }

data/ext/mo.c

@@ -28,7 +28,7 @@ void mo_array_init(mo_array *ary, size_t el_size) {
 }
 
 void mo_array_release(mo_array *ary) {
-  if (ary->release && ary->size > 0) {
+  if (ary->release) {
     void *end = mo_array_end(ary);
     for (void *i = mo_array_begin(ary); i < end; mo_array_next(ary, &i))
       ary->release(i);
@@ -168,114 +168,174 @@ void mo_array_reserve(mo_array *ary, size_t size) {
   if (ary->capa > size)
     return;
 
-  ary->buffer = realloc(ary->buffer, size * ary->el_size);
+  ary->buffer = realloc(ary->buffer, size * ary->capa);
   ary->capa   = size;
 }
 
 void mo_array_shrink(mo_array *ary) {
-  if (ary->capa == ary->size) return;
-  ary->buffer = realloc(ary->buffer, ary->size * ary->el_size);
+  ary->buffer = realloc(ary->buffer, ary->size * ary->capa);
   ary->capa   = ary->size;
 }
 
 /**
- * Doubly linked list.
+ * String.
  */
 
-mo_list *mo_list_create(size_t el_size) {
-  mo_list *list = malloc(sizeof(mo_list) + el_size);
+void mo_string_init(mo_string *str) {
+  mo_array_init(str, sizeof(char));
+  mo_array_resize(str, 1);
+  mo_string_at(str, 0) = '\0';
+}
+
+void mo_string_init_from_cstr(mo_string *str, const char *cstr) {
+  mo_string_init(str);
+  mo_string_replace(str, cstr);
+}
+
+void mo_string_init_from_buf(mo_string *str, const char *cstr, size_t size) {
+  mo_string_init(str);
+  mo_array_resize(str, size + 1);
+  memcpy(mo_string_cstr(str), cstr, size);
+  mo_string_at(str, size) = '\0';
+}
+
+void mo_string_replace(mo_string *str, const char *cstr) {
+  mo_array_resize(str, strlen(cstr) + 1);
+  strcpy(mo_string_cstr(str), cstr);
+}
+
+size_t mo_string_len(mo_string *str) {
+  return str->size - 1;
+}
+
+void mo_string_append(mo_string *str, const char *cstr) {
+  size_t old_size = str->size;
+
+  mo_array_resize(str, old_size + strlen(cstr));
+  strcpy(mo_array_get_ptr(str, old_size - 1, char), cstr);
+}
+
+char *mo_string_cstr(mo_string *str) {
+  return (char*)str->buffer;
+}
+
+int mo_string_cmp(mo_string *a, mo_string *b) {
+  return strcmp(mo_string_cstr(a), mo_string_cstr(b));
+}
+
+/**
+ * Doubly linked list.
+ */
 
-  list->prev = list->next = NULL;
+void mo_list_init(mo_list *list, size_t el_size) {
+  list->head = list->last = NULL;
 
   list->release = NULL;
   list->copy    = NULL;
 
   list->el_size = el_size;
-
-  return list;
 }
 
-void mo_list_free(mo_list *list) {
-  do {
-    mo_list *next = list->next;
+void mo_list_release(mo_list *list) {
+  mo_list_it *it = list->head;
+
+  while (it) {
+    mo_list_it *next = it->next;
 
     if (list->release)
-      list->release(list->data);
-    free(list);
+      list->release(it->data);
+    free(it);
 
-    list = next;
-  } while (list);
+    it = next;
+  }
 }
 
-mo_list *mo_list_prepend(mo_list *list, void *data) {
-  mo_list *prev = malloc(sizeof(mo_list) + list->el_size);
+mo_list *mo_list_create(size_t el_size) {
+  mo_list *list = malloc(sizeof(mo_list));
+  mo_list_init(list, el_size);
+  return list;
+}
 
-  prev->prev = list->prev;
-  prev->next = list;
+void mo_list_free(mo_list *list) {
+  mo_list_release(list);
+  free(list);
+}
 
-  if (list->prev)
-    list->prev->next = list;
+void mo_list_prepend(mo_list *list, mo_list_it *it, void *data) {
+  mo_list_it *new_it = malloc(offsetof(mo_list_it, data) + list->el_size);
 
-  list->prev = prev;
+  new_it->next = it;
 
-  prev->release = list->release;
-  prev->copy    = list->copy;
+  if (it && it->prev) {
+    new_it->prev   = it->prev;
+    it->prev->next = new_it;
+  }
+  else
+    new_it->prev = NULL;
 
-  prev->el_size = list->el_size;
+  if (it)
+    it->prev = new_it;
 
-  if (prev->copy)
-    prev->copy(prev->data, data);
-  else if (data)
-    memcpy(prev->data, data, prev->el_size);
+  if (!list->last)
+    list->last = new_it;
 
-  return prev;
-}
+  if (it == list->head)
+    list->head = new_it;
 
-mo_list *mo_list_insert(mo_list *list, void *data) {
-  mo_list *next = malloc(sizeof(mo_list) + list->el_size);
+  if (list->copy)
+    list->copy(new_it->data, data);
+  else
+    memcpy(new_it->data, data, list->el_size);
+}
 
-  next->prev = list;
-  next->next = list->next;
+void mo_list_insert(mo_list *list, mo_list_it *it, void *data) {
+  mo_list_it *new_it = malloc(offsetof(mo_list_it, data) + list->el_size);
 
-  if (list->next)
-    list->next->prev = next;
+  new_it->prev = it;
 
-  list->next = next;
+  if (it && it->next) {
+    new_it->next = it->next;
+    it->next->prev = new_it;
+  }
+  else
+    new_it->next = NULL;
 
-  next->release = list->release;
-  next->copy    = list->copy;
+  if (it)
+    it->next = new_it;
 
-  next->el_size = list->el_size;
+  if (!list->head)
+    list->head = new_it;
 
-  if (next->copy)
-    next->copy(next->data, data);
-  else if (data)
-    memcpy(next->data, data, next->el_size);
+  if (it == list->last)
+    list->last = new_it;
 
-  return next;
+  if (list->copy)
+    list->copy(new_it->data, data);
+  else
+    memcpy(new_it->data, data, list->el_size);
 }
 
-mo_list *mo_list_delete(mo_list *list) {
-  if (list->prev)
-    list->prev->next = list->next;
-
-  if (list->next)
-    list->next->prev = list->prev;
+void mo_list_delete(mo_list *list, mo_list_it *it) {
+  if (it->prev)
+    it->prev->next = it->next;
+  else /* is head */
+    list->head = it->next;
 
-  mo_list *next = list->next;
+  if (it->next)
+    it->next->prev = it->prev;
+  else /* is tail */
+    list->last = it->prev;
 
   if (list->release)
-    list->release(list->data);
-  free(list);
-
-  return next;
+    list->release(it->data);
+  free(it);
 }
 
-void mo_list_set(mo_list *list, void *data) {
+void mo_list_set(mo_list *list, mo_list_it *it, void *data) {
   if (list->copy)
-    list->copy(list->data, data);
+    list->copy(it->data, data);
   else
-    memcpy(list->data, data, list->el_size);
+    memcpy(it->data, data, list->el_size);
 }
 
 /**
@@ -287,34 +347,11 @@ void mo_hash_zero_ptr(void *ptr) {
   *(void**)ptr = NULL;
 }
 
-static
-void mo_hash_list_free(void *ptr) {
-  mo_list *list = *(mo_list**)ptr;
-  if (list) mo_list_free(list);
-}
-
-static
-void mo_hash_bucket_free(void *ptr) {
-  uint8_t *start = ptr;
-
-  mo_hash *hash = *(mo_hash**)start;
-  if (!hash)
-    return;
-
-  if (hash->key_release)
-    hash->key_release(start + sizeof(mo_hash*));
-
-  if (hash->release)
-    hash->release(start + sizeof(mo_hash*) + hash->key_size);
-}
-
-static
 void mo_hash_init(mo_hash *hash, size_t key_size, size_t el_size) {
-  mo_array_init(&hash->buffer, sizeof(mo_list*));
+  mo_array_init(&hash->buffer, sizeof(mo_hash_list*));
 
-  hash->buffer.init    = mo_hash_zero_ptr;
+  hash->buffer.init = mo_hash_zero_ptr;
   mo_array_resize(&hash->buffer, 16);
-  hash->buffer.release = mo_hash_list_free;
 
   hash->release = NULL;
   hash->copy    = NULL;
@@ -331,8 +368,23 @@ void mo_hash_init(mo_hash *hash, size_t key_size, size_t el_size) {
   hash->hash_of = NULL;
 }
 
-static
 void mo_hash_release(mo_hash *hash) {
+  for (size_t i = 0; i < hash->buffer.size; i++) {
+    mo_hash_list *it = mo_array_get_as(&hash->buffer, i, mo_hash_list*);
+
+    while (it) {
+      mo_hash_list *next = it->next;
+
+      if (hash->key_release)
+        hash->key_release(it->data);
+      if (hash->release)
+        hash->release(it->data + hash->key_size);
+      free(it);
+
+      it = next;
+    }
+  }
+
   mo_array_release(&hash->buffer);
 }
 
@@ -349,12 +401,11 @@ void mo_hash_free(mo_hash *hash) {
 
 bool mo_hash_has_key(mo_hash *hash, void *key) {
   int id = hash->hash_of(key) % hash->buffer.size;
-  mo_list *bucket = mo_array_get_as(&hash->buffer, id, mo_list*);
+  mo_hash_list *it = mo_array_get_as(&hash->buffer, id, mo_hash_list*);
 
-  while (bucket) {
-    if (hash->key_cmp(bucket->data + sizeof(mo_hash*), key) == 0)
+  for (; it; it = it->next) {
+    if (hash->key_cmp(it->data, key) == 0)
       return true;
-    bucket = bucket->next;
   }
 
   return false;
@@ -362,12 +413,11 @@ bool mo_hash_has_key(mo_hash *hash, void *key) {
 
 void *mo_hash_get(mo_hash *hash, void *key) {
   int id = hash->hash_of(key) % hash->buffer.size;
-  mo_list *bucket = mo_array_get_as(&hash->buffer, id, mo_list*);
+  mo_hash_list *it = mo_array_get_as(&hash->buffer, id, mo_hash_list*);
 
-  while (bucket) {
-    if (hash->key_cmp(bucket->data + sizeof(mo_hash*), key) == 0)
-      return bucket->data + sizeof(mo_hash*) + hash->key_size;
-    bucket = bucket->next;
+  for (; it; it = it->next) {
+    if (hash->key_cmp(it->data, key) == 0)
+      return it->data + hash->key_size;
   }
 
   return NULL;
@@ -402,34 +452,22 @@ void mo_hash_grow(mo_hash *hash) {
   /*
    * Release the current hash, and use the copy instead.
    */
-  mo_hash_release(hash);
-  *hash = copy;
-
-  /*
-   * Because each element actually contains a pointer to the hash, we need to
-   * update it.
-   */
+  mo_array_release(&hash->buffer);
 
-  it = mo_hash_begin(hash);
-  for (; !mo_hash_it_is_end(&it); mo_hash_it_next(&it)) {
-    mo_hash **data = (mo_hash**)(it.list->data);
-    *data          = hash;
-  }
+  *hash = copy;
 }
 
 static
 void mo_hash_fill_bucket(mo_hash *hash, void *store, void *key, void *data) {
-  *(mo_hash**)store = hash;
-
   if (hash->key_copy)
-    hash->key_copy((uint8_t*)store + sizeof(mo_hash*), key);
+    hash->key_copy((uint8_t*)store, key);
   else
-    memcpy((uint8_t*)store + sizeof(mo_hash*), key, hash->key_size);
+    memcpy((uint8_t*)store, key, hash->key_size);
 
   if (hash->copy)
-    hash->copy((uint8_t*)store + sizeof(mo_hash*) + hash->key_size, data);
+    hash->copy((uint8_t*)store + hash->key_size, data);
   else
-    memcpy((uint8_t*)store + sizeof(mo_hash*) + hash->key_size, data,
+    memcpy((uint8_t*)store + hash->key_size, data,
            hash->el_size);
 }
 
@@ -438,30 +476,31 @@ void mo_hash_set(mo_hash *hash, void *key, void *data) {
     mo_hash_grow(hash);
 
   int id = hash->hash_of(key) % hash->buffer.size;
-  mo_list *bucket = mo_array_get_as(&hash->buffer, id, mo_list*);
+  mo_hash_list *bucket = mo_array_get_as(&hash->buffer, id, mo_hash_list*);
 
   hash->size += 1;
 
   if (!bucket) {
-    bucket = mo_list_create(sizeof(mo_hash*) + hash->key_size + hash->el_size);
-    bucket->release = mo_hash_bucket_free;
+    bucket = malloc(offsetof(mo_hash_list, data) +
+                    hash->key_size + hash->el_size);
 
+    bucket->next = NULL;
     mo_hash_fill_bucket(hash, bucket->data, key, data);
 
-    mo_array_get_as(&hash->buffer, id, mo_list*) = bucket;
+    mo_array_get_as(&hash->buffer, id, mo_hash_list*) = bucket;
   }
   else {
-    mo_list *it = bucket, *last = bucket;
+    mo_hash_list *it = bucket, *last = bucket;
+
     while (it) {
-      if (hash->key_cmp(it->data + sizeof(mo_hash*), key) == 0) {
+      if (hash->key_cmp(it->data, key) == 0) {
         hash->size -= 1;
 
         if (hash->copy) {
-          hash->copy(it->data + sizeof(mo_hash*) + hash->key_size, data);
+          hash->copy(it->data + hash->key_size, data);
         }
         else {
-          memcpy(it->data + sizeof(mo_hash*) + hash->key_size, data,
-                 hash->el_size);
+          memcpy(it->data + hash->key_size, data, hash->el_size);
         }
 
         return;
@@ -471,28 +510,41 @@ void mo_hash_set(mo_hash *hash, void *key, void *data) {
       it   = it->next;
     }
 
-    last = mo_list_insert(last, NULL);
+    last = malloc(offsetof(mo_hash_list, data) +
+                  hash->key_size + hash->el_size);
+    last->next = NULL;
     mo_hash_fill_bucket(hash, last->data, key, data);
+
+    bucket->next = last;
   }
 }
 
 void mo_hash_del(mo_hash *hash, void *key) {
   int id = hash->hash_of(key) % hash->buffer.size;
-  mo_list *bucket = mo_array_get_as(&hash->buffer, id, mo_list*);
+  mo_hash_list *bucket = mo_array_get_as(&hash->buffer, id, mo_hash_list*);
 
-  mo_list *it = bucket, *next = bucket->next;
+  mo_hash_list *it = bucket, *next = bucket->next, *prev = NULL;
   while (it) {
-    if (hash->key_cmp(it->data + sizeof(mo_hash*), key) == 0) {
+    if (hash->key_cmp(it->data, key) == 0) {
       hash->size -= 1;
-      mo_list_delete(it);
+
+      if (prev)
+        prev->next = it->next;
+      else /* is head */
+        mo_array_get_as(&hash->buffer, id, mo_hash_list*) = next;
+
+      if (hash->key_release)
+        hash->key_release(it->data);
+      if (hash->release)
+        hash->release(it->data + hash->key_size);
+      free(it);
+
       break;
     }
 
-    it = it->next;
+    prev = it;
+    it   = it->next;
   }
-
-  if (it == bucket) /* Head changed */
-    mo_array_get_as(&hash->buffer, id, mo_list*) = next;
 }
 
 mo_hash_it mo_hash_begin(mo_hash *hash) {
@@ -503,7 +555,9 @@ mo_hash_it mo_hash_begin(mo_hash *hash) {
   };
 
   for (ret.id = 0; ret.id < hash->buffer.size; ret.id++) {
-    mo_list *bucket = mo_array_get_as(&hash->buffer, ret.id, mo_list*);
+    mo_hash_list *bucket = mo_array_get_as(&hash->buffer, ret.id,
+                                           mo_hash_list*);
+
     if (bucket) {
       ret.list = bucket;
       break;
@@ -518,11 +572,11 @@ bool mo_hash_it_is_end(mo_hash_it *it) {
 }
 
 void *mo_hash_it_key(mo_hash_it *it) {
-  return it->list->data + sizeof(mo_hash*);
+  return it->list->data;
 }
 
 void *mo_hash_it_val(mo_hash_it *it) {
-  return it->list->data + sizeof(mo_hash*) + it->hash->key_size;
+  return it->list->data + it->hash->key_size;
 }
 
 void mo_hash_it_next(mo_hash_it *it) {
@@ -532,7 +586,8 @@ void mo_hash_it_next(mo_hash_it *it) {
     it->list = NULL;
 
     for (it->id++; it->id < it->hash->buffer.size; it->id++) {
-      mo_list *bucket = mo_array_get_as(&it->hash->buffer, it->id, mo_list*);
+      mo_hash_list *bucket = mo_array_get_as(&it->hash->buffer, it->id,
+                                             mo_hash_list*);
       if (bucket) {
         it->list = bucket;
         return;
@@ -559,7 +614,7 @@ int mo_hash_pointer_cmp(const void *a, const void *b) {
 }
 
 int mo_hash_of_u32(void *ptr) {
-  return (*(uint32_t*)ptr) * MAGIC_NUMBER;
+  return *(uint32_t*)ptr * MAGIC_NUMBER;
 }
 
 int mo_hash_u32_cmp(const void *a, const void *b) {
@@ -571,7 +626,7 @@ int mo_hash_u32_cmp(const void *a, const void *b) {
 }
 
 int mo_hash_of_size(void *ptr) {
-  return (*(size_t*)ptr) * MAGIC_NUMBER;
+  return *(size_t*)ptr * MAGIC_NUMBER;
 }
 
 int mo_hash_size_cmp(const void *a, const void *b) {