opengl 0.7.0.pre1-x86-mingw32

data/test/tc_func_12.rb

@@ -0,0 +1,186 @@
+#
+# 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.
+#
+
+require 'test/unit'
+
+class Test_12 < Test::Unit::TestCase
+	def setup
+		common_setup()
+	end
+
+	def teardown
+		common_teardown()
+	end
+	
+	def test_glblend
+		return if not supported?(1.2)
+		glBlendColor(0.0,1.0,0.0,1.0)
+		assert_equal(glGetDoublev(GL_BLEND_COLOR),[0,1,0,1])
+
+		glBlendEquation(GL_MIN)
+		assert_equal(glGetIntegerv(GL_BLEND_EQUATION),GL_MIN)
+		glBlendEquation(GL_MAX)
+		assert_equal(glGetIntegerv(GL_BLEND_EQUATION),GL_MAX)
+	end
+	
+	def test_gldrawrangeelements
+		return if not supported?(1.2)
+		va = [0,0, 0,1, 1,1].pack("f*")
+		glVertexPointer(2,GL_FLOAT,0,va)
+
+		buf = glFeedbackBuffer(256,GL_3D)
+		glRenderMode(GL_FEEDBACK)
+
+		glEnable(GL_VERTEX_ARRAY)
+
+		glDrawRangeElements(GL_POINTS,0,2,3,GL_UNSIGNED_BYTE,[0,1,2].pack("C*"))
+		count = glRenderMode(GL_RENDER)
+		assert_equal(count,12)
+
+		glDisable(GL_VERTEX_ARRAY)
+	end
+	
+	def test_colortable
+		return if not supported?(1.2)
+
+		ct = ([0]*3+[1]*3+[0]*3+[1]*3).pack("f*")
+		ct2 = ([1]*3+[0]*3+[1]*3+[0]*3).pack("f*")
+		glColorTable(GL_COLOR_TABLE,GL_RGB8,4,GL_RGB,GL_FLOAT,ct)
+		assert_equal(glGetColorTable(GL_COLOR_TABLE,GL_RGB,GL_FLOAT),ct)
+
+		glColorSubTable(GL_COLOR_TABLE,0,4,GL_RGB,GL_FLOAT,ct2)
+		assert_equal(glGetColorTable(GL_COLOR_TABLE,GL_RGB,GL_FLOAT),ct2)
+
+		glDrawPixels(4,1,GL_RGB,GL_FLOAT,ct)
+		glCopyColorTable(GL_COLOR_TABLE,GL_RGB8,0,0,4)
+		assert_equal(glGetColorTable(GL_COLOR_TABLE,GL_RGB,GL_FLOAT),ct)
+
+		glDrawPixels(4,1,GL_RGB,GL_FLOAT,ct2)
+		glCopyColorSubTable(GL_COLOR_TABLE,0,0,0,4)
+		assert_equal(glGetColorTable(GL_COLOR_TABLE,GL_RGB,GL_FLOAT),ct2)
+
+		glColorTableParameterfv(GL_COLOR_TABLE,GL_COLOR_TABLE_BIAS,[0,1,0,1])
+		assert_equal(glGetColorTableParameterfv(GL_COLOR_TABLE,GL_COLOR_TABLE_BIAS),[0,1,0,1])
+
+		glColorTableParameteriv(GL_COLOR_TABLE,GL_COLOR_TABLE_BIAS,[1,0,1,0])
+		assert_equal(glGetColorTableParameteriv(GL_COLOR_TABLE,GL_COLOR_TABLE_BIAS),[1,0,1,0])
+	end
+
+	def test_convolutionfilter
+		return if not supported?(1.2)
+
+		cf = ([0]*3+[1]*3+[0]*3+[1]*3).pack("f*")
+		cf2 = ([1]*3+[0]*3+[1]*3+[0]*3).pack("f*")
+		glConvolutionFilter1D(GL_CONVOLUTION_1D, GL_RGB8, 4, GL_RGB, GL_FLOAT,cf)
+		assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_1D, GL_RGB, GL_FLOAT),cf)
+
+		glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_RGB8, 2,2, GL_RGB, GL_FLOAT,cf2)
+		assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_2D, GL_RGB, GL_FLOAT),cf2)
+
+		glDrawPixels(4,1,GL_RGB,GL_FLOAT,cf2)
+		glCopyConvolutionFilter1D(GL_CONVOLUTION_1D,GL_RGB8,0,0,4)
+		assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_1D, GL_RGB, GL_FLOAT),cf2)
+
+		glDrawPixels(2,2,GL_RGB,GL_FLOAT,cf)
+		glCopyConvolutionFilter2D(GL_CONVOLUTION_2D,GL_RGB8,0,0,2,2)
+		assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_2D, GL_RGB, GL_FLOAT),cf)
+
+		glConvolutionParameterf(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,GL_CONSTANT_BORDER)
+		assert_equal(glGetConvolutionParameterfv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_CONSTANT_BORDER)
+
+		glConvolutionParameterf(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,GL_REPLICATE_BORDER)
+		assert_equal(glGetConvolutionParameterfv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_REPLICATE_BORDER)
+
+		glConvolutionParameterfv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,[GL_CONSTANT_BORDER])
+		assert_equal(glGetConvolutionParameterfv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_CONSTANT_BORDER)
+
+		glConvolutionParameteri(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,GL_REPLICATE_BORDER)
+		assert_equal(glGetConvolutionParameteriv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_REPLICATE_BORDER)
+
+		glConvolutionParameteriv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,[GL_CONSTANT_BORDER])
+		assert_equal(glGetConvolutionParameteriv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_CONSTANT_BORDER)
+	end
+
+	def test_separablefilter
+		return if not supported?(1.2)
+		sf_a = ([0]*3+[1]*3).pack("f*")
+		sf_b = ([1]*3+[0]*3).pack("f*")
+		
+		glSeparableFilter2D(GL_SEPARABLE_2D,GL_RGB8, 2,2,GL_RGB,GL_FLOAT,sf_a,sf_b)
+		assert_equal(glGetSeparableFilter(GL_SEPARABLE_2D,GL_RGB,GL_FLOAT), [sf_a,sf_b])
+	end
+
+	def test_histogram
+		return if not supported?(1.2)
+
+		glEnable(GL_HISTOGRAM)
+
+		glHistogram(GL_HISTOGRAM,1,GL_RGB,GL_FALSE)
+		assert_equal(glGetHistogramParameterfv(GL_HISTOGRAM,GL_HISTOGRAM_WIDTH),1)
+		assert_equal(glGetHistogramParameteriv(GL_HISTOGRAM,GL_HISTOGRAM_FORMAT),GL_RGB)
+		assert_equal(glGetHistogramParameteriv(GL_HISTOGRAM,GL_HISTOGRAM_SINK),GL_FALSE)
+
+		glDrawPixels(2,1,GL_RGB,GL_FLOAT,[1,1,1,1,1,1].pack("f*"))
+		h = glGetHistogram(GL_HISTOGRAM,GL_FALSE,GL_RGB,GL_FLOAT)
+		assert_equal(h.unpack("f*"),[2,2,2])
+		glResetHistogram(GL_HISTOGRAM)
+		h = glGetHistogram(GL_HISTOGRAM,GL_FALSE,GL_RGB,GL_FLOAT)
+		assert_equal(h.unpack("f*"),[0,0,0])
+
+		glDisable(GL_HISTOGRAM)
+	end
+
+	def test_minmax
+		return if not supported?(1.2)
+
+		glEnable(GL_MINMAX)		
+
+		glMinmax(GL_MINMAX,GL_RGB,GL_FALSE)
+		assert_equal(glGetMinmaxParameteriv(GL_MINMAX,GL_MINMAX_FORMAT),GL_RGB)
+		assert_equal(glGetMinmaxParameterfv(GL_MINMAX,GL_MINMAX_FORMAT),GL_RGB)
+		assert_equal(glGetMinmaxParameteriv(GL_MINMAX,GL_MINMAX_SINK),GL_FALSE)
+
+		glDrawPixels(2,1,GL_RGB,GL_FLOAT,[0,0,0,1,1,1].pack("f*"))
+		mm = glGetMinmax(GL_MINMAX,GL_FALSE,GL_RGB,GL_FLOAT)
+		assert_equal(mm.unpack("f*"),[0,0,0,1,1,1])
+		glResetMinmax(GL_MINMAX)
+		mm = glGetMinmax(GL_MINMAX,GL_FALSE,GL_RGB,GL_UNSIGNED_BYTE)
+		assert(approx_equal(mm.unpack("f*"),[0,0,0,0,0,0]))
+
+		glDisable(GL_MINMAX)
+	end
+
+	def test_texture_3D
+		return if not supported?(1.2)
+		image = ([0,0,0,1,1,1] * 2 * 2).pack("f*")
+		image2 = ([1,1,1,0,0,0] * 2 * 2).pack("f*")
+
+		textures = glGenTextures(1)
+		glBindTexture(GL_TEXTURE_3D,textures[0])
+
+		glTexImage3D(GL_TEXTURE_3D,0,GL_RGB8,2,2,2,0,GL_RGB,GL_FLOAT,image)
+		assert_equal(glGetTexImage(GL_TEXTURE_3D,0,GL_RGB,GL_FLOAT),image)
+
+		glTexSubImage3D(GL_TEXTURE_3D,0, 0,0,0, 2,2,2,GL_RGB,GL_FLOAT,image2)
+		assert_equal(glGetTexImage(GL_TEXTURE_3D,0,GL_RGB,GL_FLOAT),image2)
+
+		glDrawPixels(2,2,GL_RGB,GL_FLOAT,image)
+		glCopyTexSubImage3D(GL_TEXTURE_3D,0,0,0,0,0,0,2,2)
+		ti = glGetTexImage(GL_TEXTURE_3D,0,GL_RGB,GL_FLOAT).unpack("f*")
+		assert_equal(ti,([0]*3 + [1]*3) * 2 + ([1]*3 + [0]*3) * 2)
+
+		glDeleteTextures(textures)
+	end
+end

data/test/tc_func_13.rb

@@ -0,0 +1,229 @@
+#
+# 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.
+#
+
+require 'test/unit'
+
+class Test_13 < Test::Unit::TestCase
+	def setup
+		common_setup()
+	end
+
+	def teardown
+		common_teardown()
+	end
+
+	def test_glsamplecoverage
+		return if not supported?(1.3)
+		glSampleCoverage(0.0,GL_TRUE)
+		assert_equal(glGetDoublev(GL_SAMPLE_COVERAGE_VALUE),0.0)
+		assert_equal(glGetBooleanv(GL_SAMPLE_COVERAGE_INVERT),GL_TRUE)
+		glSampleCoverage(1.0,GL_FALSE)
+		assert_equal(glGetDoublev(GL_SAMPLE_COVERAGE_VALUE),1.0)
+		assert_equal(glGetBooleanv(GL_SAMPLE_COVERAGE_INVERT),GL_FALSE)
+	end
+
+	def test_multitexture
+		return if not supported?(1.3)
+		glActiveTexture(GL_TEXTURE1)
+		glClientActiveTexture(GL_TEXTURE2)
+		assert_equal(glGetIntegerv(GL_ACTIVE_TEXTURE),GL_TEXTURE1)
+		assert_equal(glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE),GL_TEXTURE2)
+	end
+
+	def test_transposematrix
+		return if not supported?(1.3)
+		m_a = [[1.0,2.0,3.0,4.0],
+					 [0.0,2.0,0.0,0.0],
+					 [0.0,0.0,2.0,0.0],
+					 [0.0,0.0,0.0,2.0]]
+
+		m_b = [[1.0,2.0,3.0,4.0],
+					 [0.0,3.0,0.0,0.0],
+					 [0.0,0.0,3.0,0.0],
+					 [0.0,0.0,0.0,3.0]]
+
+		glMatrixMode(GL_MODELVIEW)
+		glLoadTransposeMatrixf(m_a)
+		assert_equal(glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX), m_a)
+
+		glLoadTransposeMatrixd(m_b)
+		assert_equal(glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX), m_b)
+
+		glLoadIdentity()
+		glMultTransposeMatrixf(m_a)
+		assert_equal(glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX), m_a)
+
+		glLoadIdentity()
+		glMultTransposeMatrixd(m_b)
+		assert_equal(glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX), m_b)
+
+		# 2
+		m = Matrix.rows([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
+		glMatrixMode(GL_MODELVIEW)
+		glLoadTransposeMatrixf(m)
+		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a.transpose)
+		glLoadIdentity()
+		glLoadTransposeMatrixd(m)
+		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a.transpose)
+		glLoadIdentity()
+		glMultTransposeMatrixf(m)
+		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a.transpose)
+		glLoadIdentity()
+		glMultTransposeMatrixd(m)
+		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a.transpose)
+
+		assert_raise ArgumentError do glLoadTransposeMatrixf([1,2,3,4]) end
+		assert_raise ArgumentError do glLoadTransposeMatrixd([1,2,3,4]) end
+		assert_raise ArgumentError do glMultTransposeMatrixf([1,2,3,4]) end
+		assert_raise ArgumentError do glMultTransposeMatrixd([1,2,3,4]) end
+	end
+	
+	def test_texturecompression
+		return if not supported?(1.3)
+		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])
+
+		# Note: 1D and 3D compressed textures are not supported by S3TC/DXTn, and usually not supported at all
+
+		# 1D
+		begin 
+			glCompressedTexImage1D(GL_TEXTURE_1D,0,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,4,0,16,image_1)
+			assert_equal(glGetCompressedTexImage(GL_TEXTURE_1D,0), image_1)
+		rescue Gl::Error => err
+			assert(err.id == GL_INVALID_ENUM || err.id == GL_INVALID_OPERATION)
+		end
+
+		begin 
+			glCompressedTexSubImage1D(GL_TEXTURE_1D,0,0,4,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,16,image_2)
+			assert_equal(glGetCompressedTexImage(GL_TEXTURE_1D,0), image_2)
+		rescue Gl::Error => err
+			assert(err.id == GL_INVALID_ENUM || err.id == GL_INVALID_OPERATION)
+		end
+
+		# 2D
+		glCompressedTexImage2D(GL_TEXTURE_2D,0,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,2,2,0,16,image_1)
+		assert_equal(glGetCompressedTexImage(GL_TEXTURE_2D,0), image_1)
+
+		glCompressedTexSubImage2D(GL_TEXTURE_2D,0,0,0,2,2,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,16,image_2)
+		assert_equal(glGetCompressedTexImage(GL_TEXTURE_2D,0), image_2)
+
+		# 3D
+		begin 
+			glCompressedTexImage3D(GL_TEXTURE_3D,0,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,2,2,1,0,16,image_1)
+			assert_equal(glGetCompressedTexImage(GL_TEXTURE_3D,0), image_1)
+		rescue Gl::Error => err
+			assert(err.id == GL_INVALID_ENUM || err.id == GL_INVALID_OPERATION)
+		end
+
+		begin 
+			glCompressedTexSubImage3D(GL_TEXTURE_3D,0, 0,0,0, 2,2,1, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 16, image_2)
+			assert_equal(glGetCompressedTexImage(GL_TEXTURE_3D,0), image_2)
+		rescue Gl::Error => err
+			assert(err.id == GL_INVALID_ENUM || err.id == GL_INVALID_OPERATION)
+		end
+		
+		glDeleteTextures(textures)
+
+		n = glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
+		if (n>0)
+			assert_equal(glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS).size,n)
+		end
+	end
+	
+	def test_glmultitexcoord
+		return if not supported?(1.3)
+	
+		glActiveTexture(GL_TEXTURE1)
+
+		# 1
+		glMultiTexCoord1d(GL_TEXTURE1, 1.0)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,0,0,1])
+		glMultiTexCoord1dv(GL_TEXTURE1, [0.0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		glMultiTexCoord1f(GL_TEXTURE1, 1.0)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,0,0,1])
+		glMultiTexCoord1fv(GL_TEXTURE1, [0.0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		glMultiTexCoord1i(GL_TEXTURE1, 1)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,0,0,1])
+		glMultiTexCoord1iv(GL_TEXTURE1, [0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		glMultiTexCoord1s(GL_TEXTURE1, 1)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,0,0,1])
+		glMultiTexCoord1sv(GL_TEXTURE1, [0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		# 2
+		glMultiTexCoord2d(GL_TEXTURE1, 1.0,1.0)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,0,1])
+		glMultiTexCoord2dv(GL_TEXTURE1, [0.0,0.0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		glMultiTexCoord2f(GL_TEXTURE1, 1.0,1.0)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,0,1])
+		glMultiTexCoord2fv(GL_TEXTURE1, [0.0,0.0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		glMultiTexCoord2i(GL_TEXTURE1, 1,1)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,0,1])
+		glMultiTexCoord2iv(GL_TEXTURE1, [0,0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		glMultiTexCoord2s(GL_TEXTURE1, 1,1)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,0,1])
+		glMultiTexCoord2sv(GL_TEXTURE1, [0,0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		# 3
+		glMultiTexCoord3d(GL_TEXTURE1, 1.0,1.0,1.0)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,1,1])
+		glMultiTexCoord3dv(GL_TEXTURE1, [0.0,0.0,0.0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		glMultiTexCoord3f(GL_TEXTURE1, 1.0,1.0,1.0)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,1,1])
+		glMultiTexCoord3fv(GL_TEXTURE1, [0.0,0.0,0.0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		glMultiTexCoord3i(GL_TEXTURE1, 1,1,1)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,1,1])
+		glMultiTexCoord3iv(GL_TEXTURE1, [0,0,0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		glMultiTexCoord3s(GL_TEXTURE1, 1,1,1)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,1,1])
+		glMultiTexCoord3sv(GL_TEXTURE1, [0,0,0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,1])
+		# 4
+		glMultiTexCoord4d(GL_TEXTURE1, 1.0,1.0,1.0,1.0)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,1,1])
+		glMultiTexCoord4dv(GL_TEXTURE1, [0.0,0.0,0.0,0.0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,0])
+		glMultiTexCoord4f(GL_TEXTURE1, 1.0,1.0,1.0,1.0)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,1,1])
+		glMultiTexCoord4fv(GL_TEXTURE1, [0.0,0.0,0.0,0.0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,0])
+		glMultiTexCoord4i(GL_TEXTURE1, 1,1,1,1)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,1,1])
+		glMultiTexCoord4iv(GL_TEXTURE1, [0,0,0,0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,0])
+		glMultiTexCoord4s(GL_TEXTURE1, 1,1,1,1)
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [1,1,1,1])
+		glMultiTexCoord4sv(GL_TEXTURE1, [0,0,0,0])
+		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS), [0,0,0,0])
+
+		glActiveTexture(GL_TEXTURE0)
+	end
+end

data/test/tc_func_14.rb

@@ -0,0 +1,197 @@
+#
+# 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.
+#
+
+require 'test/unit'
+
+class Test_14 < Test::Unit::TestCase
+	def setup
+		common_setup()
+	end
+
+	def teardown
+		common_teardown()
+	end
+
+	def test_arrays_2
+		return if not supported?(1.4)
+		sc = [0,1,0, 1,0,1].pack("f*")
+		fc = [1, 0].pack("f*")
+
+		glSecondaryColorPointer(3,GL_FLOAT,0,sc)
+		assert_equal(glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_SIZE),3)
+		assert_equal(glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_TYPE),GL_FLOAT)
+		assert_equal(glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_STRIDE),0)
+		assert_equal(glGetPointerv(GL_SECONDARY_COLOR_ARRAY_POINTER),sc)
+		glFogCoordPointer(GL_FLOAT,0,fc)
+		assert_equal(glGetIntegerv(GL_FOG_COORD_ARRAY_TYPE),GL_FLOAT)
+		assert_equal(glGetIntegerv(GL_FOG_COORD_ARRAY_STRIDE),0)
+		assert_equal(glGetPointerv(GL_FOG_COORD_ARRAY_POINTER),fc)
+
+		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)
+
+		glBegin(GL_TRIANGLES)
+		glArrayElement(1)
+		glEnd()
+
+		assert_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[1,0,1,1])
+		assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD),0)
+
+		glDisableClientState(GL_SECONDARY_COLOR_ARRAY)
+		glDisableClientState(GL_FOG_COORD_ARRAY)
+	end
+
+	def test_arrays_3
+		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)
+		
+		glEnable(GL_VERTEX_ARRAY)
+
+		buf = glFeedbackBuffer(256,GL_3D)
+		glRenderMode(GL_FEEDBACK)
+
+		glMultiDrawArrays(GL_POLYGON, [0,3], [3,3])
+
+		i1 = [0,1,2].pack("C*")
+		i2 = [3,4,5].pack("C*")
+		glMultiDrawElements(GL_TRIANGLES,GL_UNSIGNED_BYTE,[i1,i2])
+
+		count = glRenderMode(GL_RENDER)
+		assert_equal(count,(3*3+2)*4)
+		glDisable(GL_VERTEX_ARRAY)
+	end
+
+	def test_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)
+		assert_equal(glGetIntegerv(GL_BLEND_DST_RGB),GL_SRC_COLOR)
+		assert_equal(glGetIntegerv(GL_BLEND_DST_ALPHA),GL_SRC_COLOR)
+	end
+
+	def test_glpointparameter
+		return if not supported?(1.4)
+		glPointParameterf(GL_POINT_SIZE_MIN,2.0)
+		assert_equal(glGetDoublev(GL_POINT_SIZE_MIN),2.0)
+
+		glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION,[0,1,0])
+		assert_equal(glGetDoublev(GL_POINT_DISTANCE_ATTENUATION),[0,1,0])
+
+		glPointParameteri(GL_POINT_SIZE_MAX,4)
+		assert_equal(glGetDoublev(GL_POINT_SIZE_MAX),4)
+
+		glPointParameteriv(GL_POINT_DISTANCE_ATTENUATION,[1,0,1])
+		assert_equal(glGetDoublev(GL_POINT_DISTANCE_ATTENUATION),[1,0,1])
+	end
+
+	def test_glfogcoord
+		return if not supported?(1.4)
+
+		glFogCoordf(2.0)
+		assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD),2.0)
+		glFogCoordfv([3.0])
+		assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD),3.0)
+
+		glFogCoordd(2.0)
+		assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD),2.0)
+		glFogCoorddv([3.0])
+		assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD),3.0)
+	end
+
+	def test_glsecondarycolor
+		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]))
+		glSecondaryColor3bv([0,2**7-1,0])
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[0.0,1.0,0.0,1.0]))
+		glSecondaryColor3d(1.0,0.0,1.0)
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[1.0,0.0,1.0,1.0]))
+		glSecondaryColor3dv([0.0,1.0,0.0])
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[0.0,1.0,0.0,1.0]))
+		glSecondaryColor3f(1.0,0.0,1.0)
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[1.0,0.0,1.0,1.0]))
+		glSecondaryColor3fv([0.0,1.0,0.0])
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[0.0,1.0,0.0,1.0]))
+		glSecondaryColor3i(2**31-1,0,2**31-1)
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[1.0,0.0,1.0,1.0]))
+		glSecondaryColor3iv([0,2**31-1,0])
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[0.0,1.0,0.0,1.0]))
+		glSecondaryColor3s(2**15-1,0,2**15-1)
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[1.0,0.0,1.0,1.0]))
+		glSecondaryColor3sv([0,2**15-1,0])
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[0.0,1.0,0.0,1.0]))
+		glSecondaryColor3ub(2**8-1,0,2**8-1)
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[1.0,0.0,1.0,1.0]))
+		glSecondaryColor3ubv([0,2**8-1,0])
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[0.0,1.0,0.0,1.0]))
+		glSecondaryColor3ui(2**32-1,0,2**32-1)
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[1.0,0.0,1.0,1.0]))
+		glSecondaryColor3uiv([0,2**32-1,0])
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[0.0,1.0,0.0,1.0]))
+		glSecondaryColor3us(2**16-1,0,2**16-1)
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[1.0,0.0,1.0,1.0]))
+		glSecondaryColor3usv([0,2**16-1,0])
+		assert(approx_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR),[0.0,1.0,0.0,1.0]))
+	end
+
+	def test_glwindowpos
+		return if not supported?(1.4)
+		# 2
+		glWindowPos2d(1.0,2.0)
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1,2,0,1])
+		glWindowPos2dv([2.0,1.0])
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[2,1,0,1])
+		glWindowPos2f(1.0,2.0)
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1,2,0,1])
+		glWindowPos2fv([2.0,1.0])
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[2,1,0,1])
+		glWindowPos2i(1,2)
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1,2,0,1])
+		glWindowPos2iv([2,1])
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[2,1,0,1])
+		glWindowPos2s(1,2)
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1,2,0,1])
+		glWindowPos2sv([2,1])
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[2,1,0,1])
+
+		# 3
+		glWindowPos3d(1.0,2.0,0.5)
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1,2,0.5,1])
+		glWindowPos3dv([3.0,2.0,1.0])
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3,2,1,1])
+		glWindowPos3f(1.0,2.0,0.5)
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1,2,0.5,1])
+		glWindowPos3fv([3.0,2.0,1.0])
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3,2,1,1])
+		glWindowPos3i(1,2,0)
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1,2,0,1])
+		glWindowPos3iv([3,2,1])
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3,2,1,1])
+		glWindowPos3s(1,2,0)
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1,2,0,1])
+		glWindowPos3sv([3,2,1])
+		assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3,2,1,1])
+	end
+end