glu 8.2.0-x86-mingw32

data/lib/glu.rb

@@ -0,0 +1,28 @@
+begin
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "glu/#{$1}/glu"
+rescue LoadError
+  require 'glu/glu'
+end
+
+# (Glu.)gluSphere -> GLU.Sphere
+# (Glu::)GLU_INSIDE -> GLU::INSIDE
+module GLU
+  extend self
+  include Glu
+
+  Glu.constants.each do |cn|
+    n = cn.to_s.sub(/^GLU_/,'')
+    const_set( n, Glu.const_get( cn ) )
+  end
+
+  Glu.methods( false ).each do |mn|
+    n = mn.to_s.sub(/^glu/,'')
+    alias_method( n, mn )
+    public( n )
+  end
+end
+
+module Glu
+  VERSION = "8.2.0"
+end

data/lib/glu/dummy.rb

@@ -0,0 +1,2 @@
+# Unless this file exists, rake-compiler/hoe won't create this folder
+# and the extension won't build.

data/test/dummy.xorg.conf

@@ -0,0 +1,131 @@
+# This file is used to setup a dummy X server for testing on http://travis-ci.org
+# See config file ".travis.yml"
+
+##Xdummy:##
+Section "ServerFlags"
+  Option "DontVTSwitch" "true"
+  Option "AllowMouseOpenFail" "true"
+  Option "PciForceNone" "true"
+  Option "AutoEnableDevices" "false"
+  Option "AutoAddDevices" "false"
+EndSection
+
+
+##Xdummy:##
+Section "InputDevice"
+  Identifier "NoMouse"
+  Option "CorePointer" "true"
+  Driver "void"
+EndSection
+
+Section "InputDevice"
+  Identifier "NoKeyboard"
+  Option "CoreKeyboard" "true"
+  Driver "void"
+EndSection
+
+##Xdummy:##
+Section "Device"
+  Identifier "Videocard0"
+  Driver "dummy"
+  #VideoRam 4096000
+  VideoRam 256000
+EndSection
+
+##Xdummy:##
+Section "Monitor"
+  Identifier "Monitor0"
+  HorizSync   10.0 - 300.0
+  VertRefresh 10.0 - 200.0
+  DisplaySize 4335 1084
+  #The following modeline is invalid (calculator overflowed):
+  #Modeline "32000x32000@0" -38917.43 32000 32032 -115848 -115816 32000 32775 32826 33601
+  Modeline "16384x8192@10" 2101.93 16384 16416 24400 24432 8192 8390 8403 8602
+  Modeline "8192x4096@10" 424.46 8192 8224 9832 9864 4096 4195 4202 4301
+  Modeline "5120x3200@10" 199.75 5120 5152 5904 5936 3200 3277 3283 3361
+  Modeline "3840x2880@10" 133.43 3840 3872 4376 4408 2880 2950 2955 3025
+  Modeline "3840x2560@10" 116.93 3840 3872 4312 4344 2560 2622 2627 2689
+  Modeline "3840x2048@10" 91.45 3840 3872 4216 4248 2048 2097 2101 2151
+  Modeline "2048x2048@10" 49.47 2048 2080 2264 2296 2048 2097 2101 2151
+  Modeline "2560x1600@10" 47.12 2560 2592 2768 2800 1600 1639 1642 1681
+  Modeline "1920x1200@10" 26.28 1920 1952 2048 2080 1200 1229 1231 1261
+  Modeline "1920x1080@10" 23.53 1920 1952 2040 2072 1080 1106 1108 1135
+  Modeline "1680x1050@10" 20.08 1680 1712 1784 1816 1050 1075 1077 1103
+  Modeline "1600x900@20" 33.92 1600 1632 1760 1792 900 921 924 946
+  Modeline "1440x900@20" 30.66 1440 1472 1584 1616 900 921 924 946
+  Modeline "1360x768@20" 24.49 1360 1392 1480 1512 768 786 789 807
+  #common resolutions for android devices (both orientations):
+  Modeline "800x1280@20" 25.89 800 832 928 960 1280 1310 1315 1345
+  Modeline "1280x800@20" 24.15 1280 1312 1400 1432 800 819 822 841
+  Modeline "720x1280@25" 30.22 720 752 864 896 1280 1309 1315 1345
+  Modeline "1280x720@25" 27.41 1280 1312 1416 1448 720 737 740 757
+  Modeline "768x1024@25" 24.93 768 800 888 920 1024 1047 1052 1076
+  Modeline "1024x768@25" 23.77 1024 1056 1144 1176 768 785 789 807
+  Modeline "600x1024@25" 19.90 600 632 704 736 1024 1047 1052 1076
+  Modeline "1024x600@25" 18.26 1024 1056 1120 1152 600 614 617 631
+  Modeline "536x960@25" 16.74 536 568 624 656 960 982 986 1009
+  Modeline "960x536@25" 15.23 960 992 1048 1080 536 548 551 563
+  Modeline "600x800@25" 15.17 600 632 688 720 800 818 822 841
+  Modeline "800x600@25" 14.50 800 832 880 912 600 614 617 631
+  Modeline "480x854@25" 13.34 480 512 560 592 854 873 877 897
+  Modeline "848x480@25" 12.09 848 880 920 952 480 491 493 505
+  Modeline "480x800@25" 12.43 480 512 552 584 800 818 822 841
+  Modeline "800x480@25" 11.46 800 832 872 904 480 491 493 505
+  Modeline "320x480@50" 10.73 320 352 392 424 480 490 494 505
+  Modeline "480x320@50" 9.79 480 512 544 576 320 327 330 337
+  Modeline "240x400@50" 6.96 240 272 296 328 400 408 412 421
+  Modeline "400x240@50" 6.17 400 432 448 480 240 245 247 253
+  Modeline "240x320@50" 5.47 240 272 288 320 320 327 330 337
+  Modeline "320x240@50" 5.10 320 352 368 400 240 245 247 253
+  #resolutions for android devices (both orientations)
+  #minus the status bar
+  #38px status bar (and width rounded up)
+  Modeline "800x1242@20" 25.03 800 832 920 952 1242 1271 1275 1305
+  Modeline "1280x762@20" 22.93 1280 1312 1392 1424 762 780 783 801
+  Modeline "720x1242@25" 29.20 720 752 856 888 1242 1271 1276 1305
+  Modeline "1280x682@25" 25.85 1280 1312 1408 1440 682 698 701 717
+  Modeline "768x986@25" 23.90 768 800 888 920 986 1009 1013 1036
+  Modeline "1024x730@25" 22.50 1024 1056 1136 1168 730 747 750 767
+  Modeline "600x986@25" 19.07 600 632 704 736 986 1009 1013 1036
+  Modeline "1024x562@25" 17.03 1024 1056 1120 1152 562 575 578 591
+  Modeline "536x922@25" 16.01 536 568 624 656 922 943 947 969
+  Modeline "960x498@25" 14.09 960 992 1040 1072 498 509 511 523
+  Modeline "600x762@25" 14.39 600 632 680 712 762 779 783 801
+  Modeline "800x562@25" 13.52 800 832 880 912 562 575 578 591
+  Modeline "480x810@25" 12.59 480 512 552 584 810 828 832 851
+  Modeline "848x442@25" 11.09 848 880 920 952 442 452 454 465
+  Modeline "480x762@25" 11.79 480 512 552 584 762 779 783 801
+  Modeline "800x442@25" 10.51 800 832 864 896 442 452 454 465
+  #32px status bar (no need for rounding):
+  Modeline "320x448@50" 9.93 320 352 384 416 448 457 461 471
+  Modeline "480x288@50" 8.75 480 512 544 576 288 294 297 303
+  #24px status bar:
+  Modeline "240x376@50" 6.49 240 272 296 328 376 384 387 395
+  Modeline "400x216@50" 5.50 400 432 448 480 216 220 222 227
+  Modeline "240x296@50" 5.02 240 272 288 320 296 302 305 311
+  Modeline "320x216@50" 4.55 320 352 368 400 216 220 222 227
+EndSection
+
+##Xdummy:##
+Section "Screen"
+  Identifier "Screen0"
+  Device "Videocard0"
+  Monitor "Monitor0"
+  DefaultDepth 24
+  SubSection "Display"
+    Viewport 0 0
+    Depth 24
+    Modes "32000x32000" "16384x8192" "8192x4096" "5120x3200" "3840x2880" "3840x2560" "3840x2048" "2048x2048" "2560x1600" "1920x1440" "1920x1200" "1920x1080" "1600x1200" "1680x1050" "1600x900" "1400x1050" "1440x900" "1280x1024" "1366x768" "1280x800" "1024x768" "1024x600" "800x600" "320x200"
+    #Virtual 32000 32000
+    #Virtual 16384 8192
+    #Virtual 8192 4096
+    Virtual 1920 1440
+  EndSubSection
+EndSection
+
+Section "ServerLayout"
+  Identifier   "dummy_layout"
+  Screen       "screen0"
+  InputDevice  "NoMouse"
+  InputDevice  "NoKeyboard"
+EndSection

data/test/test_glu.rb

@@ -0,0 +1,310 @@
+#
+# 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'
+require 'glu'
+
+include Glu
+
+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 pos, [WINDOW_SIZE, WINDOW_SIZE, 1]
+
+    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([WINDOW_SIZE, WINDOW_SIZE, 1], pos)
+
+    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([1, 1, 1], pos)
+
+    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([1, 1, 1], pos)
+    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(2*2*3, scaled.unpack("f*").length)
+  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