qtbindings 4.8.6.1-x64-mingw32

data/examples/ruboids/ruboids/BoidView.rb

@@ -0,0 +1,159 @@
+#
+# Copyright (c) 2001 by Jim Menard <jimm@io.com>
+#
+# Released under the same license as Ruby. See
+# http://www.ruby-lang.org/en/LICENSE.txt.
+#
+
+require './View'
+
+class BoidView < View
+
+    BODY_COLOR = [0, 0, 0]
+    BEAK_COLOR = [0.75, 0.5, 0.0]
+    SHADOW_COLOR = [0.25, 0.55, 0.25]
+
+    HALF_WING_BASE = 3
+    HALF_LENGTH = 5
+    HALF_THICKNESS = 1
+    NOSE_LENGTH = 3
+
+    @@object = nil
+    @@shadow = nil
+    @@wings = nil
+    @@wingsShadows = nil
+
+    def initialize(model)
+	super(model, [0, 0, 0])
+	@wings = nil
+	@wingsShadows = nil
+    end
+
+    def makeObject
+	@@object = BoidView.makeObject() unless @@object
+	@object = @@object
+	@wings = @@wings
+    end
+
+    def makeShadow
+	BoidView.makeShadow() unless @@shadow
+	@shadow = @@shadow
+	@wingsShadows = @@wingsShadows
+    end
+
+    def drawObject
+	super()
+
+	angle = 0
+	case model.wingFlapPos
+	when 0
+	    angle = 60
+	when 1, 7
+	    angle = 30
+	when 2, 6
+	    angle = 0
+	when 3, 5
+	    angle = -30
+	when 4
+	    angle = -60
+	end
+
+	PushMatrix()
+	Rotate(angle, 0, 0, 1)
+	CallList(@wings[0])
+	Rotate(angle * -2, 0, 0, 1)
+	CallList(@wings[1])
+	PopMatrix()
+    end
+
+    def BoidView.makeObject
+	makeWings()
+
+	object = GenLists(1)
+	NewList(object, COMPILE)
+
+	makeBody()
+	makeNose()
+
+	EndList()
+
+	return object
+    end
+
+    def BoidView.makeShadow
+	@@shadow = GenLists(1)
+	NewList(@@shadow, COMPILE)
+
+	p0 = Point::ORIGIN.dup()
+	p1 = Point::ORIGIN.dup()
+	dims = Point.new(HALF_THICKNESS, HALF_THICKNESS, HALF_LENGTH)
+	p0.subtractPoint(dims)
+	p1.addPoint(dims)
+	
+	groundLevel = -($PARAMS['world_height'] / 2) + 1
+
+	Color(SHADOW_COLOR)
+	Begin(QUADS)
+	Vertex(p1.x, groundLevel, p0.z)
+	Vertex(p0.x, groundLevel, p0.z)
+	Vertex(p0.x, groundLevel, p1.z)
+	Vertex(p1.x, groundLevel, p1.z)
+	End()
+#  	Begin(TRIANGLES)
+#  	Vertex(p1.x, groundLevel, p1.z)
+#  	Vertex(0, groundLevel, p0.z)
+#  	Vertex(p0.x, groundLevel, p1.z)
+#  	End()
+
+	EndList()
+    end
+
+    def BoidView.makeBody
+	p0 = Point::ORIGIN.dup()
+	p1 = Point::ORIGIN.dup()
+	dims = Point.new(HALF_THICKNESS, HALF_THICKNESS, HALF_LENGTH)
+	p0.subtractPoint(dims)
+	p1.addPoint(dims)
+
+	Color(BODY_COLOR)
+	Graphics.boxFromCorners(p0, p1)
+    end
+
+    def BoidView.makeWings
+	@@wings = []
+	len = -$PARAMS['boid_wing_length']
+	@@wings << makeOneWing(len)
+	@@wings << makeOneWing(-len)
+    end
+
+    def BoidView.makeOneWing(len)
+	wing = GenLists(1)
+	NewList(wing, COMPILE)
+
+	Color(BODY_COLOR)
+	Begin(TRIANGLES)
+
+	Vertex(0, 0, -HALF_WING_BASE)
+	Vertex(len, 0, 0)
+	Vertex(0, 0, HALF_WING_BASE)
+
+	End()
+	EndList()
+	return wing
+    end
+
+    def BoidView.makeNose()
+	Color(BEAK_COLOR)
+	Begin(TRIANGLE_FAN)
+
+	Vertex(0, 0, HALF_LENGTH + NOSE_LENGTH)
+	Vertex( HALF_THICKNESS,  HALF_THICKNESS, HALF_LENGTH)
+	Vertex(-HALF_THICKNESS,  HALF_THICKNESS, HALF_LENGTH)
+	Vertex(-HALF_THICKNESS, -HALF_THICKNESS, HALF_LENGTH)
+	Vertex( HALF_THICKNESS, -HALF_THICKNESS, HALF_LENGTH)
+
+	End()
+    end
+
+end
+

data/examples/ruboids/ruboids/Camera.rb

@@ -0,0 +1,24 @@
+#
+# Copyright (c) 2001 by Jim Menard <jimm@io.com>
+#
+# Released under the same license as Ruby. See
+# http://www.ruby-lang.org/en/LICENSE.txt.
+#
+
+require './Params'
+
+class Camera
+
+    attr_accessor :position, :rotation, :zoom
+
+    def initialize
+	@position = Point.new($PARAMS['camera_x'],
+			      $PARAMS['camera_y'],
+			      $PARAMS['camera_z'])
+	@rotation = Point.new($PARAMS['camera_rot_x'],
+			      $PARAMS['camera_rot_y'],
+			      $PARAMS['camera_rot_z'])
+	@zoom = $PARAMS['camera_zoom']
+    end
+end
+

data/examples/ruboids/ruboids/CameraDialog.rb

@@ -0,0 +1,218 @@
+#
+# Copyright (c) 2001 by Jim Menard <jimm@io.com>
+#
+# Released under the same license as Ruby. See
+# http://www.ruby-lang.org/en/LICENSE.txt.
+#
+
+require 'Qt'
+require './World'
+require './Camera'
+
+class Adjustor
+    attr_accessor :slider, :num, :origValue
+    def initialize(slider, num, origValue = 0)
+        @slider = slider
+        @num = num
+        @origValue = origValue
+    end
+    def setSlider(val); @slider.setValue(val); end
+    def setNum(val); @num.setNum(val); end
+    def set(val)
+        setSlider(val)
+        setNum(val)
+    end
+    def reset
+        set(@origValue)
+        return @origValue
+    end
+end
+
+class CameraDialog < Qt::Dialog
+        slots         'slotReset()', 'slotLocXChanged(int)', 
+                        'slotLocYChanged(int)', 'slotLocZChanged(int)', 
+                        'slotRotationXChanged(int)', 'slotRotationYChanged(int)', 
+                        'slotRotationZChanged(int)', 'slotZoomChanged(int)'
+        
+    def initialize(parent)
+        super
+        @locAdjustors = []
+        @rotationAdjustors = []
+        @otherAdjustors = []
+        @avoidUpdates = false
+
+        @camera = World.instance.camera
+
+        # Remember values for reset
+        @origCamera = @camera.dup()
+
+        # Group and layout widgets
+        vLayout = Qt::VBoxLayout.new(self)
+
+        locBox = Qt::GroupBox.new('Location', self)
+        rotationBox = Qt::GroupBox.new('Rotation', self)
+        otherBox = Qt::GroupBox.new('Other', self)
+
+        locLayout = Qt::GridLayout.new(locBox)
+        rotationLayout = Qt::GridLayout.new(rotationBox)
+        otherLayout = Qt::GridLayout.new(otherBox)
+        buttonLayout = Qt::HBoxLayout.new()
+
+        vLayout.addWidget(locBox)
+        vLayout.addWidget(rotationBox)
+        vLayout.addWidget(otherBox)
+        vLayout.addSpacing(10)
+        vLayout.addLayout(buttonLayout)
+
+        # Add extra space at the top of each layout so the group box title
+        # doesn't get squished.
+#        locLayout.addRowSpacing(0, 15)
+#        rotationLayout.addRowSpacing(0, 15)
+#        otherLayout.addRowSpacing(0, 15)
+
+        # Contents of camera location box
+        @locAdjustors << addSlider(1, locBox, locLayout, 'X', -1000, 1000, 1,
+                                   'slotLocXChanged(int)', @camera.position.x)
+        @locAdjustors << addSlider(2, locBox, locLayout, 'Y', -1000, 1000, 1,
+                                   'slotLocYChanged(int)', @camera.position.y)
+        @locAdjustors << addSlider(3, locBox, locLayout, 'Z', -1000, 1000, 1,
+                                   'slotLocZChanged(int)', @camera.position.z)
+
+        # Contents of camera rotation box
+        @rotationAdjustors << addSlider(1, rotationBox, rotationLayout, 'X',
+                                        0, 360, 1, 'slotRotationXChanged(int)',
+                                   @camera.rotation.x)
+        @rotationAdjustors << addSlider(2, rotationBox, rotationLayout, 'Y',
+                                        0, 360, 1, 'slotRotationYChanged(int)',
+                                   @camera.rotation.y)
+        @rotationAdjustors << addSlider(3, rotationBox, rotationLayout, 'Z',
+                                        0, 360, 1, 'slotRotationZChanged(int)',
+                                   @camera.rotation.z)
+
+        @otherAdjustors <<  addSlider(1, otherBox, otherLayout, 'Zoom',
+                                      1, 100, 1, 'slotZoomChanged(int)',
+                                      @camera.zoom * 10.0)
+        @otherAdjustors[0].origValue = @camera.zoom
+
+        # The Close button
+        button = Qt::PushButton.new('Close', self)
+        connect(button, SIGNAL('clicked()'), self, SLOT('close()'))
+        button.setDefault(true)
+        button.setFixedSize(button.sizeHint())
+        buttonLayout.addWidget(button)
+
+        # The Close button
+        button = Qt::PushButton.new('Reset', self)
+        connect(button, SIGNAL('clicked()'), self, SLOT('slotReset()'))
+        button.setFixedSize(button.sizeHint())
+        buttonLayout.addWidget(button)
+
+        # 15 layout management
+        locLayout.activate()
+        rotationLayout.activate()
+        otherLayout.activate()
+        vLayout.activate()
+
+        resize(0, 0)
+
+        setWindowTitle('Camera Settings')
+    end
+
+    def addSlider(row, box, layout, label, min, max, pageStep, slot,
+                  initialValue)
+        # Label
+        text = Qt::Label.new(label, box)
+        text.setMinimumSize(text.sizeHint())
+        layout.addWidget(text, row, 0)
+
+        # Slider
+        slider = Qt::Slider.new(Qt::Horizontal, box) do |s|
+            s.range = min..max
+            s.sliderPosition = initialValue
+            s.pageStep = pageStep
+        end
+
+        slider.minimumSize = slider.sizeHint
+        slider.minimumWidth = 180
+
+        layout.addWidget(slider, row, 1)
+
+        # Connection from slider signal to our slot
+        connect(slider, SIGNAL('valueChanged(int)'), self, SLOT(slot))
+
+        # Number display
+        num = Qt::Label.new('XXXXX', box)
+        num.setMinimumSize(num.sizeHint())
+        num.setFrameStyle(Qt::Frame::Panel | Qt::Frame::Sunken)
+        num.setAlignment(Qt::AlignRight | Qt::AlignVCenter)
+        num.setNum(initialValue)
+
+        layout.addWidget(num, row, 2)
+
+        return Adjustor.new(slider, num, initialValue)
+    end
+
+    def cameraChanged
+        World.instance.setupTranslation() unless @avoidUpdates
+    end
+
+    def slotLocXChanged(val)
+        @locAdjustors[0].setNum(val)
+        @camera.position.x = val
+        cameraChanged()
+    end
+
+    def slotLocYChanged(val)
+        @locAdjustors[1].setNum(val)
+        @camera.position.y = val
+        cameraChanged()
+    end
+
+    def slotLocZChanged(val)
+        @locAdjustors[2].setNum(val)
+        @camera.position.z = val
+        cameraChanged()
+    end
+
+    def slotRotationXChanged(val)
+        @rotationAdjustors[0].setNum(val)
+        @camera.rotation.x = val
+        cameraChanged()
+    end
+
+    def slotRotationYChanged(val)
+        @rotationAdjustors[1].setNum(val)
+        @camera.rotation.y = val
+        cameraChanged()
+    end
+
+    def slotRotationZChanged(val)
+        @rotationAdjustors[2].setNum(val)
+        @camera.rotation.z = val
+        cameraChanged()
+    end
+
+    def slotZoomChanged(val)
+        @otherAdjustors[0].setNum(val)
+        @camera.zoom = val / 10.0
+        cameraChanged()
+    end
+
+    def slotReset
+        @avoidUpdates = true
+
+        @camera.position.x = @locAdjustors[0].reset()
+        @camera.position.y = @locAdjustors[1].reset()
+        @camera.position.z = @locAdjustors[2].reset()
+
+        @camera.rotation.x = @rotationAdjustors[0].reset()
+        @camera.rotation.y = @rotationAdjustors[1].reset()
+        @camera.rotation.z = @rotationAdjustors[2].reset()
+
+        @camera.zoom = @otherAdjustors[0].reset()
+        
+        @avoidUpdates = false
+        cameraChanged()
+    end
+
+end

data/examples/ruboids/ruboids/Canvas.rb

@@ -0,0 +1,143 @@
+#
+# Copyright (c) 2001 by Jim Menard <jimm@io.com>
+#
+# Released under the same license as Ruby. See
+# http://www.ruby-lang.org/en/LICENSE.txt.
+#
+
+require 'Qt'
+require 'opengl'
+require './World'
+require './Cloud'
+require './Flock'
+require './Params'
+require './Camera'
+
+include GL
+
+class Canvas < Qt::GLWidget
+
+    GRASS_COLOR = [0, 0.75, 0]
+    MDA_ROTATE = :MDA_ROTATE
+    MDA_ZOOM = :MDA_ZOOM
+    MDA_CHANGE_FOCUS = :MDA_CHANGE_FOCUS
+
+    def initialize(parent = nil, name = '')
+        super(parent)
+        @grassObject = nil
+    end
+
+    def update
+        updateGL()
+    end
+
+    def initializeGL()
+        ClearColor(0.4, 0.4, 1.0, 0.0) # Let OpenGL clear to light blue
+        @grassObject = makeGrassObject()
+        ShadeModel(FLAT)
+    end
+
+    def paintGL()
+        Enable(DEPTH_TEST)
+        Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT)
+
+        MatrixMode(MODELVIEW)
+
+        camera = World.instance.camera
+
+        LoadIdentity()
+        Rotate(camera.rotation.x, 1, 0, 0)
+        Rotate(camera.rotation.y, 0, 1, 0)
+        Rotate(camera.rotation.z, 0, 0, 1.0)
+        Translate(-camera.position.x, -camera.position.y, -camera.position.z)
+        Scale(camera.zoom, camera.zoom, camera.zoom)
+
+        CallList(@grassObject)
+
+        World.instance.clouds.each { | cloud | cloud.draw() }
+        World.instance.flock.draw()
+    end
+
+    # Set up the OpenGL view port, matrix mode, etc.
+    def resizeGL(w, h)
+        Viewport(0, 0, w, h)
+        MatrixMode(PROJECTION)
+        LoadIdentity()
+
+#          # left, right, bottom, top, front, back (focal_length)
+        halfXSize = $PARAMS['world_width'] / 2 * 1.25
+        halfYSize = $PARAMS['world_height'] / 2 * 1.25
+        halfZSize = $PARAMS['world_depth'] / 2 * 1.25
+
+#            Frustum(-halfXSize, halfXSize, -halfYSize, halfYSize,
+#                  5, halfZSize * 2)
+
+        Ortho(-halfXSize, halfXSize, -halfYSize, halfYSize,
+              -halfZSize, halfZSize)
+
+        MatrixMode(MODELVIEW)
+    end
+
+    def makeGrassObject
+        halfXSize = $PARAMS['world_width']
+        halfYSize = $PARAMS['world_depth'] / 2
+        halfZSize = $PARAMS['world_height']
+
+        list = GenLists(1)
+        NewList(list, COMPILE)
+        LineWidth(2.0)
+        Begin(QUADS)
+
+        Color(GRASS_COLOR)
+        # Counter-clockwise
+        Vertex( halfXSize, -halfYSize,  halfZSize)
+        Vertex(-halfXSize, -halfYSize,  halfZSize)
+        Vertex(-halfXSize, -halfYSize, -halfZSize)
+        Vertex( halfXSize, -halfYSize, -halfZSize)
+
+        End()
+        EndList()
+        return list
+    end
+
+    def mousePressEvent(e)
+        @mouseLoc = e.pos()
+        case e.button()
+        when Qt::LeftButton
+            @mouseDragAction = MDA_ZOOM
+        when Qt::RightButton
+            @mouseDragAction = MDA_ROTATE
+        when Qt::MidButton
+            @mouseDragAction = MDA_CHANGE_FOCUS
+        end
+    end
+
+    # Rotate around sphere with right (#2) button. Zoom with left button.
+    # Change focus with left button.
+    def mouseMoveEvent(e)
+        return if @mouseLoc.nil?
+
+        dx = dy = 0
+        if e.x() != @mouseLoc.x()
+            dx = e.x() - @mouseLoc.x() # move right increases dx
+            @mouseLoc.setX(e.x())
+        end
+        if e.y() != @mouseLoc.y()
+            dy = @mouseLoc.y() - e.y() # move up increases dy
+            @mouseLoc.setY(e.y())
+        end
+
+        return if dx == 0 && dy == 0
+
+        case @mouseDragAction
+        when MDA_ZOOM
+            return if (dy == 0)
+            World.instance.camera.zoom += 0.1 * -dy
+        when MDA_ROTATE
+            break
+        when MDA_CHANGE_FOCUS
+            break
+        end
+        World.instance.setupTranslation()
+    end
+end