qtruby4 2.1.0.b-mswin32 → 2.1.0-mswin32

data/examples/ruboids/ruboids/Flock.rb

@@ -0,0 +1,47 @@
+#
+# 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 'Flock'
+require 'Boid'
+require 'Params'
+
+class Flock
+    attr_reader :members
+
+    def initialize
+	@members = []
+    end
+
+    def add(boid)
+	@members << boid
+	boid.flock = self
+    end
+
+    def draw
+	@members.each { | boid | boid.draw() }
+    end
+
+    def move
+	@members.each { | boid | boid.move() }
+    end
+
+    # Return distance between two boid's positions.
+    def distBetween(b1, b2)
+	return b1.position.distanceTo(b2.position)
+    end
+
+    # Center of mass
+    def centerExcluding(b)
+	p = Point.new()
+	@members.each { | boid |
+	    p.addPoint(boid.position) unless boid == b
+	}
+	p.divideBy(@members.length - 1)
+	return p
+    end
+end
+

data/examples/ruboids/ruboids/Graphics.rb

@@ -0,0 +1,278 @@
+#
+# 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 'Triangle'
+
+class Graphics
+
+    DEFAULT_SPHERE_ITERATIONS = 3
+
+    XPLUS = Point.new(1, 0, 0)	# X
+    XMINUS = Point.new(-1, 0, 0)# -X
+    YPLUS = Point.new(0, 1, 0)	# Y
+    YMINUS = Point.new(0, -1, 0)# -Y
+    ZPLUS = Point.new(0, 0, 1)	# Z
+    ZMINUS = Point.new(0, 0, -1)# -Z
+
+    # defined w/counter-clockwise triangles
+    OCTAHEDRON = [
+	Triangle.new(YPLUS, ZPLUS, XPLUS),
+	Triangle.new(XMINUS, ZPLUS, YPLUS),
+	Triangle.new(YMINUS, ZPLUS, XMINUS),
+	Triangle.new(XPLUS, ZPLUS, YMINUS),
+	Triangle.new(ZMINUS, YPLUS, XPLUS),
+	Triangle.new(ZMINUS, XMINUS , YPLUS),
+	Triangle.new(ZMINUS, YMINUS , XMINUS),
+	Triangle.new(ZMINUS, XPLUS, YMINUS)
+    ]
+    # Defines counter-clockwise points used in OpenGL TRIANGLE_STRIP to
+    # create a circle on the X/Z plane. Don't include center point here;
+    # It is added when outputting the circle.
+    SQUARE = [
+	XPLUS, ZMINUS, XMINUS, ZPLUS, XPLUS
+    ]
+
+    @@spheres = Hash.new()
+    @@circles = Hash.new()
+
+    def Graphics.radiansToDegrees(rad)
+	return rad * 180.0 / Math::PI
+    end
+
+    def Graphics.degreesToRadians(deg)
+	return deg * Math::PI / 180.0
+    end
+
+    # Given a vector, return a point containing x, y, z rotation angles.
+    #
+    # atan2(x, y) = the angle formed with the x axis by the ray from the
+    # origin to the point {x,y}
+    def Graphics.rotations(v)
+	return Point::ORIGIN.dup() if v.nil?
+	return v if v == Point::ORIGIN
+
+	x = Math.atan2(v.y, v.z)
+	y = Math.atan2(v.z, v.x)
+	z = Math.atan2(v.y, v.x)
+
+	rot = Point.new(z, x, y)
+	rot.add(Math::PI).multiplyBy(180.0).divideBy(Math::PI)
+
+	rot.x = rot.x.to_i
+	rot.y = rot.y.to_i
+	rot.z = rot.z.to_i
+
+	return rot
+    end
+
+    # Build box from corners. All faces are counter-clockwise.
+    def Graphics.boxFromCorners(p0, p1)
+	pa = p0.dup()
+	pb = p1.dup()
+
+	# Make sure all coords of pa are < all coords of pb
+	if pa.x > pb.x
+	    tmp = pa.x; pa.x = pb.x; pb.x = tmp
+	end
+	if pa.y > pb.y
+	    tmp = pa.y; pa.y = pb.y; pb.y = tmp
+	end
+	if pa.z > pb.z
+	    tmp = pa.z; pa.z = pb.z; pb.z = tmp
+	end
+
+	Begin(QUAD_STRIP)
+
+	# top
+	Vertex(pb.x, pb.y, pa.z)
+	Vertex(pa.x, pb.y, pa.z)
+	# top/front
+	Vertex(pb.x, pb.y, pb.z)
+	Vertex(pa.x, pb.y, pb.z)
+	# front/bottom
+	Vertex(pb.x, pa.y, pb.z)
+	Vertex(pa.x, pa.y, pb.z)
+	# bottom/back
+	Vertex(pb.x, pa.y, pa.z)
+	Vertex(pa.x, pa.y, pa.z)
+	# back/top
+	Vertex(pb.x, pb.y, pa.z)
+	Vertex(pa.x, pb.y, pa.z)
+
+	End()
+
+	Begin(QUADS)
+
+	# left
+	Vertex(pa.x, pa.y, pb.z)
+	Vertex(pa.x, pa.y, pa.z)
+	Vertex(pa.x, pb.y, pa.z)
+	Vertex(pa.x, pb.y, pb.z)
+
+	# right
+	Vertex(pb.x, pa.y, pb.z)
+	Vertex(pb.x, pa.y, pa.z)
+	Vertex(pb.x, pb.y, pa.z)
+	Vertex(pb.x, pb.y, pb.z)
+
+	End()
+    end
+
+    # sphere() (and buildSphere()) - generate a triangle mesh approximating
+    # a sphere by recursive subdivision. First approximation is an
+    # octahedron; each level of refinement increases the number of
+    # triangles by a factor of 4.
+    #
+    # Level 3 (128 triangles) is a good tradeoff if gouraud shading is used
+    # to render the database.
+    #
+    # Usage: sphere [level] [counterClockwise]
+    #
+    #	The value level is an integer >= 1 setting the recursion level
+    #		(default = DEFAULT_SPHERE_ITERATIONS).
+    #	The boolean counterClockwise causes triangles to be generated
+    #		with vertices in counterclockwise order as viewed from
+    #		the outside in a RHS coordinate system. The default is
+    #		counter-clockwise.
+    #
+    # @author Jon Leech (leech@cs.unc.edu) 3/24/89 (C version)
+    # Ruby version by Jim Menard (jimm@io.com), May 2001.
+    def Graphics.sphere(iterations = DEFAULT_SPHERE_ITERATIONS,
+			counterClockwise = true)
+	if @@spheres[iterations].nil?
+	    @@spheres[iterations] = buildSphere(iterations, OCTAHEDRON)
+	end
+	sphere = @@spheres[iterations] 
+	
+	Begin(TRIANGLES)
+	sphere.each { | triangle |
+	    triangle.points.each { | p |
+		Vertex(p.x, p.y, p.z) if counterClockwise
+		Vertex(p.z, p.y, p.x) if !counterClockwise
+	    }
+	}
+	End()
+    end
+
+    #
+    # Subdivide each triangle in the oldObj approximation and normalize
+    #  the new points thus generated to lie on the surface of the unit
+    #  sphere.
+    # Each input triangle with vertices labelled [0,1,2] as shown
+    #  below will be turned into four new triangles:
+    #
+    #                        Make new points
+    #                                a = (0+2)/2
+    #                                b = (0+1)/2
+    #                                c = (1+2)/2
+    #          1
+    #         /\             Normalize a, b, c
+    #        /  \
+    #      b/____\ c         Construct new counter-clockwise triangles
+    #      /\    /\                  [a,b,0]
+    #     /  \  /  \                 [c,1,b]
+    #    /____\/____\                [c,b,a]
+    #   0      a     2               [2,c,a]
+    #
+    #
+    # The normalize step (which makes each point a, b, c unit distance
+    # from the origin) is where we can modify the sphere's shape.
+    #
+    def Graphics.buildSphere(iterations, sphere)
+	oldObj = sphere
+	# Subdivide each starting triangle (maxlevel - 1) times
+	iterations -= 1
+	iterations.times {
+	    # Create a new object. Allocate 4 * the number of points in the
+	    # the current approximation.
+	    newObj = Array.new(oldObj.length * 4)
+
+	    j = 0
+	    oldObj.each { | oldt |
+		# New midpoints
+		a = Point.midpoint(oldt.points[0], oldt.points[2])
+		a.normalize!()
+		b = Point.midpoint(oldt.points[0], oldt.points[1])
+		b.normalize!()
+		c = Point.midpoint(oldt.points[1], oldt.points[2])
+		c.normalize!()
+
+		# New triangeles. Their vertices are counter-clockwise.
+		newObj[j] = Triangle.new(a, b, oldt.points[0])
+		j += 1
+		newObj[j] = Triangle.new(c, oldt.points[1], b)
+		j += 1
+		newObj[j] = Triangle.new(c, b, a)
+		j += 1
+		newObj[j] = Triangle.new(oldt.points[2], c, a)
+		j += 1
+	    }
+
+	    # Continue subdividing new triangles
+	    oldObj = newObj
+	}
+	return oldObj
+    end
+
+    # Creates a circle in the X/Z plane. To have the circle's normal
+    # point down (-Y), specify clockwise instead of counter-clockwise.
+    # To create the circle in another plane, call OpenGL's Rotate() method
+    # before calling this.
+    def Graphics.circle(iterations = DEFAULT_SPHERE_ITERATIONS,
+			counterClockwise = true)
+	if @@circles[iterations].nil?
+	    @@circles[iterations] = buildCircle(iterations, SQUARE)
+	end
+	circle = @@circles[iterations] 
+	
+	Begin(TRIANGLE_FAN)
+	Vertex(0, 0, 0)
+	if counterClockwise
+	    circle.each { | p | Vertex(p.x, 0, p.z) }
+	else
+	    circle.reverse.each { | p | Vertex(p.x, 0, p.z) }
+	end
+	End()
+    end
+
+    # Different than buildSphere because we are creating triangles to
+    # be used in an OpenGL TRIANGLE_FAN operation. Thus the first point
+    # (the center) is always inviolate. We create new points between
+    # the remaining points.
+    def Graphics.buildCircle(iterations, circle)
+	oldObj = circle
+	# Subdivide each starting line segment (maxlevel - 1) times
+	iterations -= 1
+	iterations.times {
+	    # Create a new object. Allocate 2 * the number of points in the
+	    # the current approximation. Subtract one because the last point
+	    # (same as the first point) is simply copied.
+	    newObj = Array.new(oldObj.length * 2 - 1)
+
+	    prevP = nil
+	    j = 0
+	    oldObj.each { | p |
+		if !prevP.nil?
+		    newObj[j] = prevP
+		    j += 1
+
+		    # New midpoint
+		    a = Point.midpoint(prevP, p)
+		    a.normalize!()
+		    newObj[j] = a
+		    j += 1
+		end
+		prevP = p
+	    }
+	    newObj[j] = prevP	# Copy last point
+
+	    # Continue subdividing new triangles
+	    oldObj = newObj
+	}
+	return oldObj
+    end
+end

data/examples/ruboids/ruboids/Params.rb

@@ -0,0 +1,87 @@
+#
+# 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 'singleton'
+
+$PARAMS = {
+    'world_sleep_millis' => 75,
+    'world_width' => 400,
+    'world_height' => 400,
+    'world_depth' => 400,
+    'window_width' => 500,
+    'window_height' => 500,
+    'flock_boids' => 10,
+    'boid_max_speed' => 30,
+    'boid_bounds_limit_pull' => 5,
+    'boid_bounds_limit_above_ground_level' => 5,
+    'boid_wing_length' => 10,
+    'boid_personal_space_dist' => 12,
+    'boid_square_of_personal_space_dist' => 144,
+    'boid_max_perching_turns' => 150,
+    'boid_perch_wing_flap_percent' => 30,
+    'cloud_count' => 10,
+    'cloud_min_speed' => 2,
+    'cloud_max_speed' => 50,
+    'cloud_min_bubbles' => 3,
+    'cloud_max_bubbles' => 10,
+    'cloud_max_bubble_radius' => 10,
+    'cloud_min_altitude' => 250,
+    'camera_x' => 0,
+    'camera_y' => 0,
+    'camera_z' => 60,
+    'camera_rot_x' => 50,
+    'camera_rot_y' => 10,
+    'camera_rot_z' => 0,
+    'camera_zoom' => 1
+}
+
+class Params
+
+    @@reals = %w(
+world_width
+world_height
+world_depth
+boid_max_speed
+boid_bounds_limit_pull
+boid_bounds_limit_above_ground_level
+boid_wing_length
+boid_personal_space_dist
+boid_square_of_personal_space_dist
+cloud_min_speed
+cloud_max_speed
+cloud_max_bubble_radius
+cloud_min_altitude
+camera_x
+camera_y
+camera_z
+camera_rot_x
+camera_rot_y
+camera_rot_z
+camera_zoom
+)
+
+    def Params.readParamsFromFile(paramFileName)
+	File.open(paramFileName).each { | line |
+	    line.chomp!
+	    next if line.empty? || line =~ /^#/
+
+	    key, value = line.split(/\s*=\s*/)
+	    next unless value
+	    key.downcase!()
+	    key.gsub!(/\./, '_')
+
+	    isReal = @@reals.include?(key)
+	    value = value.to_f if isReal
+	    value = value.to_i if !isReal
+	    $PARAMS[key] = value
+	}
+	$PARAMS['boid_square_of_personal_space_dist'] =
+	    $PARAMS['boid_personal_space_dist'] *
+	    $PARAMS['boid_personal_space_dist']
+    end
+
+end

data/examples/ruboids/ruboids/Point.rb

@@ -0,0 +1,153 @@
+#
+# 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.
+#
+
+class Point
+
+    attr_accessor :x, :y, :z
+
+    # Return a new Point that is the midpoint on the line between two
+    # points.
+    def Point.midpoint(a, b)
+	return Point.new((a.x + b.x) * 0.5, (a.y + b.y) * 0.5,
+			   (a.z + b.z) * 0.5)
+    end
+
+    def initialize(x = 0, y = 0, z = 0)
+	if x.kind_of?(Point)
+	    @x = x.x
+	    @y = x.y
+	    @z = x.z
+	else
+	    @x = x
+	    @y = y
+	    @z = z
+	end
+    end
+
+    ORIGIN = Point.new(0, 0, 0)
+
+    def ==(point)
+	return point.kind_of?(Point) &&
+	    @x == point.x && @y == point.y && @z == point.z
+    end
+
+    # Normalize this point.
+    def normalize!
+	mag = @x * @x + @y * @y + @z * @z
+	if mag != 1.0
+	    mag = 1.0 / Math.sqrt(mag)
+	    @x *= mag
+	    @y *= mag
+	    @z *= mag
+	end
+	return self
+    end
+
+    # Return a new point that is a normalized version of this point.
+    def normalize
+	return self.dup().normalize!()
+    end
+
+    # Return a new point that is the cross product of this point and another.
+    # The cross product of two unit vectors is another vector that's at
+    # right angles to the first two (for example, a surface normal).
+    def crossProduct(p)
+	return Point.new(@y * p.z - @z * p.y, @z * p.x - @x * p.z,
+			 @x * p.y - @y * p.x)
+    end
+
+    # Return the (scalar) dot product of this vector and another.
+    # The dot product of two vectors produces the cosine of the angle
+    # between them, multiplied by the lengths of those vectors. (The dot
+    # product of two normalized vectors equals cosine of the angle.)
+    def dotProduct(p)
+	return @x * p.x + @y * p.y + @z * p.z
+    end
+
+    # Return square of distance between this point and another.
+    def squareOfDistanceTo(p)
+	dx = p.x - @x
+	dy = p.y - @y
+	dz = p.z - @z
+	return dx * dx + dy * dy + dz * dz
+    end
+
+    # Return distance between this point and another.
+    def distanceTo(p)
+	dx = p.x - @x
+	dy = p.y - @y
+	dz = p.z - @z
+	return Math.sqrt(dx * dx + dy * dy + dz * dz)
+    end
+
+    def add(d)
+	@x += d
+	@y += d
+	@z += d
+	return self
+    end
+
+    def addPoint(p)
+	@x += p.x
+	@y += p.y
+	@z += p.z
+	return self
+    end
+
+
+    def subtract(d)
+	@x -= d
+	@y -= d
+	@z -= d
+	return self
+    end
+
+    def subtractPoint(p)
+	@x -= p.x
+	@y -= p.y
+	@z -= p.z
+	return self
+    end
+
+
+    def multiplyBy(d)
+	@x *= d
+	@y *= d
+	@z *= d
+	return self
+    end
+
+    def multiplyByPoint(p)
+	@x *= p.x
+	@y *= p.y
+	@z *= p.z
+	return self
+    end
+
+    def divideBy(d)
+	@x = @x / d
+	@y = @y / d
+	@z = @z / d
+	return self
+    end
+
+    def divideByPoint(p)
+	@x = @x / p.x
+	@y = @y / p.y
+	@z = @z / p.z
+	return self
+    end
+
+    def to_a
+	return [@x, @y, @z]
+    end
+
+    def to_s
+	return "Point<#{@x}, #{@y}, #{@z}>"
+    end
+
+end