ray 0.1.1 → 0.2.0

data/ext/gl_buffer.c

@@ -48,20 +48,66 @@ VALUE ray_gl_buffer_init(VALUE self, VALUE type, VALUE vtype) {
   return self;
 }
 
-/* Unbinds any buffer that was bound. */
+/* @return [Boolean] True if the buffer has instance-specific data */
+static
+VALUE ray_gl_buffer_has_instance(VALUE self) {
+  return say_buffer_has_instance(ray_rb2buffer(self)) ? Qtrue : Qfalse;
+}
+
+/* Unbinds any bound buffer */
 static
 VALUE ray_gl_buffer_unbind(VALUE self) {
   say_buffer_unbind();
   return Qnil;
 }
 
-/* Binds the receiver */
+/* Unbinds any bound VBO from array buffer */
+static
+VALUE ray_gl_buffer_unbind_vbo(VALUE self) {
+  say_buffer_unbind_vbo();
+  return Qnil;
+}
+
+/* Binds the receiver, allowing to draw data stored in it */
 static
 VALUE ray_gl_buffer_bind(VALUE self) {
   say_buffer_bind(ray_rb2buffer(self));
   return self;
 }
 
+/* Binds the receivers's VBO as an OpenGL array buffer */
+static
+VALUE ray_gl_buffer_bind_vbo(VALUE self) {
+  say_buffer_bind_vbo(ray_rb2buffer(self));
+  return self;
+}
+
+/*
+ * Binds the receivers's VBO containing instance data as an OpenGL array buffer
+ */
+static
+VALUE ray_gl_buffer_bind_instance_vbo(VALUE self) {
+  say_buffer_bind_instance_vbo(ray_rb2buffer(self));
+  return self;
+}
+
+/*
+ * @return [Integer] The identifier of the OpenGL buffer used by the buffer
+ */
+static
+VALUE ray_gl_buffer_vbo(VALUE self) {
+  return ULONG2NUM(say_buffer_get_vbo(ray_rb2buffer(self)));
+}
+
+/*
+ * @return [Integer] The identifier of the OpenGL buffer used by the buffer to
+ *   store per-instance data
+ */
+static
+VALUE ray_gl_buffer_instance_vbo(VALUE self) {
+  return ULONG2NUM(say_buffer_get_instance_vbo(ray_rb2buffer(self)));
+}
+
 /*
  * @overload [](id)
  *   @param [Integer] id
@@ -123,6 +169,77 @@ VALUE ray_gl_buffer_set(VALUE self, VALUE i, VALUE vertex) {
 
   return vertex;
 }
+/*
+ * @overload get_instance(id)
+ *   @param [Integer] id
+ *   @return [Ray::GL::Vertex::Instance] The instance at the given index
+ */
+static
+VALUE ray_gl_buffer_get_instance(VALUE self, VALUE i) {
+  say_buffer *buf = ray_rb2buffer(self);
+
+  if (!say_buffer_has_instance(buf))
+    rb_raise(rb_eRuntimeError, "buffer has no instance data");
+
+  size_t size  = say_buffer_get_instance_size(buf);
+  size_t index = NUM2ULONG(i);
+
+  if (index >= size)
+    return Qnil;
+
+  VALUE klass  = rb_const_get(rb_iv_get(self, "@vertex_type"),
+                              rb_intern("Instance"));
+  VALUE object = rb_funcall(klass, RAY_METH("allocate"), 0);
+
+  size_t byte_size  = NUM2INT(rb_iv_get(klass, "@vertex_instance_size"));
+
+  void *ptr = NULL;
+  Data_Get_Struct(object, void, ptr);
+
+  memcpy(ptr, say_buffer_get_instance(buf, index), byte_size);
+
+  return object;
+}
+
+/*
+ * @overload set_intance(id, value)
+ *   @param [Integer] id
+ *   @param [Ray::GL::Vertex::Instance] value The instance to set the given
+ *     index.
+ */
+static
+VALUE ray_gl_buffer_set_instance(VALUE self, VALUE i, VALUE vertex) {
+  rb_check_frozen(self);
+
+  say_buffer *buf = ray_rb2buffer(self);
+
+  if (!say_buffer_has_instance(buf))
+    rb_raise(rb_eRuntimeError, "buffer has no instance data");
+
+  VALUE klass = rb_const_get(rb_iv_get(self, "@vertex_type"),
+                              rb_intern("Instance"));
+  if (!RAY_IS_A(vertex, klass)) {
+    rb_raise(rb_eTypeError, "Can't convert %s into %s",
+             RAY_OBJ_CLASSNAME(vertex), rb_class2name(klass));
+  }
+
+  size_t size  = say_buffer_get_instance_size(buf);
+  size_t index = NUM2ULONG(i);
+
+  if (index >= size) {
+    rb_raise(rb_eRangeError, "%zu is outside of range 0...%zu",
+             size, index);
+  }
+
+  size_t byte_size = NUM2INT(rb_iv_get(klass, "@vertex_instance_size"));
+
+  void *ptr = NULL;
+  Data_Get_Struct(vertex, void, ptr);
+
+  memcpy(say_buffer_get_instance(buf, index), ptr, byte_size);
+
+  return vertex;
+}
 
 /*
  * @overload update(range = 0...size)
@@ -176,6 +293,60 @@ VALUE ray_gl_buffer_update(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+/*
+ * @overload update_instance(range = 0...size)
+ *   @param [Range<Integer>] range (see #update)
+ *
+ *   Updates a part of the buffer's instance-specific data
+ *
+ * @overload update_instance(first, size)
+ *   @param (see #update)
+ */
+static
+VALUE ray_gl_buffer_update_instance(int argc, VALUE *argv, VALUE self) {
+  say_buffer *buf       = ray_rb2buffer(self);
+  size_t      max_index = say_buffer_get_instance_size(buf);
+
+  if (!say_buffer_has_instance(buf))
+    rb_raise(rb_eRuntimeError, "buffer has no per-instance data");
+
+  if (argc == 0)
+    say_buffer_update_instance(buf);
+  else if (argc == 2) {
+    size_t begin = NUM2ULONG(argv[0]);
+    size_t end   = NUM2ULONG(argv[1]);
+
+    if (end > max_index)
+      end = max_index;
+
+    if (begin > end || begin > max_index)
+      return self;
+
+    size_t size = (end - begin) + 1;
+
+    say_buffer_update_instance_part(buf, begin, size);
+  }
+  else {
+    VALUE range;
+    rb_scan_args(argc, argv, "1", &range); /* raise exception */
+
+    size_t begin = NUM2ULONG(rb_funcall(range, RAY_METH("begin"), 0));
+    size_t end   = NUM2ULONG(rb_funcall(range, RAY_METH("end"), 0));
+
+    if (end > max_index)
+      end = max_index;
+
+    if (begin > end || begin > max_index)
+      return self;
+
+    size_t size = (end - begin) + 1;
+
+    say_buffer_update_instance_part(buf, begin, size);
+  }
+
+  return self;
+}
+
 /* @return [Integer] Size of the buffer (amount of vertices it contains) */
 static
 VALUE ray_gl_buffer_size(VALUE self) {
@@ -195,6 +366,32 @@ VALUE ray_gl_buffer_resize(VALUE self, VALUE size) {
   return self;
 }
 
+/* @return [Integer] Amount of per-instance blocks in the buffer */
+static
+VALUE ray_gl_buffer_instance_size(VALUE self) {
+  say_buffer *buf = ray_rb2buffer(self);
+  if (!say_buffer_has_instance(buf))
+    return Qnil;
+  return ULONG2NUM(say_buffer_get_instance_size(buf));
+}
+
+/*
+ * @overload resize_instance(size)
+ *   @param [Integere] size (see #resize)
+ *
+ *   Resizes the buffer's instance data, alsos causing it to be updated.
+ */
+static
+VALUE ray_gl_buffer_resize_instance(VALUE self, VALUE size) {
+  rb_check_frozen(self);
+  say_buffer *buf = ray_rb2buffer(self);
+  if (!say_buffer_has_instance(buf))
+    rb_raise(rb_eRuntimeError, "buffer has no per-instance data");
+  say_buffer_resize_instance(buf, NUM2ULONG(size));
+  return self;
+}
+
+
 /*
  * Document-class: Ray::GL::Buffer
  *
@@ -211,14 +408,38 @@ void Init_ray_gl_buffer() {
   rb_define_alloc_func(ray_cGLBuffer, ray_gl_buffer_alloc);
   rb_define_method(ray_cGLBuffer, "initialize", ray_gl_buffer_init, 2);
 
+  rb_define_method(ray_cGLBuffer, "has_instance?", ray_gl_buffer_has_instance,
+                   0);
+
   rb_define_singleton_method(ray_cGLBuffer, "unbind", ray_gl_buffer_unbind, 0);
+  rb_define_singleton_method(ray_cGLBuffer, "unbind_vbo",
+                             ray_gl_buffer_unbind_vbo, 0);
   rb_define_method(ray_cGLBuffer, "bind", ray_gl_buffer_bind, 0);
+  rb_define_method(ray_cGLBuffer, "bind_vbo", ray_gl_buffer_bind_vbo, 0);
+  rb_define_method(ray_cGLBuffer, "bind_instance_vbo",
+                   ray_gl_buffer_bind_instance_vbo, 0);
+
+  rb_define_method(ray_cGLBuffer, "vbo", ray_gl_buffer_vbo, 0);
+  rb_define_method(ray_cGLBuffer, "instance_vbo", ray_gl_buffer_instance_vbo,
+                   0);
 
   rb_define_method(ray_cGLBuffer, "[]",  ray_gl_buffer_get, 1);
   rb_define_method(ray_cGLBuffer, "[]=", ray_gl_buffer_set, 2);
 
+  rb_define_method(ray_cGLBuffer, "get_instance", ray_gl_buffer_get_instance,
+                   1);
+  rb_define_method(ray_cGLBuffer, "set_instance", ray_gl_buffer_set_instance,
+                   2);
+
   rb_define_method(ray_cGLBuffer, "update", ray_gl_buffer_update, -1);
+  rb_define_method(ray_cGLBuffer, "update_instance",
+                   ray_gl_buffer_update_instance, -1);
 
   rb_define_method(ray_cGLBuffer, "size", ray_gl_buffer_size, 0);
   rb_define_method(ray_cGLBuffer, "resize", ray_gl_buffer_resize, 1);
+
+  rb_define_method(ray_cGLBuffer, "instance_size", ray_gl_buffer_instance_size,
+                   0);
+  rb_define_method(ray_cGLBuffer, "resize_instance",
+                   ray_gl_buffer_resize_instance, 1);
 }

data/ext/gl_index_buffer.c

@@ -60,6 +60,15 @@ VALUE ray_gl_index_buffer_bind(VALUE self) {
   return self;
 }
 
+/*
+ * @return [Integer] The identifier of the OpenGL buffer used by the index
+ * buffer.
+ */
+static
+VALUE ray_gl_index_buffer_ibo(VALUE self) {
+  return ULONG2NUM(say_index_buffer_get_ibo(ray_rb2index_buffer(self)));
+}
+
 /*
  * @overload [](id)
  *   @param [Integer] id
@@ -190,6 +199,8 @@ void Init_ray_gl_index_buffer() {
                              ray_gl_index_buffer_unbind, 0);
   rb_define_method(ray_cGLIndexBuffer, "bind", ray_gl_index_buffer_bind, 0);
 
+  rb_define_method(ray_cGLIndexBuffer, "ibo", ray_gl_index_buffer_ibo, 0);
+
   rb_define_method(ray_cGLIndexBuffer, "[]",  ray_gl_index_buffer_get, 1);
   rb_define_method(ray_cGLIndexBuffer, "[]=", ray_gl_index_buffer_set, 2);
 

data/ext/gl_int_array.c

@@ -2,27 +2,29 @@
 
 VALUE ray_cIntArray = Qnil;
 
-say_array *ray_rb2int_array(VALUE obj) {
+mo_array *ray_rb2int_array(VALUE obj) {
   if (!rb_obj_is_kind_of(obj, rb_path2class("Ray::GL::IntArray"))) {
     rb_raise(rb_eTypeError, "can't convert %s into Ray::GL::IntArray",
              RAY_OBJ_CLASSNAME(obj));
   }
 
-  say_array *ptr = NULL;
-  Data_Get_Struct(obj, say_array, ptr);
+  mo_array *ptr = NULL;
+  Data_Get_Struct(obj, mo_array, ptr);
 
   return ptr;
 }
 
 static
 void ray_int_set_to_zero(void *elem) {
-  *(int*)elem = 0;
+  *(GLint*)elem = 0;
 }
 
 static
 VALUE ray_int_array_alloc(VALUE self) {
-  say_array *obj = say_array_create(sizeof(int), NULL, ray_int_set_to_zero);
-  return Data_Wrap_Struct(self, NULL, say_array_free, obj);
+  mo_array *obj = mo_array_create(sizeof(GLint));
+  obj->init = ray_int_set_to_zero;
+
+  return Data_Wrap_Struct(self, NULL, mo_array_free, obj);
 }
 
 /*
@@ -31,11 +33,11 @@ VALUE ray_int_array_alloc(VALUE self) {
  */
 static
 VALUE ray_int_array_init(int argc, VALUE *argv, VALUE self) {
-  say_array *ary = ray_rb2int_array(self);
+  mo_array *ary = ray_rb2int_array(self);
 
   for (int i = 0; i < argc; i++) {
-    int val = NUM2INT(argv[i]);
-    say_array_push(ary, &val);
+    GLint val = NUM2INT(argv[i]);
+    mo_array_push(ary, &val);
   }
 
   return self;
@@ -43,7 +45,7 @@ VALUE ray_int_array_init(int argc, VALUE *argv, VALUE self) {
 
 static
 VALUE ray_int_array_init_copy(VALUE self, VALUE orig) {
-  say_array_copy(ray_rb2int_array(self), ray_rb2int_array(orig));
+  mo_array_copy(ray_rb2int_array(self), ray_rb2int_array(orig));
   return self;
 }
 
@@ -56,10 +58,10 @@ static
 VALUE ray_int_array_push(VALUE self, VALUE val) {
   rb_check_frozen(self);
 
-  say_array *ary = ray_rb2int_array(self);
-  int e = NUM2INT(val);
+  mo_array *ary = ray_rb2int_array(self);
+  GLint     e   = NUM2INT(val);
 
-  say_array_push(ary, &e);
+  mo_array_push(ary, &e);
 
   return self;
 }
@@ -71,10 +73,10 @@ VALUE ray_int_array_push(VALUE self, VALUE val) {
 */
 static
 VALUE ray_int_array_get(VALUE self, VALUE i) {
-  say_array *ary = ray_rb2int_array(self);
+  mo_array *ary = ray_rb2int_array(self);
   size_t idx = NUM2ULONG(i);
 
-  int *elem = say_array_get(ary, idx);
+  GLint *elem = mo_array_get_ptr(ary, idx, GLint);
 
   if (elem) {
     return INT2FIX(*elem);
@@ -92,13 +94,13 @@ static
 VALUE ray_int_array_set(VALUE self, VALUE i, VALUE val) {
   rb_check_frozen(self);
 
-  say_array *ary   = ray_rb2int_array(self);
-  size_t     idx   = NUM2ULONG(i);
+  mo_array *ary  = ray_rb2int_array(self);
+  size_t     idx = NUM2ULONG(i);
 
-  if (say_array_get_size(ary) <= idx)
-    say_array_resize(ary, idx + 1);
+  if (ary->size <= idx)
+    mo_array_resize(ary, idx + 1);
 
-  *(int*)say_array_get(ary, idx) = NUM2INT(val);
+  mo_array_get_as(ary, idx, GLint) = NUM2INT(val);
 
   return val;
 }
@@ -106,13 +108,13 @@ VALUE ray_int_array_set(VALUE self, VALUE i, VALUE val) {
 /* @return [Integer] size of the array */
 static
 VALUE ray_int_array_size(VALUE self) {
-  return INT2FIX(say_array_get_size(ray_rb2int_array(self)));
+  return INT2FIX(ray_rb2int_array(self)->size);
 }
 
 /* Removes all the elements from the array */
 static
 VALUE ray_int_array_clear(VALUE self) {
-  say_array_resize(ray_rb2int_array(self), 0);
+  mo_array_resize(ray_rb2int_array(self), 0);
   return self;
 }
 

data/ext/gl_vertex.c

@@ -1,6 +1,8 @@
 #include "ray.h"
 
-VALUE ray_cGLVertex = Qnil;
+VALUE ray_cGLVertex   = Qnil;
+VALUE ray_cGLInstance = Qnil;
+
 static VALUE ray_gl_vertex_types = Qnil;
 
 VALUE ray_get_vertex_class(size_t id) {
@@ -19,6 +21,55 @@ size_t ray_get_vtype(VALUE class) {
   }
 }
 
+VALUE ray_get_vertex_element(void *data, VALUE type) {
+  switch (NUM2INT(rb_hash_aref(ray_gl_vertex_types, type))) {
+  case SAY_FLOAT:
+    return rb_float_new(*(GLfloat*)data);
+  case SAY_INT:
+    return INT2FIX(*(GLint*)data);
+  case SAY_UBYTE:
+    return INT2FIX(*(GLubyte*)data);
+  case SAY_BOOL:
+    return (*(GLint*)data) ? Qtrue : Qfalse;
+
+  case SAY_COLOR:
+    return ray_col2rb(*(say_color*)data);
+  case SAY_VECTOR2:
+      return ray_vector2_to_rb(*(say_vector2*)data);
+  case SAY_VECTOR3:
+    return ray_vector3_to_rb(*(say_vector3*)data);
+  }
+
+  return Qnil;
+}
+
+void ray_set_vertex_element(void *data, VALUE type, VALUE val) {
+  switch (NUM2INT(rb_hash_aref(ray_gl_vertex_types, type))) {
+  case SAY_FLOAT:
+    *(GLfloat*)data = NUM2DBL(val);
+    break;
+  case SAY_INT:
+    *(GLint*)data = NUM2INT(val);
+    break;
+  case SAY_UBYTE:
+    *(GLubyte*)data = ray_byte_clamp(NUM2INT(val));
+    break;
+  case SAY_BOOL:
+    (*(GLint*)data) = RTEST(val);
+    break;
+
+  case SAY_COLOR:
+    *(say_color*)data = ray_rb2col(val);
+    break;
+  case SAY_VECTOR2:
+    *(say_vector2*)data = ray_convert_to_vector2(val);
+    break;
+  case SAY_VECTOR3:
+    *(say_vector3*)data = ray_convert_to_vector3(val);
+    break;
+  }
+}
+
 VALUE ray_gl_vertex_alloc(VALUE self) {
   size_t size = NUM2ULONG(rb_iv_get(self, "@vertex_type_size"));
 
@@ -26,6 +77,13 @@ VALUE ray_gl_vertex_alloc(VALUE self) {
   return Data_Wrap_Struct(self, NULL, free, vertex);
 }
 
+VALUE ray_gl_instance_alloc(VALUE self) {
+  size_t size = NUM2ULONG(rb_iv_get(self, "@vertex_instance_size"));
+
+  void *instance = malloc(size);
+  return Data_Wrap_Struct(self, NULL, free, instance);
+}
+
 static
 VALUE ray_gl_vertex_make_type(VALUE self, VALUE types) {
   size_t size = RARRAY_LEN(types);
@@ -42,11 +100,13 @@ VALUE ray_gl_vertex_make_type(VALUE self, VALUE types) {
     VALUE name = RAY_ARRAY_AT(element, 0);
     VALUE type = RAY_ARRAY_AT(element, 1);
 
-    char *c_name = StringValuePtr(name);
+    VALUE per_instance = RAY_ARRAY_AT(element, 2);
+
+    char *c_name = say_strdup(StringValuePtr(name));
     say_vertex_elem_type c_type = NUM2INT(rb_hash_aref(ray_gl_vertex_types,
                                                        type));
 
-    say_vertex_elem c_elem = {c_type, c_name};
+    say_vertex_elem c_elem = {c_type, c_name, RTEST(per_instance)};
     say_vertex_type_push(vtype, c_elem);
   }
 
@@ -65,31 +125,18 @@ VALUE ray_gl_vertex_size(VALUE self, VALUE vtype) {
   return INT2FIX(say_vertex_type_get_size(type));
 }
 
+static
+VALUE ray_gl_vertex_instance_size(VALUE self, VALUE vtype) {
+  say_vertex_type *type = say_get_vertex_type(NUM2ULONG(vtype));
+  return INT2FIX(say_vertex_type_get_instance_size(type));
+}
+
 VALUE ray_gl_vertex_element(VALUE self, VALUE offset, VALUE type) {
   uint8_t *data = NULL;
   Data_Get_Struct(self, uint8_t, data);
 
   data += NUM2ULONG(offset);
-
-  switch (NUM2INT(rb_hash_aref(ray_gl_vertex_types, type))) {
-  case SAY_FLOAT:
-    return rb_float_new(*(GLfloat*)data);
-  case SAY_INT:
-    return INT2FIX((*(GLint*)data));
-  case SAY_UBYTE:
-    return INT2FIX((*(GLubyte*)data));
-  case SAY_BOOL:
-    return (*(GLint*)data) ? Qtrue : Qfalse;
-
-  case SAY_COLOR:
-    return ray_col2rb(*(say_color*)data);
-  case SAY_VECTOR2:
-      return ray_vector2_to_rb(*(say_vector2*)data);
-  case SAY_VECTOR3:
-    return ray_vector3_to_rb(*(say_vector3*)data);
-  }
-
-  return Qnil;
+  return ray_get_vertex_element(data, type);
 }
 
 VALUE ray_gl_vertex_set_element(VALUE self, VALUE offset, VALUE type,
@@ -98,33 +145,9 @@ VALUE ray_gl_vertex_set_element(VALUE self, VALUE offset, VALUE type,
   Data_Get_Struct(self, uint8_t, data);
 
   data += NUM2ULONG(offset);
+  ray_set_vertex_element(data, type, val);
 
-  switch (NUM2INT(rb_hash_aref(ray_gl_vertex_types, type))) {
-  case SAY_FLOAT:
-    (*(GLfloat*)data) = NUM2DBL(val);
-    break;
-  case SAY_INT:
-    ((*(GLint*)data)) = NUM2INT(val);
-    break;
-  case SAY_UBYTE:
-    ((*(GLubyte*)data)) = ray_byte_clamp(NUM2INT(val));
-    break;
-  case SAY_BOOL:
-    (*(GLint*)data) = RTEST(val);
-    break;
-
-  case SAY_COLOR:
-    ((*(say_color*)data)) = ray_rb2col(val);
-    break;
-  case SAY_VECTOR2:
-    ((*(say_vector2*)data)) = ray_convert_to_vector2(val);
-    break;
-  case SAY_VECTOR3:
-    ((*(say_vector3*)data)) = ray_convert_to_vector3(val);
-    break;
-  }
-
-  return type;
+  return val;
 }
 
 void Init_ray_gl_vertex() {
@@ -137,6 +160,8 @@ void Init_ray_gl_vertex() {
                              ray_gl_vertex_offset_of, 2);
   rb_define_singleton_method(ray_cGLVertex, "size",
                              ray_gl_vertex_size, 1);
+  rb_define_singleton_method(ray_cGLVertex, "instance_size",
+                             ray_gl_vertex_instance_size, 1);
 
   rb_define_private_method(ray_cGLVertex, "element", ray_gl_vertex_element, 2);
   rb_define_private_method(ray_cGLVertex, "set_element",
@@ -154,4 +179,14 @@ void Init_ray_gl_vertex() {
   rb_hash_aset(ray_gl_vertex_types, RAY_SYM("vector3"), INT2FIX(SAY_VECTOR3));
 
   rb_define_const(ray_cGLVertex, "TypeMap", ray_gl_vertex_types);
+
+  ray_cGLInstance = rb_define_class_under(ray_cGLVertex, "Instance",
+                                                rb_cObject);
+  rb_define_alloc_func(ray_cGLInstance, ray_gl_instance_alloc);
+
+  rb_define_private_method(ray_cGLInstance, "element", ray_gl_vertex_element,
+                           2);
+  rb_define_private_method(ray_cGLInstance, "set_element",
+                           ray_gl_vertex_set_element, 3);
+
 }