ruby-opengl 0.40.1 → 0.50.0

data/ext/gl/gl-1.2.c

@@ -15,47 +15,12 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifdef __APPLE__
-#include <OpenGL/gl.h>
-#elif defined WIN32
-#include <windows.h>
-#include <GL/gl.h>
-#else
-#include <GL/gl.h>
-#endif
 #include "../common/common.h"
 
 /* OpenGL 1.2 functions */
 
-static void (APIENTRY * fptr_glBlendColor)(GLclampf,GLclampf,GLclampf,GLclampf);
-static VALUE
-gl_BlendColor(obj,arg1,arg2,arg3,arg4)
-VALUE obj,arg1,arg2,arg3,arg4;
-{
-	GLclampf red;
-	GLclampf green;
-	GLclampf blue;
-	GLclampf alpha;
-	LOAD_GL_FUNC(glBlendColor)
-	red = (GLclampf)NUM2DBL(arg1);
-	green = (GLclampf)NUM2DBL(arg2);
-	blue = (GLclampf)NUM2DBL(arg3);
-	alpha = (GLclampf)NUM2DBL(arg4);
-	fptr_glBlendColor(red,green,blue,alpha);
-	return Qnil;
-}
-
-static void (APIENTRY * fptr_glBlendEquation)(GLenum);
-static VALUE
-gl_BlendEquation(obj,arg1)
-VALUE obj,arg1;
-{
-	GLenum mode;
-	LOAD_GL_FUNC(glBlendEquation)
-	mode = (GLenum)NUM2INT(arg1);
-	fptr_glBlendEquation(mode);
-	return Qnil;
-}
+GL_SIMPLE_FUNC_LOAD(BlendColor,4,GLclampf,NUM2DBL)
+GL_SIMPLE_FUNC_LOAD(BlendEquation,1,GLenum,NUM2INT)
 
 static void (APIENTRY * fptr_glDrawRangeElements)(GLenum,GLuint,GLuint,GLsizei,GLenum,GLvoid*);
 static VALUE
@@ -73,8 +38,12 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
 	end = (GLuint)NUM2UINT(arg3);
 	count = (GLsizei)NUM2UINT(arg4);
 	type = (GLenum)NUM2INT(arg5);
-	Check_Type(arg6, T_STRING);
-	fptr_glDrawRangeElements(mode, start, end, count, type, RSTRING(arg6)->ptr);
+	if (CheckBufferBinding(GL_ELEMENT_ARRAY_BUFFER_BINDING)) {
+		fptr_glDrawRangeElements(mode, start, end, count, type, (GLvoid *)NUM2INT(arg6));
+	} else {
+		Check_Type(arg6, T_STRING);
+		fptr_glDrawRangeElements(mode, start, end, count, type, RSTRING(arg6)->ptr);
+	}
 	return Qnil;
 }
 
@@ -88,24 +57,19 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
 	GLsizei width;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
-	GLsizei size;
 	LOAD_GL_FUNC(glColorTable)
 	target = (GLenum)NUM2INT(arg1);
 	internalformat = (GLenum)NUM2INT(arg2);
 	width = (GLsizei)NUM2UINT(arg3);
 	format = (GLenum)NUM2INT(arg4);
 	type = (GLenum)NUM2INT(arg5);
-	Check_Type(arg6,T_STRING);
-	format_size = glformat_size(format);	
-	type_size = gltype_size(type);	
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
-	size = format_size*type_size*width;
-	if (RSTRING(arg6)->len < size)
-		rb_raise(rb_eArgError, "string length:%d", RSTRING(arg6)->len);
-	fptr_glColorTable(target,internalformat,width,format,type,RSTRING(arg6)->ptr);
+	if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+		fptr_glColorTable(target,internalformat,width,format,type,(GLvoid *)NUM2INT(arg6));
+	} else {
+		Check_Type(arg6,T_STRING);
+		CheckDataSize(type,format,width,arg6);
+		fptr_glColorTable(target,internalformat,width,format,type,RSTRING(arg6)->ptr);
+	}
 	return Qnil;
 }
 
@@ -156,9 +120,9 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5;
 	LOAD_GL_FUNC(glCopyColorTable)
 	target = (GLenum)NUM2INT(arg1);
 	internalformat = (GLenum)NUM2INT(arg2);
-	x = (GLenum)NUM2INT(arg3);
-	y = (GLenum)NUM2INT(arg4);
-	width = (GLenum)NUM2INT(arg5);
+	x = (GLint)NUM2INT(arg3);
+	y = (GLint)NUM2INT(arg4);
+	width = (GLsizei)NUM2INT(arg5);
 	fptr_glCopyColorTable(target,internalformat,x,y,width);
 	return Qnil;
 }
@@ -231,9 +195,6 @@ VALUE obj,arg1,arg2,arg3;
 	GLenum target;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
-	GLsizei size;
 	GLsizei width = 0;
 	VALUE data;
 	LOAD_GL_FUNC(glGetColorTable)
@@ -241,16 +202,8 @@ VALUE obj,arg1,arg2,arg3;
 	target = (GLenum)NUM2INT(arg1);
 	format = (GLenum)NUM2INT(arg2);
 	type = (GLenum)NUM2INT(arg3);
-	format_size = glformat_size(format);
-	type_size = gltype_size(type);
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
 	fptr_glGetColorTableParameteriv(target,GL_COLOR_TABLE_WIDTH,&width);
-	if (type==GL_BITMAP)
-		size = format_size*(width/8);
-	else
-		size = type_size*format_size*width;
-	data = allocate_buffer_with_string(size);
+	data = allocate_buffer_with_string(GetDataSize(type,format,width));
 	FORCE_PIXEL_STORE_MODE
 	fptr_glGetColorTable(target,format,type,(GLvoid*)RSTRING(data)->ptr);	
 	RESTORE_PIXEL_STORE_MODE
@@ -267,24 +220,19 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
 	GLsizei count;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
-	GLsizei size;
 	LOAD_GL_FUNC(glColorSubTable)
 	target = (GLenum)NUM2INT(arg1);	
 	start = (GLsizei)NUM2UINT(arg2);	
 	count = (GLsizei)NUM2UINT(arg3);	
 	format = (GLenum)NUM2INT(arg4);	
 	type = (GLenum)NUM2INT(arg5);	
-	Check_Type(arg6,T_STRING);
-	format_size = glformat_size(format);	
-	type_size = gltype_size(type);	
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
-	size = format_size*type_size*count;
-	if (RSTRING(arg6)->len < size)
-		rb_raise(rb_eArgError, "string length:%d", RSTRING(arg6)->len);
-	fptr_glColorSubTable(target,start,count,format,type,RSTRING(arg6)->ptr);
+	if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+		fptr_glColorSubTable(target,start,count,format,type,(GLvoid *)NUM2INT(arg6));
+	} else {
+		Check_Type(arg6,T_STRING);
+		CheckDataSize(type,format,count,arg6);
+		fptr_glColorSubTable(target,start,count,format,type,RSTRING(arg6)->ptr);
+	}
 	return Qnil;
 }
 
@@ -318,27 +266,19 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
 	GLsizei width;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
-	GLsizei size;
 	LOAD_GL_FUNC(glConvolutionFilter1D)
 	target = (GLenum)NUM2INT(arg1);
 	internalformat = (GLenum)NUM2INT(arg2);
 	width = (GLsizei)NUM2UINT(arg3);
 	format = (GLenum)NUM2INT(arg4);
 	type = (GLenum)NUM2INT(arg5);
-	Check_Type(arg6,T_STRING);
-	format_size = glformat_size(format);	
-	type_size = gltype_size(type);	
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
-	if (type==GL_BITMAP)
-		size = format_size*(width/8);
-	else
-		size = type_size*format_size*width;
-	if (RSTRING(arg6)->len < size)
-		rb_raise(rb_eArgError, "string length:%d", RSTRING(arg6)->len);
-	fptr_glConvolutionFilter1D(target,internalformat,width,format,type,RSTRING(arg6)->ptr);
+	if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+		fptr_glConvolutionFilter1D(target,internalformat,width,format,type,(GLvoid *)NUM2INT(arg6));
+	} else {
+		Check_Type(arg6,T_STRING);
+		CheckDataSize(type,format,width,arg6);
+		fptr_glConvolutionFilter1D(target,internalformat,width,format,type,RSTRING(arg6)->ptr);
+	}
 	return Qnil;
 }
 
@@ -353,9 +293,6 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
 	GLsizei height;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
-	GLsizei size;
 	LOAD_GL_FUNC(glConvolutionFilter2D)
 	target = (GLenum)NUM2INT(arg1);
 	internalformat = (GLenum)NUM2INT(arg2);
@@ -363,18 +300,13 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
 	height = (GLsizei)NUM2UINT(arg4);
 	format = (GLenum)NUM2INT(arg5);
 	type = (GLenum)NUM2INT(arg6);
-	Check_Type(arg7,T_STRING);
-	format_size = glformat_size(format);
-	type_size = gltype_size(type);
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
-	if (type==GL_BITMAP)
-		size = format_size*((width*height)/8);
-	else
-		size = type_size*format_size*width*height;
-	if (RSTRING(arg7)->len < size)
-		rb_raise(rb_eArgError, "string length:%d", RSTRING(arg7)->len);
-	fptr_glConvolutionFilter2D(target,internalformat,width,height,format,type,RSTRING(arg7)->ptr);
+	if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+		fptr_glConvolutionFilter2D(target,internalformat,width,height,format,type,(GLvoid *)NUM2INT(arg7));
+	} else {
+		Check_Type(arg7,T_STRING);
+		CheckDataSize(type,format,width*height,arg7);
+		fptr_glConvolutionFilter2D(target,internalformat,width,height,format,type,RSTRING(arg7)->ptr);
+	}
 	return Qnil;
 }
 
@@ -550,86 +482,107 @@ VALUE obj,arg1,arg2;
 
 static void (APIENTRY * fptr_glGetConvolutionFilter)(GLenum,GLenum,GLenum,GLvoid *);
 static VALUE
-gl_GetConvolutionFilter(obj,arg1,arg2,arg3)
-VALUE obj,arg1,arg2,arg3;
+gl_GetConvolutionFilter(argc,argv,obj)
+int argc;
+VALUE *argv;
+VALUE obj;
 {
 	GLenum target;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
+	//GLsizei format_size;
+	//GLsizei type_size;
 	GLint size = 0;
 	VALUE data;
+	VALUE args[4];
+	int numargs;
 	LOAD_GL_FUNC(glGetConvolutionFilter)
 	LOAD_GL_FUNC(glGetConvolutionParameteriv)
-	target = (GLenum)NUM2INT(arg1);
-	format = (GLenum)NUM2INT(arg2);
-	type = (GLenum)NUM2INT(arg3);
-	format_size = glformat_size(format);
-	type_size = gltype_size(type);
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
-	if (target==GL_CONVOLUTION_1D) {
-		fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_WIDTH,&size);
-	} else {
-		GLint tmp = 0;
-		fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_WIDTH,&tmp);
-		fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_HEIGHT,&size);
-		size *=tmp;
+	numargs = rb_scan_args(argc, argv, "31", &args[0], &args[1], &args[2], &args[3]);
+	target = (GLenum)NUM2INT(args[0]);
+	format = (GLenum)NUM2INT(args[1]);
+	type = (GLenum)NUM2INT(args[2]);
+
+	switch(numargs) {
+		default:
+		case 3:
+			if (CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+			rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset argument missing");
+	
+			if (target==GL_CONVOLUTION_1D) {
+				fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_WIDTH,&size);
+			} else {
+				GLint tmp = 0;
+				fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_WIDTH,&tmp);
+				fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_HEIGHT,&size);
+				size *=tmp;
+			}
+			data = allocate_buffer_with_string(GetDataSize(type,format,size));
+			FORCE_PIXEL_STORE_MODE
+			fptr_glGetConvolutionFilter(target,format,type,(GLvoid*)RSTRING(data)->ptr);
+			RESTORE_PIXEL_STORE_MODE
+			return data;
+		case 4:
+			if (!CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+				rb_raise(rb_eArgError, "Pixel pack buffer not bound");
+
+			FORCE_PIXEL_STORE_MODE
+			fptr_glGetConvolutionFilter(target,format,type,(GLvoid*)NUM2INT(args[3]));
+			RESTORE_PIXEL_STORE_MODE
+			return Qnil;
 	}
-	if (type==GL_BITMAP)
-		size = (size/8)*format_size;
-	else
-		size = size*type_size*format_size;
-	data = allocate_buffer_with_string(size);
-	FORCE_PIXEL_STORE_MODE
-	fptr_glGetConvolutionFilter(target,format,type,(GLvoid*)RSTRING(data)->ptr);
-	RESTORE_PIXEL_STORE_MODE
-	return data;
 }
 
 static void (APIENTRY * fptr_glGetSeparableFilter)(GLenum,GLenum,GLenum,GLvoid*,GLvoid*,GLvoid*);
 static VALUE
-gl_GetSeparableFilter(obj,arg1,arg2,arg3)
-VALUE obj,arg1,arg2,arg3;
+gl_GetSeparableFilter(argc,argv,obj)
+int argc;
+VALUE *argv;
+VALUE obj;
 {
 	GLenum target;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
 	GLint size_row = 0;
 	GLint size_column = 0;
 	VALUE data_row;
 	VALUE data_column;
 	VALUE retary;
+	VALUE args[6];
+	int numargs;
 	LOAD_GL_FUNC(glGetSeparableFilter)
 	LOAD_GL_FUNC(glGetConvolutionParameteriv)
-	target = (GLenum)NUM2INT(arg1);
-	format = (GLenum)NUM2INT(arg2);
-	type = (GLenum)NUM2INT(arg3);
-	format_size = glformat_size(format);
-	type_size = gltype_size(type);
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
-	fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_WIDTH,&size_row);
-	fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_HEIGHT,&size_column);
-	if (type==GL_BITMAP) {
-		size_row = (size_row/8)*format_size;
-		size_column = (size_column/8)*format_size;
-	} else {
-		size_row *= type_size*format_size;
-		size_column *= type_size*format_size;
-	}
-	data_row = allocate_buffer_with_string(size_row);
-	data_column = allocate_buffer_with_string(size_column);
-	FORCE_PIXEL_STORE_MODE
-	fptr_glGetSeparableFilter(target,format,type,(GLvoid*)RSTRING(data_row)->ptr,(GLvoid*)RSTRING(data_column)->ptr,0);
-	RESTORE_PIXEL_STORE_MODE
-	retary = rb_ary_new2(2);
-	rb_ary_push(retary, data_row);
-	rb_ary_push(retary, data_column);
-	return retary;
+	numargs = rb_scan_args(argc, argv, "33", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5]);
+	target = (GLenum)NUM2INT(args[0]);
+	format = (GLenum)NUM2INT(args[1]);
+	type = (GLenum)NUM2INT(args[2]);
+
+	switch(numargs) {
+		default:
+		case 3:
+			if (CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+				rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset arguments missing");
+
+			fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_WIDTH,&size_row);
+			fptr_glGetConvolutionParameteriv(target,GL_CONVOLUTION_HEIGHT,&size_column);
+			data_row = allocate_buffer_with_string(GetDataSize(type,format,size_row));
+			data_column = allocate_buffer_with_string(GetDataSize(type,format,size_column));
+			FORCE_PIXEL_STORE_MODE
+			fptr_glGetSeparableFilter(target,format,type,(GLvoid*)RSTRING(data_row)->ptr,(GLvoid*)RSTRING(data_column)->ptr,0);
+			RESTORE_PIXEL_STORE_MODE
+			retary = rb_ary_new2(2);
+			rb_ary_push(retary, data_row);
+			rb_ary_push(retary, data_column);
+			return retary;
+			break;
+		case 6:
+			if (!CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+				rb_raise(rb_eArgError, "Pixel pack buffer not bound");
+			FORCE_PIXEL_STORE_MODE
+			fptr_glGetSeparableFilter(target,format,type,(GLvoid*)NUM2INT(args[3]),(GLvoid*)NUM2INT(args[4]),(GLvoid*)NUM2INT(args[5]));
+			RESTORE_PIXEL_STORE_MODE
+			return Qnil;		
+		}
 }
 
 static void (APIENTRY * fptr_glSeparableFilter2D)(GLenum,GLenum,GLsizei,GLsizei,GLenum,GLenum,const GLvoid *,const GLvoid *);
@@ -643,10 +596,6 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8;
 	GLsizei height;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
-	GLsizei size_row;
-	GLsizei size_column;
 	LOAD_GL_FUNC(glSeparableFilter2D)
 	target = (GLenum)NUM2INT(arg1);
 	internalformat = (GLenum)NUM2INT(arg2);
@@ -654,25 +603,15 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8;
 	height = (GLsizei)NUM2UINT(arg4);
 	format = (GLenum)NUM2INT(arg5);
 	type = (GLenum)NUM2INT(arg6);
-	Check_Type(arg7,T_STRING);
-	Check_Type(arg8,T_STRING);
-	format_size = glformat_size(format);
-	type_size = gltype_size(type);
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
-	if (type==GL_BITMAP) {
-		size_row = format_size*(width/8);
-		size_column = format_size*(height/8);
+	if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+		fptr_glSeparableFilter2D(target,internalformat,width,height,format,type,(GLvoid *)NUM2INT(arg7),(GLvoid *)NUM2INT(arg8));
 	} else {
-		size_row = type_size*format_size*width;		
-		size_column = type_size*format_size*height;		
+		Check_Type(arg7,T_STRING);
+		Check_Type(arg8,T_STRING);
+		CheckDataSize(type,format,width,arg7);
+		CheckDataSize(type,format,height,arg8);
+		fptr_glSeparableFilter2D(target,internalformat,width,height,format,type,RSTRING(arg7)->ptr,RSTRING(arg8)->ptr);
 	}
-	if (RSTRING(arg7)->len < size_row)
-		rb_raise(rb_eArgError, "string length:%d", RSTRING(arg7)->len);
-	if (RSTRING(arg8)->len < size_column)
-		rb_raise(rb_eArgError, "string length:%d", RSTRING(arg8)->len);
-
-	fptr_glSeparableFilter2D(target,internalformat,width,height,format,type,RSTRING(arg7)->ptr,RSTRING(arg8)->ptr);
 	return Qnil;
 }
 
@@ -714,70 +653,93 @@ VALUE obj,arg1,arg2,arg3;
 
 static void (APIENTRY * fptr_glGetHistogram)(GLenum,GLboolean,GLenum,GLenum,GLvoid*);
 static VALUE
-gl_GetHistogram(obj,arg1,arg2,arg3,arg4)
-VALUE obj,arg1,arg2,arg3,arg4;
+gl_GetHistogram(argc,argv,obj)
+int argc;
+VALUE *argv;
+VALUE obj;
 {
 	GLenum target;
 	GLboolean reset;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
 	GLint size = 0;
 	VALUE data;
+	VALUE args[5];
+	int numargs;
 	LOAD_GL_FUNC(glGetHistogram)
 	LOAD_GL_FUNC(glGetHistogramParameteriv)
-	target = (GLenum)NUM2INT(arg1);
-	reset = (GLboolean)NUM2INT(arg2);
-	format = (GLenum)NUM2INT(arg3);
-	type = (GLenum)NUM2INT(arg4);
-	format_size = glformat_size(format);
-	type_size = gltype_size(type);
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
-	fptr_glGetHistogramParameteriv(target,GL_HISTOGRAM_WIDTH,&size);
-	if (type==GL_BITMAP)
-		size = (size/8)*format_size;
-	else
-		size = size*type_size*format_size;
-	data = allocate_buffer_with_string(size);
-	FORCE_PIXEL_STORE_MODE
-	fptr_glGetHistogram(target,reset,format,type,(GLvoid*)RSTRING(data)->ptr);
-	RESTORE_PIXEL_STORE_MODE
-	return data;
+	numargs = rb_scan_args(argc, argv, "41", &args[0], &args[1], &args[2], &args[3], &args[4]);
+	target = (GLenum)NUM2INT(args[0]);
+	reset = (GLboolean)NUM2INT(args[1]);
+	format = (GLenum)NUM2INT(args[2]);
+	type = (GLenum)NUM2INT(args[3]);
+
+	switch(numargs) {
+		default:
+		case 4:
+			if (CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+				rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset argument missing");
+
+			fptr_glGetHistogramParameteriv(target,GL_HISTOGRAM_WIDTH,&size);
+			data = allocate_buffer_with_string(GetDataSize(type,format,size));
+			FORCE_PIXEL_STORE_MODE
+			fptr_glGetHistogram(target,reset,format,type,(GLvoid*)RSTRING(data)->ptr);
+			RESTORE_PIXEL_STORE_MODE
+			return data;
+			break;
+		case 5:
+			if (!CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+				rb_raise(rb_eArgError, "Pixel pack buffer not bound");
+
+			FORCE_PIXEL_STORE_MODE
+			fptr_glGetHistogram(target,reset,format,type,(GLvoid*)NUM2INT(args[4]));
+			RESTORE_PIXEL_STORE_MODE
+			return Qnil;
+	}
 }
 
 static void (APIENTRY * fptr_glGetMinmax)(GLenum,GLboolean,GLenum,GLenum,GLvoid *);
 static VALUE
-gl_GetMinmax(obj,arg1,arg2,arg3,arg4)
-VALUE obj,arg1,arg2,arg3,arg4;
+gl_GetMinmax(argc,argv,obj)
+int argc;
+VALUE *argv;
+VALUE obj;
 {
 	GLenum target;
 	GLboolean reset;
 	GLenum format;
 	GLenum type;
-	GLsizei format_size;
-	GLsizei type_size;
-	GLint size;
 	VALUE data;
+	VALUE args[5];
+	int numargs;
 	LOAD_GL_FUNC(glGetMinmax)
-	target = (GLenum)NUM2INT(arg1);
-	reset = (GLboolean)NUM2INT(arg2);
-	format = (GLenum)NUM2INT(arg3);
-	type = (GLenum)NUM2INT(arg4);
-	format_size = glformat_size(format);
-	type_size = gltype_size(type);
-	if (type_size == -1 || format_size == -1)
-		rb_raise(rb_eTypeError, "type/format mismatch");
-	if (type==GL_BITMAP)
-		size = format_size*(2/8);
-	else
-		size = type_size*format_size*2;
-	data = allocate_buffer_with_string(size);
-	FORCE_PIXEL_STORE_MODE
-	fptr_glGetMinmax(target,reset,format,type,(GLvoid*)RSTRING(data)->ptr);
-	RESTORE_PIXEL_STORE_MODE
-	return data;
+	numargs = rb_scan_args(argc, argv, "41", &args[0], &args[1], &args[2], &args[3], &args[4]);
+	target = (GLenum)NUM2INT(args[0]);
+	reset = (GLboolean)NUM2INT(args[1]);
+	format = (GLenum)NUM2INT(args[2]);
+	type = (GLenum)NUM2INT(args[3]);
+
+	switch(numargs) {
+		default:
+		case 4:
+			if (CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+				rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset argument missing");
+
+			data = allocate_buffer_with_string(GetDataSize(type,format,2));
+			FORCE_PIXEL_STORE_MODE
+			fptr_glGetMinmax(target,reset,format,type,(GLvoid*)RSTRING(data)->ptr);
+			RESTORE_PIXEL_STORE_MODE
+			return data;
+			break;
+		case 5:
+			if (!CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+				rb_raise(rb_eArgError, "Pixel pack buffer not bound");
+
+			FORCE_PIXEL_STORE_MODE
+			fptr_glGetMinmax(target,reset,format,type,(GLvoid*)NUM2INT(args[4]));
+			RESTORE_PIXEL_STORE_MODE
+			return Qnil;
+	}
 }
 
 static void (APIENTRY * fptr_glGetMinmaxParameterfv)(GLenum,GLenum,GLfloat *);
@@ -889,9 +851,6 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10;
 	GLenum format;
 	GLenum type;
 	const char *pixels;
-	int size;
-	int type_size;
-	int format_size;
 	LOAD_GL_FUNC(glTexImage3D)
 	target = (GLenum)NUM2INT(arg1);
 	level = (GLint)NUM2INT(arg2);
@@ -902,29 +861,23 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10;
 	border = (GLint)NUM2INT(arg7);
 	format = (GLenum)NUM2INT(arg8);
 	type = (GLenum)NUM2INT(arg9);
-	Check_Type(arg10, T_STRING);
-	type_size = gltype_size(type);
-	format_size = glformat_size(format);
-	if (type_size == -1 || format_size == -1)
+
+	if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+		fptr_glTexImage3D( target, level, internalFormat, width, height,
+					  depth, border, format, type,(GLvoid *)NUM2INT(arg10));
 		return Qnil;
-	if (type==GL_BITMAP)
-		size = format_size*((height*width*depth)/8);
-	else	
-		size = type_size*format_size*height*width*depth;
+	}
 
-	if (target == GL_PROXY_TEXTURE_3D || NIL_P(arg10)) { /* proxy texture, no data read */
+	if (target == GL_PROXY_TEXTURE_3D  ||
+			target == GL_PROXY_TEXTURE_1D_STACK_MESAX ||
+			target == GL_PROXY_TEXTURE_2D_STACK_MESAX ||
+			target == GL_PROXY_TEXTURE_2D_ARRAY_EXT ||
+			NIL_P(arg10)) { /* proxy texture, no data read */
 		pixels = NULL;
 	} else {
-		if (TYPE(arg10) == T_FIXNUM || TYPE(arg10) == T_BIGNUM) { /* arg10 is offset to unpack buffer */
-			pixels = (const char *)NUM2UINT(arg10);
-		} else if (TYPE(arg10) == T_STRING) { /* image data */
-			if (RSTRING(arg10)->len < size)
-				rb_raise(rb_eArgError, "string length:%d",RSTRING(arg10)->len);
-			pixels = RSTRING(arg10)->ptr;
-		} else {
-			Check_Type(arg10,T_STRING); /* force exception */
-			return Qnil;
-		}
+		Check_Type(arg10,T_STRING);
+		CheckDataSize(type,format,width*height*depth,arg10);
+		pixels = RSTRING(arg10)->ptr;
 	}
 	fptr_glTexImage3D( target, level, internalFormat, width, height,
 				  depth, border, format, type,pixels);
@@ -946,10 +899,6 @@ VALUE arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11;
 	GLsizei depth;
 	GLenum format;
 	GLenum type;
-	const char *pixels;
-	int size;
-	int type_size;
-	int format_size;
 	LOAD_GL_FUNC(glTexSubImage3D)
 	target = (GLenum)NUM2INT(arg1);
 	level = (GLint)NUM2INT(arg2);
@@ -961,30 +910,17 @@ VALUE arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11;
 	depth = (GLsizei)NUM2UINT(arg8);
 	format = (GLenum)NUM2INT(arg9);
 	type = (GLenum)NUM2INT(arg10);
-	Check_Type(arg11, T_STRING);
-	type_size = gltype_size(type);
-	format_size = glformat_size(format);
-	if (type_size == -1 || format_size == -1)
-		return Qnil;
-	if (type==GL_BITMAP)
-		size = format_size*((height*width*depth)/8);
-	else	
-		size = type_size*format_size*height*width*depth;
-
-	if (TYPE(arg11) == T_STRING) {
-		if (RSTRING(arg11)->len < size)
-			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg11)->len);
-		 pixels = RSTRING(arg11)->ptr;
-	} else if (TYPE(arg11) == T_FIXNUM || TYPE(arg11) == T_BIGNUM) { /* arg11 is offset to unpack buffer */
-			pixels = (const char *)NUM2UINT(arg11);
+	if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+		fptr_glTexSubImage3D( target, level, xoffset, yoffset, zoffset,
+				width, height, depth,
+				format, type, (GLvoid *)NUM2INT(arg11));
 	} else {
-		Check_Type(arg11,T_STRING); /* force exception */
-		return Qnil;
-	}
-
-	fptr_glTexSubImage3D( target, level, xoffset, yoffset, zoffset,
+		Check_Type(arg11, T_STRING);
+		CheckDataSize(type,format,height*width*depth,arg11);
+		fptr_glTexSubImage3D( target, level, xoffset, yoffset, zoffset,
 			width, height, depth,
-			format, type, pixels);
+			format, type, RSTRING(arg11)->ptr);
+	}
 	return Qnil;
 }
 
@@ -1040,15 +976,15 @@ void gl_init_functions_1_2(VALUE module)
 	rb_define_module_function(module, "glConvolutionParameteriv", gl_ConvolutionParameteriv, 3);
 	rb_define_module_function(module, "glCopyConvolutionFilter1D", gl_CopyConvolutionFilter1D, 5);
 	rb_define_module_function(module, "glCopyConvolutionFilter2D", gl_CopyConvolutionFilter2D, 6);
-	rb_define_module_function(module, "glGetConvolutionFilter", gl_GetConvolutionFilter, 3);
+	rb_define_module_function(module, "glGetConvolutionFilter", gl_GetConvolutionFilter, -1);
 	rb_define_module_function(module, "glGetConvolutionParameterfv", gl_GetConvolutionParameterfv, 2);
 	rb_define_module_function(module, "glGetConvolutionParameteriv", gl_GetConvolutionParameteriv, 2);
-	rb_define_module_function(module, "glGetSeparableFilter", gl_GetSeparableFilter, 3);
+	rb_define_module_function(module, "glGetSeparableFilter", gl_GetSeparableFilter, -1);
 	rb_define_module_function(module, "glSeparableFilter2D", gl_SeparableFilter2D, 8);
-	rb_define_module_function(module, "glGetHistogram", gl_GetHistogram, 4);
+	rb_define_module_function(module, "glGetHistogram", gl_GetHistogram, -1);
 	rb_define_module_function(module, "glGetHistogramParameterfv", gl_GetHistogramParameterfv, 2);
 	rb_define_module_function(module, "glGetHistogramParameteriv", gl_GetHistogramParameteriv, 2);
-	rb_define_module_function(module, "glGetMinmax", gl_GetMinmax, 4);
+	rb_define_module_function(module, "glGetMinmax", gl_GetMinmax, -1);
 	rb_define_module_function(module, "glGetMinmaxParameterfv", gl_GetMinmaxParameterfv, 2);
 	rb_define_module_function(module, "glGetMinmaxParameteriv", gl_GetMinmaxParameteriv, 2);
 	rb_define_module_function(module, "glHistogram", gl_Histogram, 4);