ruby-opengl 0.40.1 → 0.50.0

data/test/tc_func_14.rb

@@ -25,7 +25,7 @@ class Test_14 < Test::Unit::TestCase
 	end
 
 	def test_arrays_2
-		return if not supported?(["glSecondaryColorPointer","glFogCoordPointer"])
+		return if not supported?(1.4)
 		sc = [0,1,0, 1,0,1].pack("f*")
 		fc = [1, 0].pack("f*")
 
@@ -61,7 +61,7 @@ class Test_14 < Test::Unit::TestCase
 	end
 
 	def test_arrays_3
-		return if not supported?(["glMultiDrawArrays","glMultiDrawElements"])
+		return if not supported?(1.4)
 		va = [0,0, 1,0, 1,1, 0,0, 1,0, 0,1].pack("f*")
 		glVertexPointer(2,GL_FLOAT,0,va)
 		
@@ -70,7 +70,7 @@ class Test_14 < Test::Unit::TestCase
 		buf = glFeedbackBuffer(256,GL_3D)
 		glRenderMode(GL_FEEDBACK)
 
-		glMultiDrawArrays(GL_POLYGON, [0,3], [3,3], 2)		
+		glMultiDrawArrays(GL_POLYGON, [0,3], [3,3])
 
 		i1 = [0,1,2].pack("C*")
 		i2 = [3,4,5].pack("C*")
@@ -82,7 +82,7 @@ class Test_14 < Test::Unit::TestCase
 	end
 
 	def test_glblendfuncseparate
-		return if not supported?(["glBlendFuncSeparate"])
+		return if not supported?(1.4)
 		glBlendFuncSeparate(GL_SRC_COLOR,GL_SRC_COLOR,GL_SRC_COLOR,GL_SRC_COLOR)
 		assert_equal(glGetIntegerv(GL_BLEND_SRC_RGB),GL_SRC_COLOR)
 		assert_equal(glGetIntegerv(GL_BLEND_SRC_ALPHA),GL_SRC_COLOR)
@@ -91,7 +91,7 @@ class Test_14 < Test::Unit::TestCase
 	end
 
 	def test_glpointparameter
-		return if not supported?(["glPointParameterf","glPointParameterfv","glPointParameteri","glPointParameteriv"])
+		return if not supported?(1.4)
 		glPointParameterf(GL_POINT_SIZE_MIN,2.0)
 		assert_equal(glGetDoublev(GL_POINT_SIZE_MIN),2.0)
 
@@ -106,7 +106,7 @@ class Test_14 < Test::Unit::TestCase
 	end
 
 	def test_glfogcoord
-		return if not supported?(["glFogCoordf","glFogCoordd","glFogCoordfv","glFogCoorddv",])
+		return if not supported?(1.4)
 
 		glFogCoordf(2.0)
 		assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD),2.0)
@@ -120,7 +120,7 @@ class Test_14 < Test::Unit::TestCase
 	end
 
 	def test_glsecondarycolor
-		return if not supported?(["glSecondaryColor3b"])
+		return if not supported?(1.4)
 
 		glSecondaryColor3b(2**7-1,0,2**7-1)
 		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[1.0,0.0,1.0,1.0]))
@@ -157,7 +157,7 @@ class Test_14 < Test::Unit::TestCase
 	end
 
 	def test_glwindowpos
-		return if not supported?(["glWindowPos2d"])
+		return if not supported?(1.4)
 		# 2
 		glWindowPos2d(1.0,2.0)
 		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1,2,0,1])

data/test/tc_func_15.rb

@@ -25,7 +25,7 @@ class Test_15 < Test::Unit::TestCase
 	end
 
 	def test_query
-		return if not supported?(["glGenQueries","glDeleteQueries","glIsQuery","glBeginQuery","glGetQueryiv","glGetQueryObjectiv","glGetQueryObjectuiv"])
+		return if not supported?(1.5)
 		queries = glGenQueries(2)
 		assert_equal(queries.size,2)
 
@@ -55,7 +55,7 @@ class Test_15 < Test::Unit::TestCase
 	end
 	
 	def test_buffers
-		return if not supported?(["glGenBuffers","glDeleteBuffers","glIsBuffer","glBindBuffer","glBufferData","glBufferSubData","glGetBufferSubData","glMapBuffer","glUnmapBuffer","glGetBufferParameteriv","glGetBufferPointerv"])
+		return if not supported?(1.5)
 		buffers = glGenBuffers(2)
 		glBindBuffer(GL_ARRAY_BUFFER,buffers[0])
 		assert_equal(glIsBuffer(buffers[0]),GL_TRUE)		
@@ -79,4 +79,192 @@ class Test_15 < Test::Unit::TestCase
 
 		# FIXME: GetBufferPointerv not yet implemented
 	end
+
+	def test_buffer_binding_element_array
+		return if not supported?(1.5)
+
+		glEnableClientState(GL_VERTEX_ARRAY)
+		va = [0,0, 0,1, 1,1].pack("f*")
+		glVertexPointer(2,GL_FLOAT,0,va)
+
+		#
+		data = [0,1,2].pack("C*")
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,buffers[0])
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER,3,data,GL_DYNAMIC_DRAW)
+
+		#
+		feedback = glFeedbackBuffer(256,GL_3D)
+		glRenderMode(GL_FEEDBACK)
+
+		glDrawElements(GL_TRIANGLES,3,GL_UNSIGNED_BYTE,0)
+		glDrawRangeElements(GL_TRIANGLES,0,3,3,GL_UNSIGNED_BYTE,0)
+
+		count = glRenderMode(GL_RENDER)
+		assert_equal(count,22)
+
+		glDisableClientState(GL_VERTEX_ARRAY)
+		glDeleteBuffers(buffers)
+	end
+
+	def test_buffer_binding_array_1
+		return if not supported?(1.5)
+
+		glEnableClientState(GL_VERTEX_ARRAY)
+		va = [0,0, 0,1, 1,1].pack("f*")
+
+		#
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_ARRAY_BUFFER,buffers[0])
+		glBufferData(GL_ARRAY_BUFFER,6*4,va,GL_DYNAMIC_DRAW)
+
+		glVertexPointer(2,GL_FLOAT,0,0)
+		assert_equal(glGetPointerv(GL_VERTEX_ARRAY_POINTER),0)
+		#
+		feedback = glFeedbackBuffer(256,GL_3D)
+		glRenderMode(GL_FEEDBACK)
+
+		glDrawElements(GL_TRIANGLES,3,GL_UNSIGNED_BYTE,[0,1,2].pack("f*"))
+
+		count = glRenderMode(GL_RENDER)
+		assert_equal(count,11)
+		
+		glDeleteBuffers(buffers)
+		glDisableClientState(GL_VERTEX_ARRAY)
+	end
+
+	def test_buffer_binding_array_2
+		return if not supported?(1.5)
+
+		efa = [0].pack("C*")
+		na = [0,1,0].pack("f*")
+		ca = [1,0,1,0].pack("f*")
+		ta = [1,0,1,0].pack("f*")
+
+		buffers = glGenBuffers(4)
+		# load data into buffers
+		buffer_efa,buffer_na,buffer_ca,buffer_ta = buffers
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_efa)
+		glBufferData(GL_ARRAY_BUFFER,1,efa,GL_DYNAMIC_DRAW)
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_na)
+		glBufferData(GL_ARRAY_BUFFER,3*4,na,GL_DYNAMIC_DRAW)
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_ca)
+		glBufferData(GL_ARRAY_BUFFER,4*4,ca,GL_DYNAMIC_DRAW)
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_ta)
+		glBufferData(GL_ARRAY_BUFFER,4*4,ta,GL_DYNAMIC_DRAW)
+
+		# load buffers into arrays
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_na)
+		glEdgeFlagPointer(0,0)
+		assert_equal(glGetPointerv(GL_EDGE_FLAG_ARRAY_POINTER),0)
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_na)
+		glNormalPointer(GL_FLOAT,0,0)
+		assert_equal(glGetPointerv(GL_NORMAL_ARRAY_POINTER),0)
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_ca)
+		glColorPointer(4,GL_FLOAT,0,0)
+		assert_equal(glGetPointerv(GL_COLOR_ARRAY_POINTER),0)
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_ta)
+		glTexCoordPointer(4,GL_FLOAT,0,0)
+		assert_equal(glGetPointerv(GL_TEXTURE_COORD_ARRAY_POINTER),0)
+
+		# not really testing index
+		glIndexPointer(GL_INT,2,0)
+		assert_equal(glGetPointerv(GL_INDEX_ARRAY_POINTER),0)
+
+		# draw arrays
+		glEnable(GL_NORMAL_ARRAY)
+		glEnable(GL_COLOR_ARRAY)
+		glEnable(GL_TEXTURE_COORD_ARRAY)
+		glEnable(GL_EDGE_FLAG_ARRAY)
+
+		glBegin(GL_TRIANGLES)
+		glArrayElement(0)
+		glEnd()
+
+		assert_equal(glGetDoublev(GL_CURRENT_NORMAL),[0,1,0])
+		assert_equal(glGetDoublev(GL_CURRENT_COLOR),[1,0,1,0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS),[1,0,1,0])
+		assert_equal(glGetDoublev(GL_EDGE_FLAG),GL_FALSE)
+
+		glDisable(GL_EDGE_FLAG_ARRAY)
+		glDisable(GL_TEXTURE_COORD_ARRAY)
+		glDisable(GL_COLOR_ARRAY)
+		glDisable(GL_NORMAL_ARRAY)
+
+		glDeleteBuffers(buffers)
+	end
+
+	def test_buffer_binding_array_3
+		return if not supported?(1.5)
+
+		sc = [0,1,0].pack("f*")
+		fc = [1].pack("f*")
+
+		buffers = glGenBuffers(2)
+		# load data into buffers
+		buffer_sc,buffer_fc = buffers
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_sc)
+		glBufferData(GL_ARRAY_BUFFER,3*4,sc,GL_DYNAMIC_DRAW)
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_fc)
+		glBufferData(GL_ARRAY_BUFFER,1*4,fc,GL_DYNAMIC_DRAW)
+
+		# load buffers into arrays
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_sc)
+		glSecondaryColorPointer(3,GL_FLOAT,0,0)
+		assert_equal(glGetPointerv(GL_SECONDARY_COLOR_ARRAY_POINTER),0)
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffer_fc)
+		glFogCoordPointer(GL_FLOAT,0,0)
+		assert_equal(glGetPointerv(GL_FOG_COORD_ARRAY_POINTER),0)
+
+		# draw arrays
+		glEnableClientState(GL_SECONDARY_COLOR_ARRAY)
+		glEnableClientState(GL_FOG_COORD_ARRAY)
+
+		glBegin(GL_TRIANGLES)
+		glArrayElement(0)
+		glEnd()
+
+		assert_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[0,1,0,1])
+		assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD),1)
+
+		glDisableClientState(GL_SECONDARY_COLOR_ARRAY)
+		glDisableClientState(GL_FOG_COORD_ARRAY)
+		
+		glDeleteBuffers(buffers)
+	end
+
+	def test_buffer_binding_array_4
+		return if not supported?(1.5)
+		va = [0,0, 1,0, 1,1, 0,0, 1,0, 0,1].pack("f*")
+		glVertexPointer(2,GL_FLOAT,0,va)
+		
+		glEnable(GL_VERTEX_ARRAY)
+
+		buf = glFeedbackBuffer(256,GL_3D)
+		glRenderMode(GL_FEEDBACK)
+
+		data = [0,1,2,3,4,5]
+		buffers = glGenBuffers(3)
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,buffers[0])
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER,6,data.pack("C*"),GL_DYNAMIC_DRAW)
+
+		glMultiDrawElements(GL_TRIANGLES,GL_UNSIGNED_BYTE,[3,3],[0,3])
+
+		count = glRenderMode(GL_RENDER)
+		assert_equal(count,(3*3+2)*2)
+
+		glDisable(GL_VERTEX_ARRAY)
+		glDeleteBuffers(buffers)
+	end
+
 end

data/test/tc_func_20.rb

@@ -25,7 +25,7 @@ class Test_20 < Test::Unit::TestCase
 	end
 
 	def test_glblendequationseparate
-		return if not supported?("glBlendEquationSeparate")
+		return if not supported?(2.0)
 		glBlendEquationSeparate(GL_MIN,GL_MAX)
 		assert_equal(glGetIntegerv(GL_BLEND_EQUATION_RGB),GL_MIN)
 		assert_equal(glGetIntegerv(GL_BLEND_EQUATION_ALPHA),GL_MAX)
@@ -35,7 +35,7 @@ class Test_20 < Test::Unit::TestCase
 	end
 
 	def test_stencilops
-		return if not supported?(["glStencilOpSeparate","glStencilFuncSeparate","glStencilMaskSeparate"])
+		return if not supported?(2.0)
 
 		glStencilOpSeparate(GL_FRONT, GL_ZERO, GL_INCR, GL_DECR)
 		assert_equal(glGetIntegerv(GL_STENCIL_FAIL), GL_ZERO)
@@ -62,13 +62,14 @@ class Test_20 < Test::Unit::TestCase
 	end
 
 	def test_gldrawbuf
-		return if not supported?("glDrawBuffers")
-		glDrawBuffers([GL_NONE])
-		assert_equal(glGetIntegerv(GL_DRAW_BUFFER0),GL_NONE)
+		return if not supported?(2.0)
+		glDrawBuffers([GL_FRONT_LEFT,GL_BACK_LEFT])
+		assert_equal(glGetIntegerv(GL_DRAW_BUFFER0),GL_FRONT_LEFT)
+		assert_equal(glGetIntegerv(GL_DRAW_BUFFER1),GL_BACK_LEFT)
 	end
 
 	def test_glvertexattrib
-		return if not supported?(["glVertexAttrib1f","glGetVertexAttribdv"])
+		return if not supported?(2.0)
 		# 1
 		glVertexAttrib1d(1,2.0)
 		assert_equal(glGetVertexAttribdv(1,GL_CURRENT_VERTEX_ATTRIB), [2.0,0.0,0.0,1.0])
@@ -149,7 +150,7 @@ class Test_20 < Test::Unit::TestCase
 	end
 
 	def test_vertexattribpointer
-		return if not supported?(["glVertexAttribPointer","glGetVertexAttribPointerv","glEnableVertexAttribArray","glDisableVertexAttribArray"])
+		return if not supported?(2.0)
 		
 		vaa = [1,1,1,1, 2,2,2,2].pack("f*")
 		glVertexAttribPointer(1,4,GL_FLOAT,GL_FALSE,0,vaa)
@@ -166,7 +167,7 @@ class Test_20 < Test::Unit::TestCase
 	end
 
 	def test_shaders
-		return if not supported?(["glCreateProgram","glIsProgram","glDeleteProgram","glCreateShader","glIsShader","glDeleteShader","glShaderSource","glGetShaderSource","glGetShaderiv","glGetProgramiv","glGetShaderInfoLog","glGetProgramInfoLog","glAttachShader","glDetachShader","glGetAttachedShaders","glValidateProgram","glUseProgram","glLinkProgram"])
+		return if not supported?(2.0)
 
 		vertex_shader_source = "void main() { gl_Position = ftransform();}"
 	
@@ -214,7 +215,7 @@ class Test_20 < Test::Unit::TestCase
 	end
 
 	def test_shaders_2
-		return if not supported?(["glCreateProgram","glBindAttribLocation","glGetAttribLocation"])
+		return if not supported?(2.0)
 
 		vertex_shader_source = "attribute vec4 test; uniform float testvec1; uniform vec2 testvec2; uniform vec3 testvec3; uniform vec4 testvec4; uniform int testivec1; uniform ivec2 testivec2; uniform ivec3 testivec3; uniform ivec4 testivec4; void main() { gl_Position = testvec1 * test * testvec2.x * testvec3.x * testivec1 * testivec2.x * testivec3.x * testivec4.x + testvec4;}"
 		program = glCreateProgram()
@@ -287,7 +288,7 @@ class Test_20 < Test::Unit::TestCase
 	end
 
 	def test_shaders_3
-		return if not supported?(["glCreateProgram","glUniformMatrix2fv"])
+		return if not supported?(2.0)
 
 		vertex_shader_source = "uniform mat2 testmat2; uniform mat3 testmat3; uniform mat4 testmat4; void main() { gl_Position = gl_Vertex * testmat4[0].x * testmat3[0].x * testmat2[0].x;}"
 
@@ -317,4 +318,29 @@ class Test_20 < Test::Unit::TestCase
 		glUniformMatrix4fv(tm4l, 1, GL_TRUE, [0,1,0,1, 1,0,1,0, 0,1,0,1, 1,0,1,0])
 		assert_equal(glGetUniformfv(program,tm4l),[0,1,0,1, 1,0,1,0, 0,1,0,1, 1,0,1,0])
 	end
+
+
+	def test_buffered_vertexattribpointer
+		return if not supported?(2.0)
+
+		vaa = [1,1,1,1, 2,2,2,2].pack("f*")
+
+		buffers = glGenBuffers(1)
+
+		glBindBuffer(GL_ARRAY_BUFFER,buffers[0])
+		glBufferData(GL_ARRAY_BUFFER,8*4,vaa,GL_DYNAMIC_DRAW)
+		
+		glVertexAttribPointer(1,4,GL_FLOAT,GL_FALSE,0,0)
+		assert_equal(glGetVertexAttribPointerv(1),0)
+		
+		glEnableVertexAttribArray(1)
+		
+		glBegin(GL_POINTS)
+		glArrayElement(1)
+		glEnd()
+		assert_equal(glGetVertexAttribfv(1,GL_CURRENT_VERTEX_ATTRIB),[2,2,2,2])
+		
+		glDisableVertexAttribArray(1)
+		glDeleteBuffers(buffers)
+	end
 end

data/test/tc_func_21.rb

@@ -25,7 +25,7 @@ class Test_21 < Test::Unit::TestCase
 	end
 
 	def test_gluniformmatrix21
-		return if not supported?(["glCreateProgram","glUniformMatrix2x3fv"])
+		return if not supported?(2.1)
 
 		vertex_shader_source = "#version 120\n uniform mat2x3 testmat23; uniform mat3x2 testmat32; uniform mat2x4 testmat24; uniform mat4x2 testmat42; uniform mat3x4 testmat34; uniform mat4x3 testmat43; void main() { gl_Position = gl_Vertex * testmat23[0].x * testmat32[0].x * testmat24[0].x * testmat42[0].x * testmat34[0].x * testmat43[0].x;}"
 
@@ -64,4 +64,447 @@ class Test_21 < Test::Unit::TestCase
 		glUniformMatrix4x3fv(tm43l, 1, GL_FALSE, [1,0,0, 0,1,0, 1,0,0, 0,1,0])
 		assert_equal(glGetUniformfv(program,tm43l),[1,0,0, 0,1,0, 1,0,0, 0,1,0])
 	end
-end
+
+	def test_pixelunpack_bitmap
+		return if not supported?(2.1)
+		glOrtho(0,$window_size,0,$window_size,0,-1)
+
+		bitmap = [ 0x55 ] * 8 # 64 bits (8x8 bitmap), stipple pattern
+		glPixelStorei(GL_PACK_ALIGNMENT,1)
+		glPixelStorei(GL_UNPACK_ALIGNMENT,1)
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,8,bitmap.pack("C*"),GL_DYNAMIC_DRAW)
+
+		glBitmap(8,8,0,0,0,0,0)
+		data = glReadPixels(0,0,8,8,GL_RED,GL_UNSIGNED_BYTE)
+		assert_equal(data.unpack("C*"),[0,255] * 32)
+	
+		glDeleteBuffers(buffers)
+	end
+
+	def test_pixelunpack_color_convolution
+		return if not supported?(2.1)
+
+		ct = ([0]*3+[1]*3+[0]*3+[1]*3).pack("f*")
+		ct2 = ([1]*3+[0]*3+[1]*3+[0]*3).pack("f*")
+
+		buffers = glGenBuffers(2)
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,4*3*4,ct,GL_DYNAMIC_DRAW)
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,4*3*4,ct2,GL_DYNAMIC_DRAW)
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glColorTable(GL_COLOR_TABLE,GL_RGB8,4,GL_RGB,GL_FLOAT,0)
+		assert_equal(glGetColorTable(GL_COLOR_TABLE,GL_RGB,GL_FLOAT),ct)
+		glConvolutionFilter1D(GL_CONVOLUTION_1D, GL_RGB8, 4, GL_RGB, GL_FLOAT,0)
+		assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_1D, GL_RGB, GL_FLOAT),ct)
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glColorSubTable(GL_COLOR_TABLE,0,4,GL_RGB,GL_FLOAT,0)
+		assert_equal(glGetColorTable(GL_COLOR_TABLE,GL_RGB,GL_FLOAT),ct2)
+		glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_RGB8, 2,2, GL_RGB, GL_FLOAT,0)
+		assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_2D, GL_RGB, GL_FLOAT),ct2)
+
+		glDeleteBuffers(buffers)
+	end
+
+	def test_pixelunpack_separable
+		return if not supported?(2.1)
+
+		sf_a = ([0]*3+[1]*3).pack("f*")
+		sf_b = ([1]*3+[0]*3).pack("f*")
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,2*3*4 *2,sf_a + sf_b,GL_DYNAMIC_DRAW)
+		
+		glSeparableFilter2D(GL_SEPARABLE_2D,GL_RGB8, 2,2,GL_RGB,GL_FLOAT,0,2*3*4)
+		assert_equal(glGetSeparableFilter(GL_SEPARABLE_2D,GL_RGB,GL_FLOAT), [sf_a,sf_b])
+
+		glDeleteBuffers(buffers)
+	end
+
+	def test_pixelunpack_drawpixels
+		return if not supported?(2.1)
+
+		glClearColor(0,0,0,0)
+		glClear(GL_COLOR_BUFFER_BIT)
+
+		image = ([1.0] * 3 * 16).pack("f*")
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,3*16*4,image,GL_DYNAMIC_DRAW)
+	
+		glDrawPixels(4,4,GL_RGB,GL_FLOAT,0)
+
+		data = glReadPixels(0,0,4,4,GL_RGB,GL_FLOAT)
+		assert_equal(data,image)
+
+		glDeleteBuffers(buffers)
+	end
+
+	def test_pixelunpack_polygonstipple
+		return if not supported?(2.1)
+
+		stipple = ([0x12] * 128).pack("c*")
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,128,stipple,GL_DYNAMIC_DRAW)
+
+		glPolygonStipple(0)
+		assert_equal(glGetPolygonStipple(),stipple)
+		glDeleteBuffers(buffers)
+	end
+
+
+	def test_pixelunpack_texturecompression
+		return if not supported?(2.1)
+		return if not supported?("GL_EXT_texture_compression_s3tc")
+
+		# S3TC/DXT5 compressed 2x2 pixels stipple patterns [w,b,b,w] and [b,w,w,b]
+		image_1 = [0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x00,0x00,0x01,0x54,0x5C,0x5C].pack("C*")
+		image_2 = [0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x00,0x00,0x54,0x01,0x0D,0x0D].pack("C*")
+
+		textures = glGenTextures(3)
+		glBindTexture(GL_TEXTURE_1D,textures[0])
+		glBindTexture(GL_TEXTURE_2D,textures[1])
+		glBindTexture(GL_TEXTURE_3D,textures[2])
+
+		buffers = glGenBuffers(2)
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,16,image_1,GL_DYNAMIC_DRAW)
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,16,image_2,GL_DYNAMIC_DRAW)
+
+		# Note: 1D and 3D compressed textures are not supported by S3TC/DXTn, and usually not supported at all
+
+		# 1D
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glCompressedTexImage1D(GL_TEXTURE_1D,0,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,4,0,16,0)
+		err = glGetError()
+		assert(err == 0 || err == GL_INVALID_ENUM || err == GL_INVALID_OPERATION)
+		if (err == 0)
+			assert_equal(glGetCompressedTexImage(GL_TEXTURE_1D,0), image_1)
+		end
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glCompressedTexSubImage1D(GL_TEXTURE_1D,0,0,4,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,16,0)
+		err = glGetError()
+		assert(err == 0 || err == GL_INVALID_ENUM || err == GL_INVALID_OPERATION)
+		if (err == 0)
+			assert_equal(glGetCompressedTexImage(GL_TEXTURE_1D,0), image_2)
+		end
+		
+		# 2D
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glCompressedTexImage2D(GL_TEXTURE_2D,0,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,2,2,0,16,0)
+		assert_equal(glGetCompressedTexImage(GL_TEXTURE_2D,0), image_1)
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glCompressedTexSubImage2D(GL_TEXTURE_2D,0,0,0,2,2,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,16,0)
+		assert_equal(glGetCompressedTexImage(GL_TEXTURE_2D,0), image_2)
+		
+		# 3D
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glCompressedTexImage3D(GL_TEXTURE_3D,0,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,2,2,1,0,16,0)
+		err = glGetError()
+		assert(err == 0 || err == GL_INVALID_ENUM || err == GL_INVALID_OPERATION)
+		if (err == 0)
+			assert_equal(glGetCompressedTexImage(GL_TEXTURE_3D,0), image_1)
+		end
+		
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glCompressedTexSubImage3D(GL_TEXTURE_3D,0, 0,0,0, 2,2,1, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 16, 0)
+		err = glGetError()
+		assert(err == 0 || err == GL_INVALID_ENUM || err == GL_INVALID_OPERATION)
+		if (err == 0)
+			assert_equal(glGetCompressedTexImage(GL_TEXTURE_3D,0), image_2)
+		end
+
+		glDeleteBuffers(buffers)
+		glDeleteTextures(textures)
+	end
+
+	def test_pixelunpack_texture
+		return if not supported?(2.1)
+
+		textures = glGenTextures(3)
+		image_1 = ([0,0,0,1,1,1] * 8).pack("f*") # 16 RGB pixels
+		image_2 = ([1,1,1,0,0,0] * 8).pack("f*") # 16 RGB pixels
+
+		buffers = glGenBuffers(2)
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,6*8*4,image_1,GL_DYNAMIC_DRAW)
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,6*8*4,image_2,GL_DYNAMIC_DRAW)
+
+		# 3D
+		glBindTexture(GL_TEXTURE_3D,textures[0])
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glTexImage3D(GL_TEXTURE_3D,0,GL_RGB8,2,2,4,0,GL_RGB,GL_FLOAT,0)
+		assert_equal(glGetTexImage(GL_TEXTURE_3D,0,GL_RGB,GL_FLOAT),image_1)
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glTexSubImage3D(GL_TEXTURE_3D,0, 0,0,0, 2,2,4,GL_RGB,GL_FLOAT,0)
+		assert_equal(glGetTexImage(GL_TEXTURE_3D,0,GL_RGB,GL_FLOAT),image_2)
+
+		# 2D
+		glBindTexture(GL_TEXTURE_2D,textures[1])
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glTexImage2D(GL_TEXTURE_2D,0,GL_RGB8, 4, 4, 0, GL_RGB, GL_FLOAT, 0)
+		assert_equal(glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT), image_1)
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glTexSubImage2D(GL_TEXTURE_2D,0, 0,0, 4,4,GL_RGB,GL_FLOAT,0)
+		assert_equal(glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT),image_2)
+	
+		# 1D
+		glBindTexture(GL_TEXTURE_1D,textures[2])
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+
+		glTexImage1D(GL_TEXTURE_1D,0,GL_RGB8, 16, 0, GL_RGB, GL_FLOAT, 0)
+		assert_equal(glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT), image_1)
+
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[1])
+		glTexSubImage1D(GL_TEXTURE_1D,0, 0, 16,GL_RGB,GL_FLOAT,0)
+		assert_equal(glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT),image_2)
+
+		glDeleteBuffers(buffers)
+		glDeleteTextures(textures)
+	end
+
+	def test_pixelunpack_pixelmap
+		return if not supported?(2.1)
+		data_1 = [1,2,3,4].pack("f*")
+		data_2 = [5,6,7,8].pack("I*")
+		data_3 = [9,10,11,12].pack("S*")
+
+		buffers = glGenBuffers(3)
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_UNPACK_BUFFER,4*4+4*4+4*2,data_1+data_2+data_3,GL_DYNAMIC_DRAW)
+
+		glPixelMapfv(GL_PIXEL_MAP_I_TO_I,4,0)
+		assert_equal(glGetPixelMapfv(GL_PIXEL_MAP_I_TO_I), [1,2,3,4])
+
+		glPixelMapuiv(GL_PIXEL_MAP_I_TO_I,4,4*4)
+		assert_equal(glGetPixelMapuiv(GL_PIXEL_MAP_I_TO_I),[5,6,7,8])
+		
+		glPixelMapusv(GL_PIXEL_MAP_I_TO_I,4,4*4+4*4)
+		assert_equal(glGetPixelMapusv(GL_PIXEL_MAP_I_TO_I),[9,10,11,12])
+
+		glDeleteBuffers(buffers)
+	end
+
+	def test_pixelpack_readpixels
+		return if not supported?(2.1)
+		glClearColor(0,0,0,0)
+		glClear(GL_COLOR_BUFFER_BIT)
+
+		image = ([1.0] * 3 * 16).pack("f*")
+		glDrawPixels(4,4,GL_RGB,GL_FLOAT,image)
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_PACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,4*4*4*3, nil, GL_STREAM_READ)
+		glReadPixels(0,0,4,4,GL_RGB,GL_FLOAT,0)
+
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal(data,image)
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		glDeleteBuffers(buffers)
+	end
+
+	def test_pixelpack_pixelmap
+		return if not supported?(2.1)
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_PACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,4*4, nil, GL_STREAM_READ)
+
+		# fv	
+		glPixelMapfv(GL_PIXEL_MAP_I_TO_I,[1,2,3,4])
+		glGetPixelMapfv(GL_PIXEL_MAP_I_TO_I,0)
+
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal([1,2,3,4].pack("f*"),data)
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		# uiv
+		glPixelMapuiv(GL_PIXEL_MAP_I_TO_I,[5,6,7,8])
+		glGetPixelMapuiv(GL_PIXEL_MAP_I_TO_I,0)
+
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal([5,6,7,8].pack("I*"),data)
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		# usv	
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,4*2, nil, GL_STREAM_READ)
+
+		glPixelMapusv(GL_PIXEL_MAP_I_TO_I,[9,10,11,12])
+		glGetPixelMapusv(GL_PIXEL_MAP_I_TO_I,0)
+
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal([9,10,11,12].pack("S*"),data)
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		glDeleteBuffers(buffers)
+	end
+
+	def test_pixelpack_polygonstipple
+		return if not supported?(2.1)
+
+		stipple = [0x12] * 128
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_PACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,128, nil, GL_STREAM_READ)
+
+		glPolygonStipple(stipple.pack("c*"))
+		glGetPolygonStipple(0)
+
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal(stipple.pack("c*"),data)
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+	
+		glDeleteBuffers(buffers)
+	end
+	
+	def test_pixelpack_separablefilter
+		return if not supported?(2.1)
+		sf_a = ([0]*3+[1]*3).pack("f*")
+		sf_b = ([1]*3+[0]*3).pack("f*")
+	
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_PACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,6*4 + 6*4, nil, GL_STREAM_READ)
+	
+		glSeparableFilter2D(GL_SEPARABLE_2D,GL_RGB8, 2,2,GL_RGB,GL_FLOAT,sf_a,sf_b)
+		glGetSeparableFilter(GL_SEPARABLE_2D,GL_RGB,GL_FLOAT,0,6*4,0)
+
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal(data,sf_a + sf_b)
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		glDeleteBuffers(buffers)
+	end
+
+	def test_pixelpack_convolutionfilter
+		return if not supported?(2.1)
+
+		cf = ([0]*3+[1]*3+[0]*3+[1]*3).pack("f*")
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_PACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,3*4*4, nil, GL_STREAM_READ)
+
+		glConvolutionFilter1D(GL_CONVOLUTION_1D, GL_RGB8, 4, GL_RGB, GL_FLOAT,cf)
+
+		glGetConvolutionFilter(GL_CONVOLUTION_1D, GL_RGB, GL_FLOAT,0)
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal(data,cf)
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		glDeleteBuffers(buffers)
+	end
+
+	def test_pixelpack_histogram
+		return if not supported?(2.1)
+
+		glEnable(GL_HISTOGRAM)
+
+		glHistogram(GL_HISTOGRAM,1,GL_RGB8,GL_FALSE)
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_PACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,3*4, nil, GL_STREAM_READ)
+
+		glDrawPixels(2,1,GL_RGB,GL_FLOAT,[1,1,1,1,1,1].pack("f*"))
+		glGetHistogram(GL_HISTOGRAM,GL_FALSE,GL_RGB,GL_FLOAT,0)
+
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal(data.unpack("f*"),[2,2,2])
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		glDeleteBuffers(buffers)
+		glDisable(GL_HISTOGRAM)
+	end
+
+	def test_pixelpack_minmax
+		return if not supported?(2.1)
+
+		glEnable(GL_MINMAX)		
+
+		glMinmax(GL_MINMAX,GL_RGB8,GL_FALSE)
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_PACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,6*4, nil, GL_STREAM_READ)
+
+		glDrawPixels(2,1,GL_RGB,GL_FLOAT,[0,0,0,1,1,1].pack("f*"))
+		glGetMinmax(GL_MINMAX,GL_FALSE,GL_RGB,GL_FLOAT,0)
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal(data.unpack("f*"),[0,0,0,1,1,1])
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		glDeleteBuffers(buffers)
+		glDisable(GL_MINMAX)
+	end
+
+	def test_pixelpack_teximage
+		return if not supported?(2.1)
+
+		textures = glGenTextures(1)
+		glBindTexture(GL_TEXTURE_2D,textures[0])
+
+		image = ([0,0,0,1,1,1] * 8).pack("f*") # 16 RGB pixels
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_PACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,16*3*4, nil, GL_STREAM_READ)
+
+		glTexImage2D(GL_TEXTURE_2D,0,GL_RGB8, 4, 4, 0, GL_RGB, GL_FLOAT, image)
+		glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT,0)
+
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal(data,image)
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		glDeleteBuffers(buffers)
+		glDeleteTextures(textures)
+	end
+
+	def test_pixelpack_compressedteximage
+		return if not supported?(2.1)
+		return if not supported?("GL_EXT_texture_compression_s3tc")
+
+		# S3TC/DXT5 compressed 2x2 pixels stipple pattern [w,b,b,w]
+		image = [0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x00,0x00,0x01,0x54,0x5C,0x5C].pack("C*")
+
+		textures = glGenTextures(1)
+		glBindTexture(GL_TEXTURE_2D,textures[0])
+
+		buffers = glGenBuffers(1)
+		glBindBuffer(GL_PIXEL_PACK_BUFFER,buffers[0])
+		glBufferData(GL_PIXEL_PACK_BUFFER_ARB,image.size, nil, GL_STREAM_READ)
+
+		glCompressedTexImage2D(GL_TEXTURE_2D,0,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,2,2,0,16,image)
+    glGetCompressedTexImage(GL_TEXTURE_2D,0,0)
+
+		data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
+		assert_equal(data,image)
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
+
+		glDeleteBuffers(buffers)
+		glDeleteTextures(textures)
+	end
+end