shattered_support 0.3.2 → 0.3.3

data/lib/vector.rb

@@ -1,206 +0,0 @@
-
-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
-  
-module ShatteredSupport #:nodoc:
-  # 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(&: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.kind_of?(Vector) && 
-      x == vector.x           && 
-      y == vector.y           &&
-      z == vector.z
-    end
-    
-  private
-    
-    def convert_args_to_vector(*args)
-      args.flatten!
-      if args.first.is_a? Vector
-        args.first
-      else
-        args.to_v
-      end
-    end
-    
-  end
-end