ray 0.1.1 → 0.2.0

data/ext/extconf.rb

@@ -1,6 +1,6 @@
 require 'mkmf'
 
-$CFLAGS  << " -Wextra -Wall -Wno-unused-parameter -std=gnu99 -g -O0"
+$CFLAGS  << " -Wextra -Wall -Wno-unused-parameter -std=gnu99"
 
 unless RUBY_PLATFORM =~ /mingw/
   $CFLAGS  << " " << `freetype-config --cflags`.chomp
@@ -21,59 +21,61 @@ elsif RUBY_PLATFORM =~ /mingw/
   def vendor_path(file)
     File.join(File.dirname(__FILE__), "vendor", file)
   end
-  
+
   def vendor(file)
     '"' + vendor_path(file) + '"'
   end
-  
+
   def rel(file)
     File.join(File.dirname(__FILE__), file)
   end
-  
+
   require 'fileutils'
   include FileUtils
-  
+
   cp vendor_path("openal/Win32/soft_oal.dll"), rel("OpenAL32.dll")
   cp vendor_path("freetype/bin/freetype6.dll"), rel("freetype6.dll")
   cp vendor_path("freetype/bin/zlib1.dll"), rel("zlib1.dll")
   cp vendor_path("glew/lib/glew32.dll"), rel("glew32.dll")
   cp vendor_path("sndfile/bin/libsndfile-1.dll"), rel("libsndfile-1.dll")
-  
+
   $CFLAGS << " -DSAY_WIN"
 
   # Windows API
   have_library "gdi32"
-  
+
   # OpenGL and GLEW
   $CFLAGS  << " -I#{vendor("glew/include")}"
   $LDFLAGS << " -L#{vendor("glew/lib")}"
-  
+
   have_library "opengl32"
   have_library "glew32"
-  
+
   # Freetype
   $CFLAGS  << " -I#{vendor("freetype/include")}"
   $CFLAGS  << " -I#{vendor("freetype/include/freetype2")}"
   $LDFLAGS << " -L#{vendor("freetype/lib")}"
-  
+
   have_library "libfreetype"
-  
+
   # OpenAL
   $CFLAGS  << " -I#{vendor("openal/include")}"
   $LDFLAGS << " -L#{vendor("openal/lib")}"
-  
+
   have_library "OpenAL32"
-  
+
   # libsndfile
   $CFLAGS  << " -I#{vendor("sndfile/include")}"
   $LDFLAGS << " -L#{vendor("sndfile/lib")}"
-  
+
   have_library "libsndfile-1"
 
   create_makefile 'ray_ext'
 else
   $CFLAGS << " -DSAY_X11"
 
+  have_header "GL/glxext.h"
+
   have_header "X11/extensions/Xrandr.h"
   have_library "Xrandr"
 

data/ext/gl.c

@@ -4,19 +4,17 @@ VALUE ray_mGL = Qnil;
 static VALUE ray_gl_primitives = Qnil;
 
 /*
-  @overload draw_arrays(primitive, first, count)
-    @note Misusing this method can cause a crash.
-    @param [Symbol] primitive Primitive to draw. Must be one of the folowing:
-      points, line_strip, line_loop, lines, triangle_strip, triangle_fan,
-      triangles.
-
-    @param [Integer] first Identifier of the first vertex to draw.
-    @param [Integer] count Amount of vertices to draw.
-*/
+ * @overload draw_arrays(primitive, first, count)
+ *   @param [Symbol] primitive Primitive to draw. Must be one of the folowing:
+ *     points, line_strip, line_loop, lines, triangle_strip, triangle_fan,
+ *     triangles.
+ *
+ *   @param [Integer] first Identifier of the first vertex to draw.
+ *   @param [Integer] count Amount of vertices to draw.
+ */
 static
 VALUE ray_gl_draw_arrays(VALUE self, VALUE primitive, VALUE first,
                          VALUE count) {
-
   glDrawArrays(NUM2INT(rb_hash_aref(ray_gl_primitives, primitive)),
                NUM2ULONG(first), NUM2ULONG(count));
   return Qnil;
@@ -38,25 +36,69 @@ VALUE ray_gl_draw_elements(VALUE self, VALUE primitive, VALUE count,
 }
 
 /*
-  @overload multi_draw_arrays(primitive, first, count)
-    @param primitive (see #draw_arrays)
-    @param [Ray::GL::IntArray] first Indices of the first vertex
-    @param [Ray::GL::IntArray] count Ammount of vertices to draw
-*/
+ * @overload draw_arrays_instanced(primitive, first, count, instance_count)
+ *   @param [Symbol] primitive (see #draw_arrays)
+ *   @param [Integer] first (see #draw_arrays)
+ *   @param [Integer] count (see #draw_arrays)
+ *   @param [Integer] instance_count Amount of instances to draw
+ */
+static
+VALUE ray_gl_draw_arrays_instanced(VALUE self, VALUE primitive, VALUE first,
+                                   VALUE count, VALUE instance_count) {
+  say_context_ensure();
+  if (glDrawArraysInstanced) {
+    glDrawArraysInstanced(NUM2INT(rb_hash_aref(ray_gl_primitives, primitive)),
+                          NUM2ULONG(first), NUM2ULONG(count),
+                          NUM2ULONG(instance_count));
+  }
+  else
+    rb_raise(rb_eRuntimeError, "GL_ARB_draw_instanced is not supported");
+
+  return Qnil;
+}
+
+/*
+ * @overload draw_elements_instanced(primitive, count, index, instance_count)
+ *   @param primitive (see #draw_arrays)
+ *   @param count     (see #draw_arrays)
+ *   @param index     (see #draw_elements)
+ *   @param instance_count (see #draw_arrays_instanced)
+ */
+static
+VALUE ray_gl_draw_elements_instanced(VALUE self, VALUE primitive, VALUE count,
+                                     VALUE index, VALUE instance_count) {
+  say_context_ensure();
+  if (glDrawElementsInstanced) {
+    glDrawElementsInstanced(NUM2INT(rb_hash_aref(ray_gl_primitives, primitive)),
+                            NUM2ULONG(count),
+                            GL_UNSIGNED_INT, (void*)NUM2ULONG(index),
+                            NUM2ULONG(instance_count));
+  }
+  else
+    rb_raise(rb_eRuntimeError, "GL_ARB_draw_instanced is not supported");
+
+  return Qnil;
+}
+
+
+/*
+ * @overload multi_draw_arrays(primitive, first, count)
+ *   @param primitive (see #draw_arrays)
+ *   @param [Ray::GL::IntArray] first Indices of the first vertex
+ *   @param [Ray::GL::IntArray] count Ammount of vertices to draw
+ */
 static
 VALUE ray_gl_multi_draw_arrays(VALUE self, VALUE primitive, VALUE rb_first,
                                VALUE rb_count) {
-  say_array *first = ray_rb2int_array(rb_first);
-  say_array *count = ray_rb2int_array(rb_count);
+  mo_array *first = ray_rb2int_array(rb_first);
+  mo_array *count = ray_rb2int_array(rb_count);
 
-  size_t size = say_array_get_size(first);
-
-  if (size != say_array_get_size(count))
+  if (first->size != count->size)
     rb_raise(rb_eArgError, "first and count arrays should have the same size");
 
   glMultiDrawArrays(NUM2INT(rb_hash_aref(ray_gl_primitives, primitive)),
-                    say_array_get(first, 0), say_array_get(count, 0),
-                    size);
+                    mo_array_at(first, 0), mo_array_at(count, 0),
+                    first->size);
 
   return Qnil;
 }
@@ -71,21 +113,221 @@ VALUE ray_gl_multi_draw_arrays(VALUE self, VALUE primitive, VALUE rb_first,
 static
 VALUE ray_gl_multi_draw_elements(VALUE self, VALUE primitive, VALUE rb_count,
                                  VALUE rb_index) {
-  say_array *index = ray_rb2int_array(rb_index);
-  say_array *count = ray_rb2int_array(rb_count);
-
-  size_t size = say_array_get_size(index);
+  mo_array *index = ray_rb2int_array(rb_index);
+  mo_array *count = ray_rb2int_array(rb_count);
 
-  if (size != say_array_get_size(count))
+  if (index->size != count->size)
     rb_raise(rb_eArgError, "index and count arrays should have the same size");
 
   glMultiDrawElements(NUM2INT(rb_hash_aref(ray_gl_primitives, primitive)),
-                      say_array_get(count, 0),
-                      GL_UNSIGNED_INT, (const GLvoid**)say_array_get(count, 0),
-                      size);
+                      mo_array_at(count, 0),
+                      GL_UNSIGNED_INT, (const GLvoid**)mo_array_at(index, 0),
+                      index->size);
   return Qnil;
 }
 
+/* @return [Integer] Size of the depth buffer, in bits */
+static
+VALUE ray_gl_depth_size(VALUE self) {
+  return ULONG2NUM(say_context_get_config()->depth_size);
+}
+
+/* @return [Integer] Size of the stencil buffer, in bits */
+static
+VALUE ray_gl_stencil_size(VALUE self) {
+  return ULONG2NUM(say_context_get_config()->stencil_size);
+}
+
+/* @return [Integer] Major version number. Ignored if less than 3. */
+static
+VALUE ray_gl_major_version(VALUE self) {
+  return ULONG2NUM(say_context_get_config()->major_version);
+}
+
+/* @return [Integer] Minor version number */
+static
+VALUE ray_gl_minor_version(VALUE self) {
+  return ULONG2NUM(say_context_get_config()->minor_version);
+}
+
+/* @return [Bollean] True when a core OpenGL profile must be used */
+static
+VALUE ray_gl_core_profile(VALUE self) {
+  return say_context_get_config()->core_profile ? Qtrue : Qfalse;
+}
+
+/* @see depth_size */
+static
+VALUE ray_gl_set_depth_size(VALUE self, VALUE val) {
+  say_context_get_config()->depth_size = NUM2ULONG(val);
+  return val;
+}
+
+/* @see stencil_size */
+static
+VALUE ray_gl_set_stencil_size(VALUE self, VALUE val) {
+  say_context_get_config()->stencil_size = NUM2ULONG(val);
+  return val;
+}
+
+/* @see major_version */
+static
+VALUE ray_gl_set_major_version(VALUE self, VALUE val) {
+  say_context_get_config()->major_version = NUM2ULONG(val);
+  return val;
+}
+
+/* @see minor_version */
+static
+VALUE ray_gl_set_minor_version(VALUE self, VALUE val) {
+  say_context_get_config()->minor_version = NUM2ULONG(val);
+  return val;
+}
+
+/* @see core_profile? */
+static
+VALUE ray_gl_set_core_profile(VALUE self, VALUE val) {
+  say_context_get_config()->core_profile = RTEST(val);
+  return val;
+}
+
+/* @return [true, false] True if debugging mode is enabled */
+static
+VALUE ray_gl_debug(VALUE self) {
+  return say_context_get_config()->debug ? Qtrue : Qfalse;
+}
+
+/* @see debug? */
+static
+VALUE ray_gl_set_debug(VALUE self, VALUE val) {
+  say_context_get_config()->debug = RTEST(val);
+  return val;
+}
+
+static
+void ray_gl_debug_proc(GLenum source,
+                       GLenum type,
+                       GLuint id,
+                       GLenum severity,
+                       GLsizei length,
+                       const GLchar *message,
+                       GLvoid *param) {
+  VALUE rb_source = Qnil;
+  switch (source) {
+  case GL_DEBUG_SOURCE_API_ARB:
+    rb_source = RAY_SYM("api"); break;
+  case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:
+    rb_source = RAY_SYM("window_system"); break;
+  case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:
+    rb_source = RAY_SYM("shader_compiler"); break;
+  case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:
+    rb_source = RAY_SYM("third_party"); break;
+  case GL_DEBUG_SOURCE_APPLICATION_ARB:
+    rb_source = RAY_SYM("application"); break;
+  default:
+    rb_source = RAY_SYM("other"); break;
+  }
+
+  VALUE rb_type = Qnil;
+  switch (type) {
+  case GL_DEBUG_TYPE_ERROR_ARB:
+    rb_type = RAY_SYM("error"); break;
+  case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
+    rb_type = RAY_SYM("deprecated_behavior"); break;
+  case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
+    rb_type = RAY_SYM("undefined_behavior"); break;
+  case GL_DEBUG_TYPE_PORTABILITY_ARB:
+    rb_type = RAY_SYM("portability"); break;
+  case GL_DEBUG_TYPE_PERFORMANCE_ARB:
+    rb_type = RAY_SYM("performance"); break;
+  default:
+    rb_type = RAY_SYM("other"); break;
+  }
+
+  VALUE rb_id = ULONG2NUM(id);
+
+  VALUE rb_severity = Qnil;
+  switch (severity) {
+  case GL_DEBUG_SEVERITY_HIGH_ARB:
+    rb_severity = RAY_SYM("high"); break;
+  case GL_DEBUG_SEVERITY_MEDIUM_ARB:
+    rb_severity = RAY_SYM("medium"); break;
+  default:
+    rb_severity = RAY_SYM("low"); break;
+  }
+
+  VALUE rb_message = rb_str_new(message, length);
+
+  VALUE proc = rb_iv_get(rb_path2class("Ray::GL"), "@callback");
+  rb_funcall(proc, RAY_METH("call"), 5, rb_source, rb_type, rb_id, rb_severity,
+             rb_message);
+}
+
+/* @return [True, False] True if a callback proc can be set */
+static
+VALUE ray_gl_has_callback(VALUE self) {
+  say_context_ensure();
+  return glDebugMessageCallbackARB ? Qtrue : Qfalse;
+}
+
+/*
+ * @overload callback=(proc)
+ *   Sets the proc called by OpenGL for debugging purpose
+ *   @param [Proc, nil] proc A proc, or nil to disable debugging
+ *
+ *   The given proc will be called upon some events (errors or warnings about
+ *   performance and undifined behaviors) with the following arguments:
+ *
+ *   1. A source (:api, :window_system, :shader_compiler, :third_party,
+ *      :application, :other).
+ *   2. A type (:error, :depreacted_behavior, :undefined_behavior, :portability,
+ *      :performance, :other).
+ *   3. An integer identifier.
+ *   4. A severity (:high, :medium, :low).
+ *   5. A human-readable message.
+ *
+ *   Notice the debugging proc is only called if the context has been created
+ *   in debug mode.
+ *
+ *   @example
+ *      Ray::GL.debug = true # required
+ *
+ *      Ray::GL.callback = proc do |source, type, _, severity, msg|
+ *        puts "[#{source}][#{type}][#{severity}] #{msg}"
+ *      end
+ *
+ *   @see debug?
+ */
+static
+VALUE ray_gl_set_callback(VALUE self, VALUE proc) {
+  say_context_ensure();
+
+  if (!glDebugMessageCallbackARB)
+    rb_raise(rb_eRuntimeError, "setting the debug proc isn't supported");
+
+  rb_iv_set(rb_path2class("Ray::GL"), "@callback", proc);
+  if (RTEST(proc))
+    glDebugMessageCallbackARB(ray_gl_debug_proc, NULL);
+  else
+    glDebugMessageCallbackARB(NULL, NULL);
+
+  return proc;
+}
+
+/*
+ * Ensures an OpenGL context is active for the current thread
+ */
+static
+VALUE ray_gl_ensure_context(VALUE self) {
+  say_context_ensure();
+  return Qnil;
+}
+
+/*
+ * Document-Class: Ray::GL
+ *
+ * The GL module is used to give access to low-level OpenGL features in Ray.
+ */
 void Init_ray_gl() {
   ray_mGL = rb_define_module_under(ray_mRay, "GL");
 
@@ -104,11 +346,49 @@ void Init_ray_gl() {
   /* @return [Hash] Available primitives. */
   rb_define_const(ray_mGL, "Primitives", ray_gl_primitives);
 
+  /* @group Context configuration */
+  rb_define_module_function(ray_mGL, "depth_size", ray_gl_depth_size, 0);
+  rb_define_module_function(ray_mGL, "depth_size=", ray_gl_set_depth_size, 1);
+
+  rb_define_module_function(ray_mGL, "stencil_size", ray_gl_stencil_size, 0);
+  rb_define_module_function(ray_mGL, "stencil_size=", ray_gl_set_stencil_size,
+                            1);
+
+  rb_define_module_function(ray_mGL, "major_version", ray_gl_major_version, 0);
+  rb_define_module_function(ray_mGL, "major_version=", ray_gl_set_major_version,
+                            1);
+
+  rb_define_module_function(ray_mGL, "minor_version", ray_gl_minor_version, 0);
+  rb_define_module_function(ray_mGL, "minor_version=", ray_gl_set_minor_version,
+                            1);
+
+  rb_define_module_function(ray_mGL, "core_profile?", ray_gl_core_profile, 0);
+  rb_define_module_function(ray_mGL, "core_profile=", ray_gl_set_core_profile,
+                            1);
+
+  rb_define_module_function(ray_mGL, "debug?", ray_gl_debug, 0);
+  rb_define_module_function(ray_mGL, "debug=", ray_gl_set_debug, 1);
+  /* @endgroup */
+
+
+  /* @group Low-level rendering */
   rb_define_module_function(ray_mGL, "draw_arrays", ray_gl_draw_arrays, 3);
   rb_define_module_function(ray_mGL, "draw_elements", ray_gl_draw_elements, 3);
 
+  rb_define_module_function(ray_mGL, "draw_arrays_instanced",
+                            ray_gl_draw_arrays_instanced, 4);
+  rb_define_module_function(ray_mGL, "draw_elements_instanced",
+                            ray_gl_draw_elements_instanced, 4);
+
   rb_define_module_function(ray_mGL, "multi_draw_arrays",
                             ray_gl_multi_draw_arrays, 3);
   rb_define_module_function(ray_mGL, "multi_draw_elements",
                             ray_gl_multi_draw_elements, 3);
+  /* @endgroup */
+
+  rb_define_module_function(ray_mGL, "has_callback?", ray_gl_has_callback, 0);
+  rb_define_module_function(ray_mGL, "callback=", ray_gl_set_callback, 1);
+
+  rb_define_module_function(ray_mGL, "ensure_context", ray_gl_ensure_context,
+                            0);
 }