opengl 0.7.0.pre1 → 0.7.0.pre2

data/test/{tc_ext_gremedy.rb → test_gl_ext_gremedy.rb}

@@ -13,24 +13,24 @@
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-require 'test/unit'
+require 'opengl/test_case'
 
-class Test_EXT_GREMEDY < Test::Unit::TestCase
+class TestGlExtGremedy < OpenGL::TestCase
 	def setup
-		common_setup()
+		super()
 	end
 
 	def teardown
-		common_teardown()
+		super()
 	end
 
 	def test_gl_gremedy_string_marker
-		return if not supported?("GL_GREMEDY_string_marker")
+		supported?("GL_GREMEDY_string_marker")
 		glStringMarkerGREMEDY("test")
 	end
 
 	def test_gl_gremedy_frame_terminator
-		return if not supported?("GL_GREMEDY_frame_terminator")
+		supported?("GL_GREMEDY_frame_terminator")
 		glFrameTerminatorGREMEDY()
 	end
 end

data/test/test_gl_ext_nv.rb

@@ -0,0 +1,352 @@
+
+# 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 'opengl/test_case'
+
+class TestGlExtNv < OpenGL::TestCase
+
+  def test_gl_nv_vertex_program
+    supported?("GL_NV_vertex_program")
+
+    assert_equal(glIsProgramNV(0),false)
+    programs = glGenProgramsNV(2)
+    assert_equal(programs.size,2)
+
+    program = "!!VSP1.0\nEND"
+
+    glBindProgramNV(GL_VERTEX_PROGRAM_NV, programs[1])
+    glLoadProgramNV(GL_VERTEX_STATE_PROGRAM_NV, programs[0], program)
+    assert_equal(glGetProgramStringNV(programs[0], GL_PROGRAM_STRING_NV), program)
+    assert_equal(glIsProgramNV(programs[0]),true)	
+
+    assert_equal(glGetProgramivNV(programs[0],GL_PROGRAM_LENGTH_NV),program.size)
+
+    glVertexAttribPointerNV(1,2,GL_FLOAT,0,[1,1].pack("f*"))
+    assert_equal(glGetVertexAttribPointervNV(1),[1,1].pack("f*"))
+
+    glExecuteProgramNV(GL_VERTEX_STATE_PROGRAM_NV,programs[0],[1,1,1,1])
+
+    glProgramParameter4dNV(GL_VERTEX_PROGRAM_NV,1, 1,2,3,4)
+    assert_equal(glGetProgramParameterdvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[1,2,3,4])
+    glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV,1, 5,6,7,8)
+    assert_equal(glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[5,6,7,8])
+    glProgramParameter4dvNV(GL_VERTEX_PROGRAM_NV,1, [1,2,3,4])
+    assert_equal(glGetProgramParameterdvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[1,2,3,4])
+    glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV,1, [5,6,7,8])
+    assert_equal(glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[5,6,7,8])
+
+    glProgramParameters4fvNV(GL_VERTEX_PROGRAM_NV,1, [1,2,3,4,5,6,7,8])
+    assert_equal(glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[1,2,3,4])
+    assert_equal(glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV,2,GL_PROGRAM_PARAMETER_NV),[5,6,7,8])
+
+    glProgramParameters4dvNV(GL_VERTEX_PROGRAM_NV,1, [8,7,6,5,4,3,2,1])
+    assert_equal(glGetProgramParameterdvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[8,7,6,5])
+    assert_equal(glGetProgramParameterdvNV(GL_VERTEX_PROGRAM_NV,2,GL_PROGRAM_PARAMETER_NV),[4,3,2,1])
+
+
+    glVertexAttrib1dNV(1,1)
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],1)
+    glVertexAttrib1fNV(1,2)
+    assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0],2)
+    glVertexAttrib1sNV(1,3)
+    assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0],3)
+    glVertexAttrib1dvNV(1,[1])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],1)
+    glVertexAttrib1fvNV(1,[2])
+    assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0],2)
+    glVertexAttrib1svNV(1,[3])
+    assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0],3)
+
+    glVertexAttrib2dNV(1,1,2)
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[1,2])
+    glVertexAttrib2fNV(1,2,3)
+    assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[2,3])
+    glVertexAttrib2sNV(1,3,4)
+    assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[3,4])
+    glVertexAttrib2dvNV(1,[1,2])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[1,2])
+    glVertexAttrib2fvNV(1,[2,3])
+    assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[2,3])
+    glVertexAttrib2svNV(1,[3,4])
+    assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[3,4])
+
+    glVertexAttrib3dNV(1,1,2,3)
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[1,2,3])
+    glVertexAttrib3fNV(1,2,3,4)
+    assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[2,3,4])
+    glVertexAttrib3sNV(1,3,4,5)
+    assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[3,4,5])
+    glVertexAttrib3dvNV(1,[1,2,3])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[1,2,3])
+    glVertexAttrib3fvNV(1,[2,3,4])
+    assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[2,3,4])
+    glVertexAttrib3svNV(1,[3,4,5])
+    assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[3,4,5])
+
+    glVertexAttrib4dNV(1,1,2,3,4)
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,2,3,4])
+    glVertexAttrib4fNV(1,2,3,4,5)
+    assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[2,3,4,5])
+    glVertexAttrib4sNV(1,3,4,5,6)
+    assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[3,4,5,6])
+    glVertexAttrib4dvNV(1,[1,2,3,4])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,2,3,4])
+    glVertexAttrib4fvNV(1,[2,3,4,5])
+    assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[2,3,4,5])
+    glVertexAttrib4svNV(1,[3,4,5,6])
+    assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[3,4,5,6])
+
+    glVertexAttrib4ubNV(1,2**8-1,0,2**8-1,0)
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,0,1,0])
+    glVertexAttrib4ubvNV(1,[0,2**8-1,0,2**8-1])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[0,1,0,1])
+
+    glVertexAttribs1dvNV(1,[1,2])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],1)
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0],2)
+    glVertexAttribs1fvNV(1,[3,4])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],3)
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0],4)
+    glVertexAttribs1svNV(1,[5,6])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],5)
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0],6)
+
+    glVertexAttribs2dvNV(1,[1,2,3,4])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[1,2])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,2],[3,4])
+    glVertexAttribs2fvNV(1,[3,4,5,6])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[3,4])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,2],[5,6])
+    glVertexAttribs2svNV(1,[5,6,7,8])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[5,6])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,2],[7,8])
+
+    glVertexAttribs3dvNV(1,[1,2,3,4,5,6])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[1,2,3])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,3],[4,5,6])
+    glVertexAttribs3fvNV(1,[3,4,5,6,7,8])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[3,4,5])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,3],[6,7,8])
+    glVertexAttribs3svNV(1,[5,6,7,8,9,10])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[5,6,7])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,3],[8,9,10])
+
+    glVertexAttribs4dvNV(1,[1,2,3,4,5,6,7,8])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,2,3,4])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,4],[5,6,7,8])
+    glVertexAttribs4fvNV(1,[3,4,5,6,7,8,9,10])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[3,4,5,6])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,4],[7,8,9,10])
+    glVertexAttribs4svNV(1,[5,6,7,8,9,10,11,12])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[5,6,7,8])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,4],[9,10,11,12])
+    glVertexAttribs4ubvNV(1,[2**8-1,0,2**8-1,0,2**8-1,0,2**8-1,0])
+    assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,0,1,0])
+    assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,4],[1,0,1,0])
+
+    glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MATRIX0_NV, GL_IDENTITY_NV);
+    assert_equal(glGetTrackMatrixivNV(GL_VERTEX_PROGRAM_NV, 4, GL_TRACK_MATRIX_NV),GL_MATRIX0_NV)
+
+    glRequestResidentProgramsNV(programs[0])
+    res = glAreProgramsResidentNV(programs[0])
+    assert_equal(res.size,1)
+
+    glDeleteProgramsNV(programs)
+  end
+
+  def test_gl_nv_fragment_program
+    supported?("GL_NV_fragment_program")
+    programs = glGenProgramsNV(1)
+    program = "!!FP1.0\nDECLARE test = {0,0,0,0};\nEND"
+    glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, programs[0])
+    glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, programs[0], program)
+
+    glProgramNamedParameter4fNV(programs[0],"test",1,2,3,4)
+    assert_equal(glGetProgramNamedParameterfvNV(programs[0],"test"),[1,2,3,4])
+    glProgramNamedParameter4dNV(programs[0],"test",5,6,7,8)
+    assert_equal(glGetProgramNamedParameterdvNV(programs[0],"test"),[5,6,7,8])
+    glProgramNamedParameter4fvNV(programs[0],"test",[1,2,3,4])
+    assert_equal(glGetProgramNamedParameterfvNV(programs[0],"test"),[1,2,3,4])
+    glProgramNamedParameter4dvNV(programs[0],"test",[5,6,7,8])
+    assert_equal(glGetProgramNamedParameterdvNV(programs[0],"test"),[5,6,7,8])
+
+    glDeleteProgramsNV(programs)
+  end
+
+  def test_gl_nv_framebuffer_multisample_coverage
+    supported?("GL_NV_framebuffer_multisample_coverage")
+    rb = glGenRenderbuffersEXT(1)[0]
+
+    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,rb)
+    glRenderbufferStorageMultisampleCoverageNV(GL_RENDERBUFFER_EXT,4,4, GL_RGBA,2,2)
+    samples = glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT,GL_RENDERBUFFER_COVERAGE_SAMPLES_NV)
+    assert_equal(samples,4)
+    samples = glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT,GL_RENDERBUFFER_COLOR_SAMPLES_NV)
+    assert_equal(samples,4)
+
+    glDeleteRenderbuffersEXT(rb)
+  end
+
+  def test_gl_nv_fence
+    supported?("GL_NV_fence")
+    fences = glGenFencesNV(2)
+    assert_equal(fences.size,2)
+
+    glSetFenceNV(fences[0],GL_ALL_COMPLETED_NV)
+    assert_equal(glGetFenceivNV(fences[0],GL_FENCE_CONDITION_NV),GL_ALL_COMPLETED_NV)
+    assert_equal(glIsFenceNV(fences[0]),true)
+
+    glFinishFenceNV(fences[0])
+    assert_equal(glTestFenceNV(fences[0]),true)
+
+    glDeleteFencesNV(fences)
+  end
+
+  def test_gl_nv_depth_buffer_float
+    supported?("GL_NV_depth_buffer_float")
+    glDepthRangedNV(0.1,0.2)
+    assert(assert_in_delta(glGetFloatv(GL_DEPTH_RANGE),[0.1,0.2]))
+    glDepthBoundsdNV(0.1,0.2)
+    assert(assert_in_delta(glGetFloatv(GL_DEPTH_BOUNDS_EXT),[0.1,0.2]))
+    glClearDepthdNV(0.3)
+    assert(assert_in_delta([glGetDoublev(GL_DEPTH_CLEAR_VALUE)],[0.3]))
+  end
+
+  def test_gl_nv_occlusion_query
+    supported?("GL_NV_occlusion_query")
+
+    queries = glGenOcclusionQueriesNV(2)
+    assert_equal(queries.size,2)
+
+    glBeginOcclusionQueryNV(queries[0])
+    assert_equal(glIsOcclusionQueryNV(queries[0]),true)
+
+    glEndOcclusionQueryNV()
+    r = glGetOcclusionQueryivNV(queries[0],GL_PIXEL_COUNT_AVAILABLE_NV)
+    assert(r==GL_TRUE || r==GL_FALSE)
+    assert(glGetOcclusionQueryuivNV(queries[0],GL_PIXEL_COUNT_NV)>=0)
+
+    glDeleteOcclusionQueriesNV(queries)
+    assert_equal(glIsOcclusionQueryNV(queries[1]),false)
+  end
+
+  def test_gl_nv_gpu_program4
+    supported?(["GL_NV_gpu_program4","GL_ARB_vertex_program"])
+
+    programs = glGenProgramsARB(1)
+    program = "!!ARBvp1.0\nTEMP vv;\nEND"
+
+    glBindProgramARB(GL_VERTEX_PROGRAM_ARB, programs[0])
+    glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, program)
+
+    glProgramLocalParameterI4iNV(GL_VERTEX_PROGRAM_ARB,1, 1,2,3,4)
+    assert_equal(glGetProgramLocalParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+    glProgramLocalParameterI4uiNV(GL_VERTEX_PROGRAM_ARB,1, 5,6,7,8)
+    assert_equal(glGetProgramLocalParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+    glProgramLocalParameterI4ivNV(GL_VERTEX_PROGRAM_ARB,1, [1,2,3,4])
+    assert_equal(glGetProgramLocalParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+    glProgramLocalParameterI4uivNV(GL_VERTEX_PROGRAM_ARB,1, [5,6,7,8])
+    assert_equal(glGetProgramLocalParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+    glProgramLocalParametersI4ivNV(GL_VERTEX_PROGRAM_ARB,1, [1,2,3,4])
+    assert_equal(glGetProgramLocalParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+    glProgramLocalParametersI4uivNV(GL_VERTEX_PROGRAM_ARB,1, [5,6,7,8])
+    assert_equal(glGetProgramLocalParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+
+    glProgramEnvParameterI4iNV(GL_VERTEX_PROGRAM_ARB,1, 1,2,3,4)
+    assert_equal(glGetProgramEnvParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+    glProgramEnvParameterI4uiNV(GL_VERTEX_PROGRAM_ARB,1, 5,6,7,8)
+    assert_equal(glGetProgramEnvParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+    glProgramEnvParameterI4ivNV(GL_VERTEX_PROGRAM_ARB,1, [1,2,3,4])
+    assert_equal(glGetProgramEnvParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+    glProgramEnvParameterI4uivNV(GL_VERTEX_PROGRAM_ARB,1, [5,6,7,8])
+    assert_equal(glGetProgramEnvParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+    glProgramEnvParametersI4ivNV(GL_VERTEX_PROGRAM_ARB,1, [1,2,3,4])
+    assert_equal(glGetProgramEnvParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+    glProgramEnvParametersI4uivNV(GL_VERTEX_PROGRAM_ARB,1, [5,6,7,8])
+    assert_equal(glGetProgramEnvParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+
+    glDeleteProgramsARB(programs)
+  end
+
+  def test_gl_nv_gpu_program4
+    supported?(["GL_NV_gpu_program4","GL_EXT_framebuffer_object"])
+    geometry_program = <<-EOP
+!!NVgp4.0
+PRIMITIVE_IN TRIANGLES;
+PRIMITIVE_OUT TRIANGLE_STRIP;
+VERTICES_OUT 1;
+END
+    EOP
+
+    program_id = glGenProgramsARB(1)[0]
+    glBindProgramARB(GL_GEOMETRY_PROGRAM_NV, program_id)
+    glProgramStringARB(GL_GEOMETRY_PROGRAM_NV, GL_PROGRAM_FORMAT_ASCII_ARB, geometry_program);
+
+    assert_equal(glGetProgramivARB(GL_GEOMETRY_PROGRAM_NV,GL_GEOMETRY_VERTICES_OUT_EXT),1)
+    glProgramVertexLimitNV(GL_GEOMETRY_PROGRAM_NV, 2)
+    assert_equal(glGetProgramivARB(GL_GEOMETRY_PROGRAM_NV,GL_GEOMETRY_VERTICES_OUT_EXT),2)
+
+    #
+
+    fbo = glGenFramebuffersEXT(1)[0]
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fbo)
+
+    texture2d,texture3d,texture_cube = glGenTextures(3)
+    glBindTexture(GL_TEXTURE_2D, texture2d)
+    glBindTexture(GL_TEXTURE_3D, texture3d)
+    glBindTexture(GL_TEXTURE_CUBE_MAP, texture_cube)
+
+    glFramebufferTextureEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,texture2d,0)
+    assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT),texture2d)
+    assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT),0)
+    glFramebufferTextureLayerEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,texture3d,0,1)
+    assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT),texture3d)
+    assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT),0)
+    assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT),1)
+
+    glFramebufferTextureFaceEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,texture_cube,0,GL_TEXTURE_CUBE_MAP_POSITIVE_X)
+    assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT),texture_cube)
+    assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT),0)
+    assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT),GL_TEXTURE_CUBE_MAP_POSITIVE_X)
+
+    glDeleteTextures([texture2d,texture3d])
+    glDeleteFramebuffersEXT(fbo)
+    glDeleteProgramsARB(program_id)
+  end
+
+  def test_gl_nv_primitive_restart
+    supported?("GL_NV_primitive_restart")
+    glBegin(GL_TRIANGLES)
+    glPrimitiveRestartNV()
+    glEnd
+    glPrimitiveRestartIndexNV(2)
+    assert_equal(glGetIntegerv(GL_PRIMITIVE_RESTART_INDEX_NV),2)
+  end
+
+  def test_gl_nv_point_sprite
+    supported?("GL_NV_point_sprite")
+    glPointParameteriNV(GL_POINT_SPRITE_R_MODE_NV, GL_ZERO)
+    assert_equal(glGetIntegerv(GL_POINT_SPRITE_R_MODE_NV),GL_ZERO)
+    glPointParameteriNV(GL_POINT_SPRITE_R_MODE_NV, GL_S)
+    assert_equal(glGetIntegerv(GL_POINT_SPRITE_R_MODE_NV),GL_S)
+
+    glPointParameterivNV(GL_POINT_SPRITE_R_MODE_NV, [GL_ZERO])
+    assert_equal(glGetIntegerv(GL_POINT_SPRITE_R_MODE_NV),GL_ZERO)
+    glPointParameterivNV(GL_POINT_SPRITE_R_MODE_NV, [GL_S])
+    assert_equal(glGetIntegerv(GL_POINT_SPRITE_R_MODE_NV),GL_S)
+  end
+
+end
+

data/test/test_glu.rb

@@ -0,0 +1,309 @@
+#
+# 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 'opengl/test_case'
+
+class TestGlu < OpenGL::TestCase
+
+  def test_gluortho
+    res = [ [2.0/WINDOW_SIZE, 0, 0, 0],
+      [0, 2.0/WINDOW_SIZE, 0, 0],
+      [0, 0, -1, 0],
+      [-1, -1, 0, 1] ]
+
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity()
+    gluOrtho2D(0, WINDOW_SIZE, 0, WINDOW_SIZE)
+    assert_equal res, glGetDoublev(GL_PROJECTION_MATRIX)
+  end
+
+  def test_glugetstring
+    refute_empty gluGetString GLU_VERSION
+  end
+
+  def test_gluerrorstring
+    refute_empty gluErrorString GL_INVALID_VALUE
+  end
+
+  def test_glubuild2dmipmaps
+    textures = glGenTextures(1)
+    glBindTexture(GL_TEXTURE_2D, textures[0])
+
+    image = ([0, 0, 0, 1, 1, 1] * 8).pack("f*") # 16 RGB pixels
+
+    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, 4, 4, GL_RGB, GL_FLOAT, image)
+    im = glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_FLOAT)
+
+    assert_equal image, im
+    assert_equal 4*4*3, im.unpack("f*").size
+
+    im = glGetTexImage(GL_TEXTURE_2D, 1, GL_RGB, GL_FLOAT)
+    assert_equal 2*2*3, im.unpack("f*").size
+
+    im = glGetTexImage(GL_TEXTURE_2D, 2, GL_RGB, GL_FLOAT)
+    assert_equal 1*1*3, im.unpack("f*").size
+
+    glDeleteTextures(textures)
+  end
+
+  def test_glubuild1dmipmaps
+    textures = glGenTextures(1)
+    glBindTexture(GL_TEXTURE_1D, textures[0])
+
+    image = ([0, 0, 0, 1, 1, 1] * 2).pack("f*") # 4 RGB pixels
+
+    gluBuild1DMipmaps(GL_TEXTURE_1D, GL_RGB8, 4, GL_RGB, GL_FLOAT, image)
+
+    im = glGetTexImage(GL_TEXTURE_1D, 0, GL_RGB, GL_FLOAT)
+    assert_equal image, im
+    assert_equal 4*3, im.unpack("f*").size
+    im = glGetTexImage(GL_TEXTURE_1D, 1, GL_RGB, GL_FLOAT)
+    assert_equal 2*3, im.unpack("f*").size
+    im = glGetTexImage(GL_TEXTURE_1D, 2, GL_RGB, GL_FLOAT)
+    assert_equal 1*3, im.unpack("f*").size
+
+    glDeleteTextures(textures)
+  end
+
+  def test_glulookat
+    m = [[0, 0, 1, 0], [0, 1, 0, 0], [-1, 0, 0, 0], [0, 0, -1, 1]]
+    gluLookAt(1, 0, 0, 0, 0, 0, 0, 1, 0)
+    assert_equal m, glGetDoublev(GL_PROJECTION_MATRIX)
+  end
+
+  def test_gluproject
+    pos = gluProject(1, 1, 1)
+    assert_equal [WINDOW_SIZE, WINDOW_SIZE, 1], pos
+
+    mp = glGetDoublev(GL_PROJECTION_MATRIX)
+    mm = Matrix.rows(glGetDoublev(GL_MODELVIEW_MATRIX))
+    view = glGetDoublev(GL_VIEWPORT)
+    pos = gluProject(1, 1, 1, mp, mm, view)
+    assert_equal(pos, [WINDOW_SIZE, WINDOW_SIZE, 1])
+
+    assert_raises ArgumentError do pos = gluProject(1, 1, 1, mp, [1, 2, 3, 4], view) end
+  end
+
+  def test_gluunproject
+    pos = gluUnProject(WINDOW_SIZE, WINDOW_SIZE, 1)
+    assert_equal(pos, [1, 1, 1])
+
+    mp = glGetDoublev(GL_PROJECTION_MATRIX)
+    mm = Matrix.rows(glGetDoublev(GL_MODELVIEW_MATRIX))
+    view = glGetDoublev(GL_VIEWPORT)
+    pos = gluUnProject(WINDOW_SIZE, WINDOW_SIZE, 1, mp, mm, view)
+    assert_equal(pos, [1, 1, 1])
+    assert_raises ArgumentError do	pos = gluUnProject(WINDOW_SIZE, WINDOW_SIZE, 1, mp, [1, 2, 3, 4], view) end
+  end
+
+  def test_glupickmatrix
+    t = WINDOW_SIZE / 5.0
+    m = [[t, 0.0, 0.0, 0.0], [0.0, t, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [t, t, 0.0, 1.0]]
+    glMatrixMode(GL_PROJECTION)
+
+    glLoadIdentity()
+    gluPickMatrix(0, 0)
+    assert_each_in_delta m, glGetDoublev(GL_PROJECTION_MATRIX)
+
+    glLoadIdentity()
+    gluPickMatrix(0, 0, 5, 5)
+    assert_each_in_delta m, glGetDoublev(GL_PROJECTION_MATRIX)
+
+    glLoadIdentity()
+    gluPickMatrix(0, 0, 5, 5, glGetDoublev(GL_VIEWPORT))
+    assert_each_in_delta m, glGetDoublev(GL_PROJECTION_MATRIX)
+  end
+
+  def test_gluperspective
+    m = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -3, -1], [0, 0, -4, 0]]
+    gluPerspective(90, 1, 1, 2)
+    assert_equal m, glGetDoublev(GL_PROJECTION_MATRIX)
+  end
+
+  def test_gluscaleimage
+    image = ([0, 0, 0, 1, 1, 1] * 8).pack("f*") # 16 RGB pixels
+    scaled = gluScaleImage(GL_RGB, 4, 4, GL_FLOAT, image, 2, 2, GL_FLOAT)
+    assert_equal(scaled.unpack("f*").length, 2*2*3)
+  end
+
+  def test_gluquadrics
+    ecount = 0
+    error_func = lambda do |error|
+      ecount+=1
+    end
+
+    q = gluNewQuadric()
+    gluQuadricDrawStyle(q, GL_LINE)
+    gluQuadricNormals(q, GL_SMOOTH)
+    gluQuadricOrientation(q, GLU_OUTSIDE)
+    gluQuadricTexture(q, GL_FALSE)
+    gluQuadricCallback(q, GLU_ERROR, error_func)
+
+    buf = glFeedbackBuffer(1024, GL_3D)
+    glRenderMode(GL_FEEDBACK)
+    gluSphere(q, 1.0, 4, 3)
+    count = glRenderMode(GL_RENDER)
+    refute_equal 0, count
+
+    glRenderMode(GL_FEEDBACK)
+    gluCylinder(q, 1.0, 1.0, 1.0, 4, 3)
+    count = glRenderMode(GL_RENDER)
+    refute_equal 0, count
+
+    glRenderMode(GL_FEEDBACK)
+    gluDisk(q, 1.0, 2.0, 4, 3)
+    count = glRenderMode(GL_RENDER)
+    refute_equal 0, count
+
+    glRenderMode(GL_FEEDBACK)
+    gluPartialDisk(q, 1.0, 2.0, 4, 3, 0, 360)
+    count = glRenderMode(GL_RENDER)
+    refute_equal 0, count
+
+    assert_equal 0, ecount
+    gluSphere(q, 0.0, 0, 0)
+    assert_equal 1, ecount
+    gluDeleteQuadric(q)
+  end
+
+  def test_glunurbs
+    ecount = 0
+
+    glViewport(0, 0, WINDOW_SIZE, WINDOW_SIZE)
+    glMatrixMode(GL_PROJECTION)
+    glOrtho(0, WINDOW_SIZE, 0, WINDOW_SIZE, -1, 1)
+
+    n_error = lambda do |error|
+      ecount += 1
+    end
+
+    m = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
+    m2 = Matrix.rows(m)
+
+    n = gluNewNurbsRenderer()
+    gluNurbsCallback(n, GLU_ERROR, n_error)
+    gluNurbsProperty(n, GLU_SAMPLING_TOLERANCE, 40)
+    assert_equal 40, gluGetNurbsProperty(n, GLU_SAMPLING_TOLERANCE)
+
+    gluLoadSamplingMatrices(n, m, m2, glGetIntegerv(GL_VIEWPORT))
+    assert_raises ArgumentError do gluLoadSamplingMatrices(n, m, [1, 2, 3, 4], glGetIntegerv(GL_VIEWPORT)) end
+
+    knots = [0, 0, 0, 0, 1, 1, 1, 1]
+    ctlpoints_curve = [[50, 50, 0], [400, 50, 0], [400, 400, 0], [50, 400, 0]]
+
+    # generate surface control points
+    ctlpoints =  Array.new(4).collect { Array.new(4).collect { Array.new(3, nil) } } # 4*4*3 array
+    0.upto(3)	do |u|
+      0.upto(3) do |v|
+        ctlpoints[u][v][0]=2.0*(u-1.5)
+        ctlpoints[u][v][1]=2.0*(v-1.5)
+
+        if ((u==1 || u==2) && (v==1 || v==2))
+          ctlpoints[u][v][2]=6.0
+        else
+          ctlpoints[u][v][2]=0.0
+        end
+      end
+    end
+
+    buf = glFeedbackBuffer(1024*1024*8, GL_3D) # large enough buffer for tesselated surface
+    glRenderMode(GL_FEEDBACK)
+    gluBeginCurve(n)
+    gluNurbsCurve(n, knots, ctlpoints_curve, 4, GL_MAP1_VERTEX_3)
+    gluEndCurve(n)
+
+    gluBeginSurface(n)
+    gluNurbsSurface(n, knots, knots, ctlpoints, 4, 4, GL_MAP2_VERTEX_3)
+    gluEndSurface(n)
+
+    count = glRenderMode(GL_RENDER)
+    refute_equal 1, count
+
+    assert_equal 0, ecount
+    gluBeginTrim(n)
+    gluPwlCurve(n, [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]], GLU_MAP1_TRIM_2)
+    gluEndTrim(n)
+
+    gluDeleteNurbsRenderer(n)
+    assert_equal 1, ecount
+  end
+
+  def test_glutess
+    glViewport(0, 0, WINDOW_SIZE, WINDOW_SIZE)
+    glMatrixMode(GL_PROJECTION)
+    glOrtho(0, WINDOW_SIZE, 0, WINDOW_SIZE, -1, 1)
+    vcount, bcount, ecount = 0, 0, 0
+
+    cb_begin = lambda do |type|
+      bcount += 1
+    end
+    cb_end = lambda do
+      ecount += 1
+    end
+    cb_vertex = lambda do |data|
+      vcount += 1
+    end
+    cb_error = lambda do |error|
+      p gluErrorString(error)
+    end
+
+    t = gluNewTess()
+    gluTessCallback(t, GLU_TESS_BEGIN, cb_begin)
+    gluTessCallback(t, GLU_TESS_END, cb_end)
+    gluTessCallback(t, GLU_TESS_ERROR, cb_error)
+    gluTessCallback(t, GLU_TESS_VERTEX, cb_vertex)
+    gluTessProperty(t, GLU_TESS_BOUNDARY_ONLY, GL_TRUE)
+    assert_equal GL_TRUE, gluGetTessProperty(t, GLU_TESS_BOUNDARY_ONLY)
+    gluTessProperty(t, GLU_TESS_BOUNDARY_ONLY, GL_FALSE)
+    assert_equal GL_FALSE, gluGetTessProperty(t, GLU_TESS_BOUNDARY_ONLY)
+
+    gluTessNormal(t, 0.0, 0.0, 0.0)
+
+    rect = [[50.0, 50.0, 0.0],
+      [200.0, 50.0, 0.0],
+      [200.0, 200.0, 0.0],
+      [50.0, 200.0, 0.0]]
+    tri = [[75.0, 75.0, 0.0],
+      [125.0, 175.0, 0.0],
+      [175.0, 75.0, 0.0]]
+
+    gluTessBeginPolygon(t, nil)
+    gluTessBeginContour(t)
+    gluTessVertex(t, rect[0], rect[0])
+    gluTessVertex(t, rect[1], rect[1])
+    gluTessVertex(t, rect[2], rect[2])
+    gluTessVertex(t, rect[3], rect[3])
+    gluTessEndContour(t)
+    gluTessBeginContour(t)
+    gluTessVertex(t, tri[0], tri[0])
+    gluTessVertex(t, tri[1], tri[1])
+    gluTessVertex(t, tri[2], tri[2])
+    gluTessEndContour(t)
+    gluTessEndPolygon(t)
+
+    gluTessCallback(t, GLU_TESS_BEGIN, nil)
+    gluTessCallback(t, GLU_TESS_END, nil)
+    gluTessCallback(t, GLU_TESS_ERROR, nil)
+    gluTessCallback(t, GLU_TESS_VERTEX, nil)
+
+    gluDeleteTess(t)
+
+    assert_equal 1, bcount
+    assert_equal 1, ecount
+    assert_equal 9, vcount
+  end
+
+end
+