opengl 0.7.0.pre1-x86-mingw32

data/ext/common/common.h

@@ -0,0 +1,448 @@
+/*
+ * Last edit by previous maintainer:
+ * 2000/01/06 16:37:43, kusano
+ *
+ * Copyright (C) 1999 - 2005 Yoshi <yoshi@giganet.net>
+ * Copyright (C) 2006 John M. Gabriele <jmg3000@gmail.com>
+ * Copyright (C) 2007 James Adam <james@lazyatom.com>
+ * 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.
+ */
+
+#ifndef _COMMON_H_
+#define _COMMON_H_
+
+#include <ruby.h>
+#include "extconf.h"
+
+#include <ctype.h>
+
+#ifdef HAVE_OPENGL_GL_H
+#include <OpenGL/gl.h>
+#endif
+
+#ifdef HAVE_OPENGL_GLU_H
+#include <OpenGL/glu.h>
+#endif
+
+#ifdef HAVE_GLUT_GLUT_H
+#include <GLUT/glut.h>
+#endif
+
+#ifdef HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+#if false
+#include <stdlib.h>
+#include <string.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+
+#ifdef HAVE_GL_GL_H
+#include <GL/gl.h>
+#endif
+
+#ifdef HAVE_GL_GLU_H
+#include <GL/glu.h>
+#endif
+
+#ifdef HAVE_GL_GLUT_H
+#include <GL/glut.h>
+#endif
+
+#ifdef HAVE_GL_GLX_H
+#include <GL/glx.h>
+#endif
+
+#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
+#endif
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+#ifndef GLUTCALLBACK
+#define GLUTCALLBACK
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+
+/* these two macros are cast to a 32 bit type in the places they are used */
+#ifndef RARRAY_LENINT
+#define RARRAY_LENINT RARRAY_LEN
+#endif
+
+#ifndef RSTRING_LENINT
+#define RSTRING_LENINT RSTRING_LEN
+#endif
+
+/* */
+
+/* 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;
+
+/* 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); \
+	glPixelStorei(GL_PACK_SKIP_PIXELS, 0); \
+	glPixelStorei(GL_PACK_SKIP_ROWS, 0); \
+	glPixelStorei(GL_PACK_ROW_LENGTH, 0); \
+	glPixelStorei(GL_PACK_SKIP_IMAGES, 0); \
+	glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0); \
+	if (CheckVersionExtension("GL_SGIS_texture4D")) { \
+		glPixelStorei(GL_PACK_SKIP_VOLUMES_SGIS, 0); \
+		glPixelStorei(GL_PACK_IMAGE_DEPTH_SGIS, 0); \
+	}
+
+#define RESTORE_PIXEL_STORE_MODE \
+	glPopClientAttrib();
+
+GLboolean CheckVersionExtension(const char *name);
+GLint CheckBufferBinding(GLint buffer);
+
+/* -------------------------------------------------------------------- */
+
+/* gets number of components for given format */
+static inline int glformat_size(GLenum format)
+{
+	switch(format)
+	{
+		case GL_COLOR_INDEX:
+		case GL_RED:
+		case GL_GREEN:
+		case GL_BLUE:
+		case GL_ALPHA:
+		case GL_RED_INTEGER_EXT:
+		case GL_GREEN_INTEGER_EXT:
+		case GL_BLUE_INTEGER_EXT:
+		case GL_ALPHA_INTEGER_EXT:
+		case GL_STENCIL_INDEX:
+		case GL_DEPTH_COMPONENT:
+		case GL_LUMINANCE:
+		case GL_LUMINANCE_INTEGER_EXT:
+			return 1;
+		
+		case GL_LUMINANCE_ALPHA:
+		case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+		case GL_422_EXT:
+		case GL_422_REV_EXT:
+		case GL_422_AVERAGE_EXT:
+		case GL_422_REV_AVERAGE_EXT:
+		case GL_YCRCB_422_SGIX:
+		case GL_YCBCR_422_APPLE:
+		case GL_YCBCR_MESA:
+		case GL_DEPTH_STENCIL_NV:
+		case GL_HILO_NV:
+		case GL_DSDT_NV:
+		case GL_DUDV_ATI:
+		case GL_DU8DV8_ATI:
+		case GL_FORMAT_SUBSAMPLE_24_24_OML:
+			return 2;
+		
+		case GL_RGB:
+		case GL_RGB_INTEGER_EXT:
+		case GL_BGR_EXT:
+		case GL_BGR_INTEGER_EXT:
+		case GL_YCRCB_444_SGIX:
+		case GL_DSDT_MAG_NV:
+		case GL_FORMAT_SUBSAMPLE_244_244_OML:
+			return 3;
+		
+		case GL_RGBA:
+		case GL_RGBA_INTEGER_EXT:
+		case GL_BGRA_EXT:
+		case GL_BGRA_INTEGER_EXT:
+		case GL_ABGR_EXT:
+		case GL_CMYK_EXT:
+		case GL_DSDT_MAG_VIB_NV:
+			return 4;
+
+		case GL_CMYKA_EXT:
+			return 5;
+
+		/* GL spec permits passing direct format size instead of enum (now obsolete) */
+		case 1:
+		case 2:
+		case 3:
+		case 4:
+			return format;
+
+		default:
+			rb_raise(rb_eArgError, "Unknown GL format enum %i",format);
+			return -1; /* not reached */
+	}
+}
+
+/* computes unit (pixel) size for given type and format */
+static inline int gltype_glformat_unit_size(GLenum type,GLenum format)
+{
+	unsigned int format_size;
+	
+	format_size = glformat_size(format);
+	
+	switch(type)
+	{
+		case GL_BYTE:
+		case GL_UNSIGNED_BYTE:
+		case GL_BITMAP:
+			return 1*format_size;
+
+		case GL_SHORT:
+		case GL_UNSIGNED_SHORT:
+		case GL_HALF_FLOAT_ARB:
+			return 2*format_size;
+
+		case GL_INT:
+		case GL_UNSIGNED_INT:
+		case GL_FLOAT:
+			return 4*format_size;
+
+		/* in packed formats all components are packed into/unpacked from single datatype,
+		   so number of components(format_size) doesn't matter for total size calculation */
+		case GL_UNSIGNED_BYTE_3_3_2:
+		case GL_UNSIGNED_BYTE_2_3_3_REV:
+			return 1;
+
+		case GL_UNSIGNED_SHORT_5_6_5:
+		case GL_UNSIGNED_SHORT_5_6_5_REV:
+		case GL_UNSIGNED_SHORT_4_4_4_4:
+		case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+		case GL_UNSIGNED_SHORT_5_5_5_1:
+		case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+		case GL_UNSIGNED_SHORT_8_8_APPLE:
+		case GL_UNSIGNED_SHORT_8_8_REV_APPLE:
+			return 2;
+
+		case GL_UNSIGNED_INT_8_8_8_8:
+		case GL_UNSIGNED_INT_8_8_8_8_REV:
+		case GL_UNSIGNED_INT_10_10_10_2:
+		case GL_UNSIGNED_INT_2_10_10_10_REV:
+		case GL_UNSIGNED_INT_24_8_NV:
+		case GL_UNSIGNED_INT_S8_S8_8_8_NV:
+		case GL_UNSIGNED_INT_8_8_S8_S8_REV_NV:
+		case GL_UNSIGNED_INT_10F_11F_11F_REV_EXT:
+		case GL_UNSIGNED_INT_5_9_9_9_REV_EXT:
+		case GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV:
+			return 4;
+	
+		default:
+			rb_raise(rb_eArgError, "Unknown GL type enum %i",type);
+			return -1; /* not reached */
+	}
+}
+
+/* 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;
+	int unit_size;
+
+	unit_size = gltype_glformat_unit_size(type,format);
+	
+	if (type==GL_BITMAP)
+		size = unit_size*(num/8); /* FIXME account for alignment */
+	else
+		size = unit_size*num;
+
+	return size;
+}
+
+/* Checks if data size of 'data' string confirms to passed format values */
+/* 'num' is number of elements, each of size 'format' * 'type' */
+static inline void CheckDataSize(GLenum type,GLenum format,int num,VALUE data)
+{
+	int size;
+
+	size = GetDataSize(type,format,num);
+	
+	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);
+}
+
+/* -------------------------------------------------------------------- */
+static inline VALUE allocate_buffer_with_string( long size )
+{
+    return rb_str_new(NULL, size);
+}
+
+/* -------------------------------------------------------------------- */
+static inline void *load_gl_function(const char *name,int raise) 
+{
+	void *func_ptr = NULL;
+
+#if defined(__APPLE__)
+	void *library = NULL;
+	char* symbolName;
+  library = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
+
+	if (library == NULL)
+		rb_raise(rb_eRuntimeError,"Can't load OpenGL library for dynamic loading");
+		
+	/*  prepend a '_' for the Unix C symbol mangling convention  */
+	symbolName = ALLOC_N(char,strlen(name) + 2);
+	symbolName[0] = '_';
+	strcpy(symbolName+1, name);
+
+  func_ptr = dlsym(library, symbolName);
+	xfree(symbolName);
+  dlclose(library);
+#elif HAVE_WGLGETPROCADDRESS
+	func_ptr = wglGetProcAddress((LPCSTR)name);
+#elif defined(GLX_VERSION_1_4)
+	func_ptr = glXGetProcAddress((const GLubyte *)name);
+#else
+	func_ptr = glXGetProcAddressARB((const GLubyte *)name);
+#endif
+
+	if (func_ptr == NULL && raise == 1)
+		rb_raise(rb_eNotImpError,"Function %s is not available on this system",name);
+
+	return func_ptr;
+}
+
+static inline VALUE pack_array_or_pass_string(GLenum type,VALUE ary)
+{
+	const 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 */
+	}
+
+	return rb_funcall(ary,rb_intern("pack"),1,rb_str_new2(type_str));
+}
+
+/* -------------------------------------------------------------------- */
+
+#endif /* _COMMON_H_ */

data/ext/common/conv.h

@@ -0,0 +1,234 @@
+/*
+ * 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 HAVE_STRUCT_RFLOAT_FLOAT_VALUE
+#define	FLOAT_VAL_ACCESS(val) RFLOAT(val)->float_value
+#else
+#define	FLOAT_VAL_ACCESS(val) RFLOAT(val)->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 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 long ary2c##_type_( arg, cary, maxlen ) \
+VALUE arg; \
+GL##_type_ cary[]; \
+long maxlen; \
+{ \
+    long i; \
+    VALUE ary = rb_Array(arg); \
+    if (maxlen < 1) \
+        maxlen = RARRAY_LEN(ary); \
+    else \
+        maxlen = maxlen < RARRAY_LEN(ary) ? maxlen : RARRAY_LEN(ary); \
+    for (i=0; i < maxlen; i++) \
+        cary[i] = (GL##_type_)_convert_(rb_ary_entry(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) \
+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) != 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; \
+}