shattered_pack 0.4.0.1 → 0.5.0.1

data/lib/shattered_view/vector.rb

@@ -1,258 +0,0 @@
-class Object
-  # This is a shorthand to define vector object coordinates.
-  #
-  # Creates a vector object at coordinates x,y,z
-  def v(x, y, z) 
-    Vector.new(x, y, z) 
-  end
-end
-
-class SymbolToVectorError < StandardError #:nodoc:
-end
-
-class Symbol #:nodoc:
-  #  Vectors in symbol form can be any of the following:
-  #  :x => v(1,0,0)
-  #  :y => v(0,1,0)
-  #  :z => v(0,0,1),
-  #  :up => v(0,1,0)
-  #  :down => v(0,-1,0)
-  #  :left => v(-1,0,0)
-  #  :right => v(1,0,0)
-  #  :forward => v(0,0,1)
-  #  :backward => v(0,0,-1)
-  #  :zero => v(0,0,0)
-  def to_v
-    @definitions ||= {:x => v(1,0,0),:y => v(0,1,0),:z => v(0,0,1),
-                    :up => v(0,1,0),:down => v(0,-1,0),
-                    :left => v(-1,0,0),:right => v(1,0,0),
-                    :forward => v(0,0,1),:backward => v(0,0,-1),
-                    :zero => v(0,0,0)}
-    return @definitions[self] unless @definitions[self].nil?
-    raise SymbolToVectorError, "Undefined vector for symbol #{self}"
-  end
-  
-  # Multiplication defined for vectors carries over to their symbolic equivalence.
-  def *(number)
-    return to_v * number
-  end
-  
-  # Addition for vectors
-  def +(number)
-    return to_v + number
-  end
-end
-
-class Array #:nodoc:
-  # Vector extensions for array.  Allows for coersion of a 3 element Array into a vector.
-  
-  # Randomize the order of an array
-  #
-  #   [1, 2, 3].shuffle #=> [2, 3, 1]
-  #
-  def shuffle
-    sort_by {rand}
-  end
-  
-  # Create a vector from an array.
-  #
-  #   [1, 2, 3].to_v #=> same as Vector.new(1, 2, 3)
-  #
-  def to_v
-    raise StandardError, "vector #{self.inspect} does not have 3 elements" if self.length < 3
-    Vector.new self[0], self[1] ,self[2]
-  end
-  
-  # Returns this Array as an Ogre vector object: Vector3.  Should only be used internally by
-  # Shattered to communicate with the Ogre engine.
-  def to_v3
-    self.to_v.to_v3
-  end
-end
-  
-# Vector is a three dimensional array, that allows for various operations on itself.
-# To create a vector, use the shorthand:
-#   v(0,0,0) # Creates a zero vector
-class Vector
-	
-	attr_reader :x, :y, :z
-	
-	# Create a new Vector object.  It requires exactly 3 arguments: x, y and z.  Any value that
-	# can be converted to a float is acceptable.
-	#
-	# *NOTE:* The recomended way to create Vector objects is to use the <tt>v(1,2,3)</tt> shorthand.
-	def initialize(x_val, y_val, z_val)
-		@x, @y, @z = [x_val, y_val, z_val].collect{ |x| x.to_f }
-	end
-	
-	# Iterate through x, y and z with a block.  The passed value is the value of each component of 
-	# the vector.
-	def each(&block)
-		self.to_a.each do |component|
-			yield component
-		end
-	end
-	
-	# Returns this Vector as an Ogre vector object: Vector3.  Should only be used internally by
-	# Shattered to communicate with the Ogre engine.
-	def to_v3 # :nodoc:
-		ShatteredOgre::Vector3.new @x, @y, @z
-	end
-	
-	# Returns self
-	def to_v
-		self
-	end
-	
-	# Returns an array with x, y and z dumped into its elements.
-	#   v(1, 2, 3).to_a #=> [1.0, 2.0, 3.0]
-	def to_a
-		[@x, @y, @z]
-	end
-	
-	# Add 2 Vectors together.
-	#   v(1,1,1) + v(1,2,3) #=> v(2,3,4)
-	def +(*args)
-		vector = convert_args_to_vector(args)
-		Vector.new(
-			self.x + vector.x,
-			self.y + vector.y,
-			self.z + vector.z
-		)
-	end
-	
-	# Subtract one Vector from another.
-	#   v(1,2,3) - v(1,1,1) #=> v(0,1,2)
-	def -(args)
-		vector = convert_args_to_vector(args)
-		Vector.new(
-			self.x - vector.x,
-			self.y - vector.y,
-			self.z - vector.z
-		)
-	end
-	
-	# Multiply all components of a vector by a scalar amount.
-	#   v(1,2,3) * 3 #=> v(3,6,9)
-	def *(value)
-		result = []
-		each do |i|
-			result << i * value
-		end
-		result.to_v
-	end
-	
-	# Divide all components of a vector by a scalar amount
-	#   v(5,10,15) / 5 #=> v(1,2,3)
-	def /(value)
-		result = Array.new
-		self.each do |i|
-			result << i/value.to_f
-		end
-		result.to_v
-	end
-	
-	# Returns this Vector but normalized to a length of 1.
-	#   v(9, 0, 0).normalize #=> v(1,0,0)
-	def normalize
-		self * (1 / length)
-	end
-	alias_method :normalise, :normalize
-	
-	# Same as #normalize but modifies the receiver in place.
-	def normalize!
-		@x, @y, @z = normalize.to_a
-	end
-	alias_method :normalise!, :normalize!
-	
-	# Return the value specified by bracket notation.  Integers, Symbols or Strings
-	# are accepted as keys.
-	#   
-	#   vector = v(1,2,3)
-	#   vector[:x]  #=> 1
-	#   vector['y'] #=> 2
-	#   vector[2]   #=> 3
-	def [](index)
-		case
-			when index == 0 || index == :x || index == 'x'
-				@x
-			when index == 1 || index == :y || index == 'y'
-				@y
-			when index == 2 || index == :z || index == 'z'
-				@z
-		end
-	end
-	
-	# Set the value specified by bracket notation.  Accepts the same keys as the #[] 
-	# method.
-	def []=(index, value)
-		case
-			when index == 0 || index == :x || index == 'x'
-				@x = value.to_f
-			when index == 1 || index == :y || index == 'y'
-				@y = value.to_f
-			when index == 2 || index == :z || index == 'z'
-				@z = value.to_f
-		end
-	end
-	
-	# Set the value of the X component.
-	def x=(value)
-		@x = value.to_f
-	end
-	
-	# Set the value of the Y component.
-	def y=(value)
-		@y = value.to_f
-	end
-	
-	# Set the value of the Z component.
-	def z=(value)
-		@z = value.to_f
-	end
-	
-	
-	# Returns the length of this vector.
-	#   v(0,0,7).length #=> 7
-	def length
-		Math.sqrt(x**2 + y**2 + z**2)
-	end
-	
-	# Converts the vector into an easily identifiable form.  Mostly used for debugging
-	# and console output.
-	#   v(1,2,3).to_s #=> "#<Vector [1.0, 2.0, 3.0]>"
-	def to_s
-		"#<Vector [#@x, #@y, #@z]>"
-	end
-	
-	# Equality test.  This method will return true if all components of both vectors are
-	# indentical.
-	def ==(vector)
-	  vector = vector.to_v if vector.is_a?(Symbol)
-		vector.kind_of?(Vector) && 
-		x == vector.x           && 
-		y == vector.y           &&
-		z == vector.z
-	end
-	
-	# Create a unique identifier based on x, y and z.
-	def hash
-	  return self.to_a.hash
-  end
-  
-  # Equality test for hash indexes.
-  def eql?(other)
-    return self.to_a.eql?(other.to_a)
-  end
-	
-private
-	
-	def convert_args_to_vector(*args)
-		args.flatten!
-		if(args.first.is_a?(Vector) || args.first.is_a?(Symbol))
-			args.first.to_v
-		else
-			args.to_v
-		end
-	end
-end