qtruby4 2.1.0.b-mswin32 → 2.1.0-mswin32

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

data/examples/ruboids/ruboids/Cloud.rb

@@ -0,0 +1,61 @@
+#
+# 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 'Thing'
+require 'CloudView'
+require 'Params'
+
+class Bubble
+
+    attr_reader :loc, :radius, :color
+
+    def initialize
+	@radius = rand($PARAMS['cloud_max_bubble_radius']) + 1
+	@loc = Point.new(0, rand(8) - 4, rand(8) - 4)
+	c = 0.85 + rand() * 0.15
+	@color = [c, c, c]
+    end
+
+end
+
+
+class Cloud < Thing
+
+    attr_reader :speed, :bubbles, :width
+
+    def initialize
+	minSpeed = $PARAMS['cloud_min_speed']
+	minBubbles = $PARAMS['cloud_min_bubbles']
+	@speed = rand($PARAMS['cloud_max_speed'] - minSpeed) + minSpeed
+	numBubbles = rand($PARAMS['cloud_max_bubbles'] - minBubbles) +
+	    minBubbles
+	@bubbles = []
+	prevBubble = nil
+	(0 ... numBubbles).each { | i |
+	    bubble = Bubble.new()
+	    if !prevBubble.nil?
+		bubble.loc.x = prevBubble.loc.x +
+		    rand((prevBubble.radius + bubble.radius) * 0.66)
+	    end
+
+	    @bubbles[i] = prevBubble = bubble
+	}
+
+	@width = bubbles.last.loc.x +
+	    @bubbles.first.radius + @bubbles.last.radius
+
+	@view = CloudView.new(self)
+    end
+
+    def move
+	@position.x += pixelsPerSecToPixelsPerMove(speed)
+	halfWorldWidth = $PARAMS['world_width']
+	if (@position.x >=  halfWorldWidth / 2)
+	    @position.x = -(halfWorldWidth + @width)
+	end
+    end
+end

data/examples/ruboids/ruboids/CloudView.rb

@@ -0,0 +1,54 @@
+#
+# 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 'View'
+require 'Cloud'
+require 'Params'
+require 'World'
+require 'Graphics'
+
+class CloudView < View
+
+    def initialize(cloud)
+	super(cloud)
+    end
+
+    def makeObject
+	@object = GenLists(1)
+	NewList(@object, COMPILE)
+
+	@model.bubbles.each { | bubble |
+  	    Color(bubble.color)
+	    PushMatrix()
+	    Translate(bubble.loc.x, bubble.loc.y, bubble.loc.z)
+	    Scale(bubble.radius, bubble.radius, bubble.radius)
+	    Graphics.sphere()
+	    PopMatrix()
+	}
+
+	EndList()
+    end
+
+    def makeShadow
+	@shadow = GenLists(1)
+	NewList(@shadow, COMPILE)
+
+	groundLevel = -($PARAMS['world_height'] / 2) + 1
+	@model.bubbles.each { | bubble |
+  	    Color(shadowColorForHeight(model.position.y + bubble.loc.y))
+	    PushMatrix()
+	    Translate(bubble.loc.x, groundLevel, bubble.loc.z)
+	    Scale(bubble.radius, 1.0, bubble.radius)
+	    Graphics.circle(2)
+	    PopMatrix()
+	}
+
+	EndList()
+    end
+
+end