ruby-opengl 0.50.0 → 0.60.0

data/ext/common/common.h

@@ -24,6 +24,8 @@
 
 #include <ruby.h>
 
+#include <ctype.h>
+
 #ifdef __APPLE__
 #include <OpenGL/gl.h>
 #include <OpenGL/glu.h>
@@ -46,6 +48,10 @@
 #include "gl-types.h"
 #include "gl-enums.h"
 #include "glu-enums.h"
+#include "gl-error.h"
+
+#include "funcdef.h"
+#include "conv.h"
 
 #ifndef APIENTRY
 #define APIENTRY
@@ -67,21 +73,16 @@
 
 /* */
 
+/* at least GL_MAX_VERTEX_ATTRIBS - usually 16 or 32 on today's high-end cards */
+#define _MAX_VERTEX_ATTRIBS 64
+
 typedef struct RArray RArray;
 
 extern VALUE cProc;
 
-#define LOAD_GL_FUNC(_NAME_) \
-if (fptr_##_NAME_==NULL) \
-fptr_##_NAME_ = load_gl_function(#_NAME_, 1);
-
-#define LOAD_GL_EXT_FUNC(_NAME_,_EXTNAME_) \
-if (fptr_##_NAME_==NULL) {\
-	if (CheckExtension(_EXTNAME_)==GL_FALSE) \
-		rb_raise(rb_eNotImpError,"Extension %s is not available on this system",_EXTNAME_); \
-	fptr_##_NAME_ = load_gl_function(#_NAME_, 1); \
-}
-
+/* For now we do not honor pixel store modes, so we need to
+  force them to defaults on each affected function call for
+  correct size requirement calculations */
 #define FORCE_PIXEL_STORE_MODE \
 	glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); \
 	glPixelStorei(GL_PACK_ALIGNMENT, 1); \
@@ -90,7 +91,7 @@ if (fptr_##_NAME_==NULL) {\
 	glPixelStorei(GL_PACK_ROW_LENGTH, 0); \
 	glPixelStorei(GL_PACK_SKIP_IMAGES, 0); \
 	glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0); \
-	if (CheckExtension("GL_SGIS_texture4D")) { \
+	if (CheckVersionExtension("GL_SGIS_texture4D")) { \
 		glPixelStorei(GL_PACK_SKIP_VOLUMES_SGIS, 0); \
 		glPixelStorei(GL_PACK_IMAGE_DEPTH_SGIS, 0); \
 	}
@@ -98,151 +99,9 @@ if (fptr_##_NAME_==NULL) {\
 #define RESTORE_PIXEL_STORE_MODE \
 	glPopClientAttrib();
 
-GLboolean CheckExtension(const char *name);
+GLboolean CheckVersionExtension(const char *name);
 GLint CheckBufferBinding(GLint buffer);
 
-/* -------------------------------------------------------------------- */
-#ifndef NUM2DBL
-#define NUM2DBL(_val) num2double(_val) 
-
-static inline double num2double( VALUE val )
-{
-    struct RFloat* flt;
-    if (NIL_P(val)) return 0;
-    flt = RFLOAT(f_float(0, val));
-    return flt->value;
-}
-#endif
-
-/* -------------------------------------------------------------------- */
-#define ARY2INTEGRAL(_type_,_convert_) \
-static inline int ary2c##_type_( arg, cary, maxlen ) \
-VALUE arg; \
-GL##_type_ cary[]; \
-int maxlen; \
-{ \
-    int i; \
-    struct RArray* ary; \
-    VALUE entry; \
-    ary = RARRAY(rb_Array(arg)); \
-    if (maxlen < 1) \
-        maxlen = ary->len; \
-    else \
-        maxlen = maxlen < ary->len ? maxlen : ary->len; \
-    for (i=0; i < maxlen; i++) \
-    { \
-        entry = rb_ary_entry((VALUE)ary,i); \
-        cary[i] = (GL##_type_)_convert_(entry); \
-    } \
-    return i; \
-}
-
-ARY2INTEGRAL(int,NUM2INT)
-ARY2INTEGRAL(uint,NUM2UINT)
-ARY2INTEGRAL(byte,NUM2INT)
-ARY2INTEGRAL(ubyte,NUM2INT)
-ARY2INTEGRAL(short,NUM2INT)
-ARY2INTEGRAL(ushort,NUM2INT)
-ARY2INTEGRAL(boolean,NUM2INT)
-#undef ARY2INTEGRAL
-
-/* -------------------------------------------------------------------- */
-static inline int ary2cflt(arg, cary, maxlen)
-VALUE arg;
-float cary[];
-int maxlen;
-{
-    int i;
-    struct RArray* ary;
-    ary = RARRAY(rb_Array(arg));
-    if (maxlen < 1)
-        maxlen = ary->len;
-    else
-        maxlen = maxlen < ary->len ? maxlen : ary->len;
-    for (i=0; i < maxlen; i++)
-        cary[i] = (float)NUM2DBL(rb_ary_entry((VALUE)ary,i));
-    return i;
-}
-
-/* -------------------------------------------------------------------- */
-static inline int ary2cdbl(arg, cary, maxlen)
-VALUE arg;
-double cary[];
-int maxlen;
-{
-    int i;
-    struct RArray* ary;
-    ary = RARRAY(rb_Array(arg));
-    if (maxlen < 1)
-        maxlen = ary->len;
-    else
-        maxlen = maxlen < ary->len ? maxlen : ary->len;
-    for (i=0; i < maxlen; i++)
-        cary[i] = NUM2DBL(rb_ary_entry((VALUE)ary,i));
-    return i;
-}
-
-/* -------------------------------------------------------------------- */
-/* Array.flatten */
-static inline void mary2ary(src, ary)
-VALUE src;
-VALUE ary;
-{
-    struct RArray* tmp_ary;
-    int i;
-    tmp_ary = RARRAY(rb_Array(src));
-    for (i = 0; i < tmp_ary->len; i++)
-    {
-        if (TYPE(tmp_ary->ptr[i]) == T_ARRAY)
-            mary2ary((VALUE)tmp_ary->ptr[i], ary);
-        else
-            rb_ary_push(ary, tmp_ary->ptr[i]);
-    }
-}
-
-/* -------------------------------------------------------------------- */
-static inline void ary2cmat4x4dbl(ary, cary)
-VALUE ary;
-double cary[];
-{
-    int i,j;
-    RArray *ary_r,*ary_c;
-    memset(cary, 0x0, sizeof(double[4*4]));
-    ary_c = RARRAY(rb_Array(ary));
-    if (TYPE(ary_c->ptr[0]) != T_ARRAY)
-        ary2cdbl((VALUE)ary_c, cary, 16);
-    else
-    {
-        for (i = 0; i < ary_c->len && i < 4; i++)
-        {
-            ary_r = RARRAY(rb_Array(ary_c->ptr[i]));
-            for(j = 0; j < ary_r->len && j < 4; j++)
-                cary[i*4+j] = (GLdouble)NUM2DBL(ary_r->ptr[j]);
-        }
-    }
-}
-
-static inline void ary2cmat4x4flt(ary, cary)
-VALUE ary;
-float cary[];
-{
-    int i,j;
-    RArray *ary_r,*ary_c;
-    memset(cary, 0x0, sizeof(float[4*4]));
-    ary_c = RARRAY(rb_Array(ary));
-    if (TYPE(ary_c->ptr[0]) != T_ARRAY)
-        ary2cflt((VALUE)ary_c, cary, 16);
-    else
-    {
-        for (i = 0; i < ary_c->len && i < 4; i++)
-        {
-            ary_r = RARRAY(rb_Array(ary_c->ptr[i]));
-            for(j = 0; j < ary_r->len && j < 4; j++)
-                cary[i*4+j] = (GLfloat)NUM2DBL(ary_r->ptr[j]);
-        }
-    }
-}
-
 /* -------------------------------------------------------------------- */
 
 /* gets number of components for given format */
@@ -374,6 +233,91 @@ static inline int gltype_glformat_unit_size(GLenum type,GLenum format)
 	}
 }
 
+/* returns size(units) for given type of shader uniform var */
+static inline int get_uniform_size(GLenum uniform_type)
+{
+	int uniform_size = 0;
+
+	switch (uniform_type) { 
+		case GL_FLOAT: 
+		case GL_INT: 
+		case GL_UNSIGNED_INT: 
+		case GL_BOOL: 
+		case GL_SAMPLER_1D: 
+		case GL_SAMPLER_2D: 
+		case GL_SAMPLER_3D: 
+		case GL_SAMPLER_CUBE: 
+		case GL_SAMPLER_1D_SHADOW: 
+		case GL_SAMPLER_2D_SHADOW: 
+		case GL_SAMPLER_2D_RECT_ARB: 
+		case GL_SAMPLER_2D_RECT_SHADOW_ARB: 
+		case GL_SAMPLER_1D_ARRAY_EXT: 
+		case GL_SAMPLER_2D_ARRAY_EXT: 
+		case GL_SAMPLER_BUFFER_EXT: 
+		case GL_SAMPLER_1D_ARRAY_SHADOW_EXT: 
+		case GL_SAMPLER_2D_ARRAY_SHADOW_EXT: 
+		case GL_SAMPLER_CUBE_SHADOW_EXT: 
+		case GL_INT_SAMPLER_1D_EXT: 
+		case GL_INT_SAMPLER_2D_EXT: 
+		case GL_INT_SAMPLER_3D_EXT: 
+		case GL_INT_SAMPLER_CUBE_EXT: 
+		case GL_INT_SAMPLER_2D_RECT_EXT: 
+		case GL_INT_SAMPLER_1D_ARRAY_EXT: 
+		case GL_INT_SAMPLER_2D_ARRAY_EXT: 
+		case GL_INT_SAMPLER_BUFFER_EXT: 
+		case GL_UNSIGNED_INT_SAMPLER_1D_EXT: 
+		case GL_UNSIGNED_INT_SAMPLER_2D_EXT: 
+		case GL_UNSIGNED_INT_SAMPLER_3D_EXT: 
+		case GL_UNSIGNED_INT_SAMPLER_CUBE_EXT: 
+		case GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT: 
+		case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT: 
+		case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT: 
+		case GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT: 
+			uniform_size = 1; 
+			break; 
+		case GL_FLOAT_VEC2: 
+		case GL_INT_VEC2: 
+		case GL_UNSIGNED_INT_VEC2_EXT: 
+		case GL_BOOL_VEC2: 
+			uniform_size = 2; 
+			break; 
+		case GL_FLOAT_VEC3: 
+		case GL_INT_VEC3: 
+		case GL_UNSIGNED_INT_VEC3_EXT: 
+		case GL_BOOL_VEC3: 
+			uniform_size = 3; 
+			break; 
+		case GL_FLOAT_VEC4: 
+		case GL_INT_VEC4: 
+		case GL_UNSIGNED_INT_VEC4_EXT: 
+		case GL_BOOL_VEC4: 
+		case GL_FLOAT_MAT2: 
+			uniform_size = 4; 
+			break; 
+		case GL_FLOAT_MAT2x3: 
+		case GL_FLOAT_MAT3x2: 
+			uniform_size = 6; 
+			break; 
+		case GL_FLOAT_MAT2x4: 
+		case GL_FLOAT_MAT4x2: 
+			uniform_size = 8; 
+			break; 
+		case GL_FLOAT_MAT3: 
+			uniform_size = 9; 
+			break; 
+		case GL_FLOAT_MAT4x3: 
+		case GL_FLOAT_MAT3x4: 
+			uniform_size = 12; 
+			break; 
+		case GL_FLOAT_MAT4: 
+			uniform_size = 16; 
+			break; 
+		default: 
+			rb_raise(rb_eTypeError, "Unsupported uniform type '%i'",uniform_type);
+	}
+	return uniform_size;
+}
+
 static inline int GetDataSize(GLenum type,GLenum format,int num)
 {
 	int size;
@@ -397,7 +341,7 @@ static inline void CheckDataSize(GLenum type,GLenum format,int num,VALUE data)
 
 	size = GetDataSize(type,format,num);
 	
-	if (RSTRING(data)->len < size)
+	if (RSTRING_LEN(data) < size)
 		rb_raise(rb_eArgError, "Length of specified data doesn't correspond to format and type parameters passed. Calculated length: %i",size);
 }
 
@@ -448,68 +392,32 @@ static inline void *load_gl_function(const char *name,int raise)
 	return func_ptr;
 }
 
-/* -------------------------------------------------------------------- */
+static inline VALUE pack_array_or_pass_string(GLenum type,VALUE ary)
+{
+	char *type_str;
+
+	if (TYPE(ary)==T_STRING)
+		return ary;
+
+	Check_Type(ary,T_ARRAY);
+
+	switch(type) {
+		case GL_FLOAT:          type_str = "f*"; break;
+		case GL_DOUBLE:         type_str = "d*"; break;
+		case GL_BYTE:	          type_str = "c*"; break;
+		case GL_SHORT:          type_str = "s*"; break;
+		case GL_INT:            type_str = "i*"; break;
+		case GL_UNSIGNED_BYTE:  type_str = "C*"; break;
+		case GL_UNSIGNED_SHORT: type_str = "S*"; break;
+		case GL_UNSIGNED_INT:	  type_str = "I*"; break;
+		default:
+			rb_raise(rb_eTypeError,"Unknown type %i",type);
+			return Qnil; /* not reached */
+	}
 
-/* Macroset for defining simple functions, i.e. functions that take n arguments of
-  the same type and pass them to GL API function without any additional processing.
-
-  Some checking is implicit in _conversion_ argument - e.g. NUM2INT makes sure that
-  user is really passing type that can be converted to INT, otherwire raises. */
-
-#define ARGLIST0 obj
-#define ARGLIST1 obj,arg1
-#define ARGLIST2 obj,arg1,arg2
-#define ARGLIST3 obj,arg1,arg2,arg3
-#define ARGLIST4 obj,arg1,arg2,arg3,arg4
-#define ARGLIST5 obj,arg1,arg2,arg3,arg4,arg5
-#define ARGLIST6 obj,arg1,arg2,arg3,arg4,arg5,arg6
-
-#define TYPELIST0(_ctype_) void
-#define TYPELIST1(_ctype_) _ctype_
-#define TYPELIST2(_ctype_) _ctype_,_ctype_
-#define TYPELIST3(_ctype_) _ctype_,_ctype_,_ctype_
-#define TYPELIST4(_ctype_) _ctype_,_ctype_,_ctype_,_ctype_
-#define TYPELIST5(_ctype_) _ctype_,_ctype_,_ctype_,_ctype_,_ctype_
-#define TYPELIST6(_ctype_) _ctype_,_ctype_,_ctype_,_ctype_,_ctype_,_ctype_
-
-#define FUNCPARAMS0(_ctype_,_conversion_) 
-#define FUNCPARAMS1(_ctype_,_conversion_) (_ctype_)_conversion_(arg1)
-#define FUNCPARAMS2(_ctype_,_conversion_) (_ctype_)_conversion_(arg1),(_ctype_)_conversion_(arg2)
-#define FUNCPARAMS3(_ctype_,_conversion_) (_ctype_)_conversion_(arg1),(_ctype_)_conversion_(arg2),(_ctype_)_conversion_(arg3)
-#define FUNCPARAMS4(_ctype_,_conversion_) (_ctype_)_conversion_(arg1),(_ctype_)_conversion_(arg2),(_ctype_)_conversion_(arg3),(_ctype_)_conversion_(arg4)
-#define FUNCPARAMS5(_ctype_,_conversion_) (_ctype_)_conversion_(arg1),(_ctype_)_conversion_(arg2),(_ctype_)_conversion_(arg3),(_ctype_)_conversion_(arg4),(_ctype_)_conversion_(arg5)
-#define FUNCPARAMS6(_ctype_,_conversion_) (_ctype_)_conversion_(arg1),(_ctype_)_conversion_(arg2),(_ctype_)_conversion_(arg3),(_ctype_)_conversion_(arg4),(_ctype_)_conversion_(arg5),(_ctype_)_conversion_(arg6)
-
-#define GL_SIMPLE_FUNC(_name_,_numparams_,_ctype_,_conversion_) \
-static VALUE \
-gl_##_name_(ARGLIST##_numparams_) \
-VALUE ARGLIST##_numparams_; \
-{ \
-	gl##_name_(FUNCPARAMS##_numparams_(_ctype_,_conversion_)); \
-	return Qnil; \
-} 
-
-#define GL_SIMPLE_FUNC_LOAD(_name_,_numparams_,_ctype_,_conversion_) \
-static void (APIENTRY * fptr_gl##_name_)( TYPELIST##_numparams_(_ctype_) ); \
-static VALUE \
-gl_##_name_(ARGLIST##_numparams_) \
-VALUE ARGLIST##_numparams_; \
-{ \
-	LOAD_GL_FUNC(gl##_name_) \
-	fptr_gl##_name_(FUNCPARAMS##_numparams_(_ctype_,_conversion_)); \
-	return Qnil; \
-} 
-
-
-#define GL_EXT_SIMPLE_FUNC_LOAD(_name_,_numparams_,_ctype_,_conversion_,_extensionname_) \
-static void (APIENTRY * fptr_gl##_name_)( TYPELIST##_numparams_(_ctype_) ); \
-static VALUE \
-gl_##_name_(ARGLIST##_numparams_) \
-VALUE ARGLIST##_numparams_; \
-{ \
-	LOAD_GL_EXT_FUNC(gl##_name_,_extensionname_) \
-	fptr_gl##_name_(FUNCPARAMS##_numparams_(_ctype_,_conversion_)); \
-	return Qnil; \
-} 
+	return rb_funcall(ary,rb_intern("pack"),1,rb_str_new2(type_str));
+}
+
+/* -------------------------------------------------------------------- */
 
 #endif /* _COMMON_H_ */

data/ext/common/conv.h

@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+ *
+ * This program is distributed under the terms of the MIT license.
+ * See the included MIT-LICENSE file for the terms of this license.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* Functions and macros for datatype conversion between Ruby and C */
+
+/*
+   Fast inline conversion functions as a replacement for the ones in libruby.
+   FIXNUM_P is simple logical AND check so it comes first, TYPE() is simple function,
+   and specified in header file so it can be inlined. For conversion, FIX2LONG is
+   simple right shift, and RFLOAT()-> just pointer dereference. For converting
+   Fixnum and Float types (which accounts for 99.9% of things you would want to pass
+   to OpenGL), there is large performance boost as result.
+
+	 Also ruby 'true' and 'false' are converted to GL_TRUE/GL_FALSE for compatibility, and
+	 finally, we fallback to library functions for any other data types (and error handling).
+*/
+
+#if RUBY_VERSION <190
+#define	FLOAT_VAL_ACCESS(val) RFLOAT(val)->value
+#else
+#define	FLOAT_VAL_ACCESS(val) RFLOAT(val)->float_value
+#endif
+
+#define FASTCONV(_name_,_type_,_convfix_,_convfallback_) \
+static inline _type_ _name_(val) \
+VALUE val; \
+{ \
+	if (FIXNUM_P(val)) \
+		return (_type_) _convfix_(val); \
+\
+	if (TYPE(val) == T_FLOAT) \
+		return (_type_)FLOAT_VAL_ACCESS(val); \
+\
+	if ((val) == Qtrue) \
+		return (_type_)(GL_TRUE); \
+\
+	if ((val) == Qfalse || (val) == Qnil) \
+		return (_type_)(GL_FALSE); \
+\
+	return (_convfallback_(val)); \
+}
+
+FASTCONV(num2double,double,FIX2LONG,rb_num2dbl)
+#if SIZEOF_INT < SIZEOF_LONG
+/* For 64bit platforms with LP64 mode */
+FASTCONV(num2int,long,FIX2LONG,rb_num2int)
+FASTCONV(num2uint,unsigned long,FIX2ULONG,rb_num2uint)
+#else
+/* All other platforms */
+FASTCONV(num2int,long,FIX2LONG,(int)NUM2LONG)
+FASTCONV(num2uint,unsigned long,FIX2ULONG,(unsigned int)NUM2ULONG)
+#endif
+
+#undef NUM2DBL
+#define NUM2DBL num2double
+
+#undef NUM2INT
+#define NUM2INT num2int
+
+#undef NUM2UINT
+#define NUM2UINT num2uint
+
+#undef FASTCONV
+
+/* For conversion between ruby and GL boolean values */
+#define GLBOOL2RUBY(x) (x)==GL_TRUE? Qtrue :( (x)==GL_FALSE? Qfalse : INT2NUM((x)))
+#define RUBYBOOL2GL(x) (x)==Qtrue? GL_TRUE : GL_FALSE
+
+#define cond_GLBOOL2RUBY_FUNC(_name_,_type_,_conv_) \
+static inline VALUE _name_(GLenum pname,_type_ value) \
+{ \
+	switch (pname) { \
+	case GL_DELETE_STATUS: \
+	case GL_LINK_STATUS: \
+	case GL_VALIDATE_STATUS: \
+	case GL_COMPILE_STATUS: \
+	case GL_MINMAX_SINK: \
+	case GL_HISTOGRAM_SINK: \
+	case GL_COORD_REPLACE: \
+	case GL_TEXTURE_COMPRESSED: \
+	case GL_GENERATE_MIPMAP: \
+	case GL_TEXTURE_RESIDENT: \
+	case GL_BUFFER_MAPPED: \
+	case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: \
+	case GL_VERTEX_ATTRIB_ARRAY_ENABLED: \
+	case GL_QUERY_RESULT_AVAILABLE: \
+	case GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB: \
+	case GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT: \
+	case GL_FENCE_STATUS_NV: \
+	case GL_TEXTURE_FLOAT_COMPONENTS_NV: \
+	case GL_SHADER_CONSISTENT_NV: \
+	case GL_TEXTURE_COMPARE_SGIX: \
+	case GLU_TESS_BOUNDARY_ONLY: \
+	case GLU_CULLING: \
+	case GLU_AUTO_LOAD_MATRIX: \
+		return GLBOOL2RUBY(value); \
+	default: \
+		return _conv_(value); \
+	} \
+}
+
+cond_GLBOOL2RUBY_FUNC(cond_GLBOOL2RUBY,GLint,INT2NUM)
+cond_GLBOOL2RUBY_FUNC(cond_GLBOOL2RUBY_U,GLuint,UINT2NUM)
+cond_GLBOOL2RUBY_FUNC(cond_GLBOOL2RUBY_LL,GLint64EXT,LL2NUM)
+cond_GLBOOL2RUBY_FUNC(cond_GLBOOL2RUBY_ULL,GLuint64EXT,ULL2NUM)
+cond_GLBOOL2RUBY_FUNC(cond_GLBOOL2RUBY_F,GLfloat,rb_float_new)
+cond_GLBOOL2RUBY_FUNC(cond_GLBOOL2RUBY_D,GLdouble,rb_float_new)
+
+
+/* For conversion between ruby array (or object that can be converted to array) and C array.
+   The C array has to be preallocated by calling function. */
+#define ARY2CTYPE(_type_,_convert_) \
+static inline int ary2c##_type_( arg, cary, maxlen ) \
+VALUE arg; \
+GL##_type_ cary[]; \
+int maxlen; \
+{ \
+    int i; \
+    struct RArray* ary; \
+    ary = RARRAY(rb_Array(arg)); \
+    if (maxlen < 1) \
+        maxlen = ary->len; \
+    else \
+        maxlen = maxlen < ary->len ? maxlen : ary->len; \
+    for (i=0; i < maxlen; i++) \
+        cary[i] = (GL##_type_)_convert_(rb_ary_entry((VALUE)ary,i)); \
+    return i; \
+}
+
+ARY2CTYPE(int,NUM2INT)
+ARY2CTYPE(uint,NUM2UINT)
+ARY2CTYPE(byte,NUM2INT)
+ARY2CTYPE(ubyte,NUM2INT)
+ARY2CTYPE(short,NUM2INT)
+ARY2CTYPE(ushort,NUM2INT)
+ARY2CTYPE(boolean,NUM2INT)
+ARY2CTYPE(float,NUM2DBL)
+ARY2CTYPE(double,NUM2DBL)
+
+#define ary2cflt ary2cfloat
+#define ary2cdbl ary2cdouble
+
+#undef ARY2CTYPE
+
+/* Converts either array or object responding to #to_a to C-style array */
+#define ARY2CMAT(_type_) \
+static inline void ary2cmat##_type_(rary, cary, cols, rows, count) \
+VALUE rary; \
+_type_ cary[]; \
+int cols,rows; \
+{ \
+	int i; \
+\
+	rary = rb_Array(rary); \
+	rary = rb_funcall(rary,rb_intern("flatten"),0); \
+\
+	if (RARRAY(rary)->len != cols*rows) \
+		rb_raise(rb_eArgError, "passed array/matrix must have %i*%i elements",cols,rows); \
+\
+	for (i=0; i < cols*rows; i++) \
+		cary[i] = (_type_) NUM2DBL(rb_ary_entry(rary,i)); \
+}
+
+ARY2CMAT(double)
+ARY2CMAT(float)
+#undef ARY2CMAT
+
+#define ARY2CMATCNT(_type_) \
+static inline void ary2cmat##_type_##count(rary, cary, cols, rows) \
+VALUE rary; \
+_type_ cary[]; \
+int cols,rows; \
+{ \
+	int i; \
+\
+	rary = rb_Array(rary); \
+	rary = rb_funcall(rary,rb_intern("flatten"),0); \
+\
+	if (RARRAY_LEN(rary)<1 || (RARRAY_LEN(rary) % (cols*rows) != 0)) {\
+		xfree(cary); \
+		rb_raise(rb_eArgError, "passed array/matrix must conatain n x (%i*%i) elements",cols,rows); \
+	} \
+\
+	for (i=0; i < RARRAY_LEN(rary); i++) \
+		cary[i] = (_type_) NUM2DBL(rb_ary_entry(rary,i)); \
+}
+
+ARY2CMATCNT(double)
+ARY2CMATCNT(float)
+#undef ARY2CMATCNT
+
+
+#define EMPTY
+#define FREE(_x_) xfree(_x_);
+
+#define RET_ARRAY_OR_SINGLE(_size_,_conv_,_params_) RET_ARRAY_OR_SINGLE_FUNC(_size_,_conv_,_params_,EMPTY)
+#define RET_ARRAY_OR_SINGLE_FREE(_size_,_conv_,_params_) RET_ARRAY_OR_SINGLE_FUNC(_size_,_conv_,_params_,FREE(_params_))
+
+#define RET_ARRAY_OR_SINGLE_FUNC(_size_,_conv_,_params_,_extra_) \
+{ \
+	int iter; \
+	VALUE return_array; \
+	if (_size_ == 1) { \
+		return_array = _conv_(_params_[0]); \
+	} else { \
+		return_array = rb_ary_new2(_size_); \
+		for(iter=0;iter<_size_;iter++) \
+			rb_ary_push(return_array, _conv_(_params_[iter])); \
+	} \
+	_extra_ \
+	CHECK_GLERROR \
+	return return_array; \
+}
+
+#define RET_ARRAY_OR_SINGLE_BOOL(_size_,_conv_,_enum_,_params_) RET_ARRAY_OR_SINGLE_BOOL_FUNC(_size_,_conv_,_enum_,_params_,EMPTY)
+#define RET_ARRAY_OR_SINGLE_BOOL_FREE(_size_,_conv_,_enum_,_params_) RET_ARRAY_OR_SINGLE_BOOL_FUNC(_size_,_conv_,_enum_,_params_,FREE(_params_))
+
+#define RET_ARRAY_OR_SINGLE_BOOL_FUNC(_size_,_conv_,_enum_,_params_,_extra_) \
+{ \
+	int iter; \
+	VALUE return_array; \
+	if (_size_ == 1) { \
+		return_array = _conv_(_enum_,_params_[0]); \
+	} else { \
+		return_array = rb_ary_new2(_size_); \
+		for(iter=0;iter<_size_;iter++) \
+			rb_ary_push(return_array, _conv_(_enum_,_params_[iter])); \
+	} \
+	_extra_ \
+	CHECK_GLERROR \
+	return return_array; \
+}