gosling 1.0.0 → 2.0.0

data/lib/gosling/collision.rb

@@ -1,8 +1,31 @@
 require 'singleton'
 
+require_relative 'utils.rb'
+
 module Gosling
+  ##
+  # Very basic 2D collision detection. It is naive to where actors were during the last physics step or how fast they are
+  # moving. But it does a fine job of detecting collisions between actors in their present state.
+  #
+  # Keep in mind that Actors and their subclasses each have their own unique shapes. Actors, by themselves, have no
+  # shape and will never collide with anything. To see collisions in action, you'll need to use Circle, Polygon, or
+  # something else that has an actual shape.
+  #
+
   class Collision
-    # 11.4 - 6.7 (get_separation_axes) - 4.7 (project_onto_axis)
+    include Singleton
+
+    ##
+    # Tests two Actors or child classes to see whether they overlap. Actors, having no shape, never overlap. Child
+    # classes use appropriate algorithms based on their shape.
+    #
+    # Arguments:
+    # - shapeA: an Actor
+    # - shapeB: another Actor
+    #
+    # Returns:
+    # - true if the actors' shapes overlap, false otherwise
+    #
     def self.test(shapeA, shapeB)
       return false if shapeA.instance_of?(Actor) || shapeB.instance_of?(Actor)
 
@@ -19,8 +42,19 @@ module Gosling
       return true
     end
 
+    ##
+    # Tests a point in space to see whether it is inside the actor's shape or not.
+    #
+    # Arguments:
+    # - point: a Snow::Vec3
+    # - shape: an Actor
+    #
+    # Returns:
+    # - true if the point is inside of the actor's shape, false otherwise
+    #
     def self.is_point_in_shape?(point, shape)
-      raise ArgumentError.new("Collision.get_normal() requires a point and an actor") unless point.is_a?(Vector) && point.size == 3 && shape.is_a?(Actor)
+      type_check(point, Snow::Vec3)
+      type_check(shape, Actor)
 
       return false if shape.instance_of?(Actor)
 
@@ -34,24 +68,24 @@ module Gosling
 
       separation_axes.each do |axis|
         shape_projection = project_onto_axis(shape, axis)
-        point_projection = point.inner_product(axis)
+        point_projection = point.dot_product(axis)
         return false unless shape_projection.min <= point_projection && point_projection <= shape_projection.max
       end
 
       return true
     end
 
-    def self.get_normal(vector)
-      raise ArgumentError.new("Collision.get_normal() requires a length 3 vector") unless vector.is_a?(Vector) && vector.size == 3
-      raise ArgumentError.new("Cannot determine normal of zero-length vector") if vector.magnitude == 0
+    private
 
-      Vector[-vector[1], vector[0], 0]
+    def self.get_normal(vector)
+      type_check(vector, Snow::Vec3)
+      raise ArgumentError.new("Cannot determine normal of zero-length vector") if vector.magnitude_squared == 0
+      Snow::Vec3[-vector[1], vector[0], 0]
     end
 
     def self.get_polygon_separation_axes(vertices)
-      unless vertices.is_a?(Array) && vertices.reject { |v| v.is_a?(Vector) && v.size == 3 }.empty?
-        raise ArgumentError.new("Collission.get_polygon_separation_axes() expects an array of vectors similar to that produced by Polygon.get_vertices")
-      end
+      type_check(vertices, Array)
+      vertices.each { |v| type_check(v, Snow::Vec3) }
 
       axes = (0...vertices.length).map do |i|
         axis = vertices[(i + 1) % vertices.length] - vertices[i]
@@ -61,14 +95,12 @@ module Gosling
     end
 
     def self.get_circle_separation_axis(circleA, circleB)
-      unless circleA.is_a?(Actor) && circleB.is_a?(Actor)
-        raise ArgumentError.new("Collision.get_circle_separation_axis() expects two circles")
-      end
+      type_check(circleA, Actor)
+      type_check(circleB, Actor)
       axis = circleB.get_global_position - circleA.get_global_position
       (axis.magnitude > 0) ? axis.normalize : nil
     end
 
-    # 4.8 - 2.6 - 1.6 - .4
     def self.get_separation_axes(shapeA, shapeB)
       unless shapeA.is_a?(Actor) && !shapeA.instance_of?(Actor)
         raise ArgumentError.new("Expected a child of the Actor class, but received #{shapeA.inspect}!")
@@ -98,25 +130,28 @@ module Gosling
     end
 
     def self.project_onto_axis(shape, axis)
-      raise ArgumentError.new("Expected Actor, but received #{shape.inspect}!") unless shape.is_a?(Actor)
-      raise ArgumentError.new("Expected Vector, but received #{shape.inspect}!") unless axis.is_a?(Vector)
+      type_check(shape, Actor)
+      type_check(axis, Snow::Vec3)
 
       global_vertices = if shape.instance_of?(Circle)
         global_tf = shape.get_global_transform
-        local_axis = global_tf.inverse * Vector[axis[0], axis[1], 0]
+        local_axis = global_tf.inverse * Snow::Vec3[axis[0], axis[1], 0]
         v = shape.get_point_at_angle(Math.atan2(local_axis[1], local_axis[0]))
         [v, v * -1].map { |vertex| Transform.transform_point(global_tf, vertex) }
       else
         shape.get_global_vertices
       end
 
-      projections = global_vertices.map { |vertex| vertex.inner_product(axis) }.sort
+      projections = global_vertices.map { |vertex| vertex.dot_product(axis) }.sort
       [projections.first, projections.last]
     end
 
     def self.projections_overlap?(a, b)
-      raise ArgumentError.new("Collision.projections_overlap?() expects arrays") unless a.is_a?(Array) && b.is_a?(Array)
-      raise ArgumentError.new("Collision.projections_overlap?() projection arrays must be length 2") unless a.length == 2 && b.length == 2
+      type_check(a, Array)
+      type_check(b, Array)
+      a.each { |x| type_check(x, Numeric) }
+      b.each { |x| type_check(x, Numeric) }
+      raise ArgumentError.new("Expected two arrays of length 2, but received #{a.inspect} and #{b.inspect}!") unless a.length == 2 && b.length == 2
 
       a.sort! if a[0] > a[1]
       b.sort! if b[0] > b[1]

data/lib/gosling/image_library.rb

@@ -1,11 +1,18 @@
 require 'singleton'
 
 module Gosling
+  ##
+  # A cached Gosu::Image repository.
+  #
   class ImageLibrary
     @@cache = {}
 
     include Singleton
 
+    ##
+    # When passed the path to an image, it first checks to see if that image is in the cache. If so, it returns the cached
+    # Gosu::Image. Otherwise, it loads the image, stores it in the cache, and returns it.
+    #
     def self.get(filename)
       raise ArgumentError.new("File not found: '#{filename}' in '#{Dir.pwd}'") unless File.exists?(filename)
       unless @@cache.has_key?(filename)

data/lib/gosling/patches.rb

@@ -0,0 +1,42 @@
+require 'snow-math'
+
+module Snow
+  class Mat3
+    ##
+    # Monkey-patch fix for Mat3 * Vec3
+    #
+    def multiply(rhs, out = nil)
+      case rhs
+      when ::Snow::Mat3
+        multiply_mat3(rhs, out)
+      when ::Snow::Vec3
+        values = (0..2).map { |i| get_row3(i) ** rhs }
+        out ||= Snow::Vec3.new
+        out.set(values)
+      when Numeric
+        scale(rhs, rhs, rhs, out)
+      else
+        raise TypeError, "Invalid type for RHS"
+      end
+    end
+    alias_method :*, :multiply
+
+    ##
+    # Monkey-patch fix for #multiply! type-switching
+    #
+    def multiply!(rhs)
+      multiply rhs, case rhs
+                    when ::Snow::Mat3, Numeric then self
+                    when ::Snow::Vec3 then rhs
+                    else raise TypeError, "Invalid type for RHS"
+                    end
+    end
+
+    ##
+    # Returns true if this Mat3 is an identity matrix.
+    #
+    def identity?
+      [1, 2, 3, 5, 6, 7].all? { |i| self[i] == 0 } && [0, 4, 8].all? { |i| self[i] == 1 }
+    end
+  end
+end

data/lib/gosling/polygon.rb

@@ -1,35 +1,67 @@
 require_relative 'actor.rb'
 require_relative 'collision.rb'
+require_relative 'utils.rb'
 
 module Gosling
+  ##
+  # A Polygon is an Actor with a shape defined by three or more vertices. Can be used to make triangles, hexagons, or
+  # any other unusual geometry not covered by the other Actors. For circles, you should use Circle. For squares or
+  # rectangles, see Rect.
+  #
   class Polygon < Actor
+    ##
+    # Creates a new, square Polygon with a width and height of 1.
+    #
     def initialize(window)
+      type_check(window, Gosu::Window)
       super(window)
       @vertices = [
-        Vector[0, 0, 0],
-        Vector[1, 0, 0],
-        Vector[1, 1, 0],
-        Vector[0, 1, 0]
+        Snow::Vec3[0, 0, 0],
+        Snow::Vec3[1, 0, 0],
+        Snow::Vec3[1, 1, 0],
+        Snow::Vec3[0, 1, 0]
       ]
     end
 
+    ##
+    # Returns a copy of this Polygon's vertices (@vertices is read-only).
+    #
     def get_vertices
       @vertices.dup
     end
 
+    ##
+    # Sets this polygon's vertices. Requires three or more Snow::Vec3.
+    #
+    # Usage:
+    # - polygon.set_vertices([Snow::Vec3[-1, 0, 0], Snow::Vec3[0, -1, 0], Snow::Vec3[1, 1, 0]])
+    #
     def set_vertices(vertices)
-      unless vertices.is_a?(Array) && vertices.length >= 3 && vertices.reject { |v| v.is_a?(Vector) && v.size == 3 }.empty?
-        raise ArgumentError.new("set_vertices() expects an array of at least three 3D Vectors")
-      end
+      type_check(vertices, Array)
+      raise ArgumentError.new("set_vertices() expects an array of at least three 3D Vectors") unless vertices.length >= 3
+      vertices.each { |v| type_check(v, Snow::Vec3) }
       @vertices.replace(vertices)
     end
 
+    ##
+    # Returns an array containing all of our local vertices transformed to global-space. (See Actor#get_global_transform.)
+    #
     def get_global_vertices
       tf = get_global_transform
       @vertices.map { |v| Transform.transform_point(tf, v) }
     end
 
+    ##
+    # Returns true if the point is inside of this Polygon, false otherwise.
+    #
+    def is_point_in_bounds(point)
+      Collision.is_point_in_shape?(point, self)
+    end
+
+    private
+
     def render(matrix)
+      type_check(matrix, Snow::Mat3)
       global_vertices = @vertices.map { |v| Transform.transform_point(matrix, v) }
       i = 2
       while i < global_vertices.length
@@ -44,9 +76,5 @@ module Gosling
         i += 1
       end
     end
-
-    def is_point_in_bounds(point)
-      Collision.is_point_in_shape?(point, self)
-    end
   end
 end

data/lib/gosling/rect.rb

@@ -1,9 +1,16 @@
 require_relative 'polygon.rb'
 
 module Gosling
+  ##
+  # A Rect is a Polygon with exactly four vertices, defined by a width and height, with sides at right angles to one
+  # another. The width and height can be modified at runtime; all vertices will be updated automatically.
+  #
   class Rect < Polygon
     attr_reader :width, :height
 
+    ##
+    # Creates a new Rect with a width and height of 1.
+    #
     def initialize(window)
       super(window)
       @width = 1
@@ -23,12 +30,14 @@ module Gosling
       rebuild_vertices
     end
 
+    private
+
     def rebuild_vertices
       vertices = [
-        Vector[     0,       0, 0],
-        Vector[@width,       0, 0],
-        Vector[@width, @height, 0],
-        Vector[     0, @height, 0],
+        Snow::Vec3[     0,       0, 0],
+        Snow::Vec3[@width,       0, 0],
+        Snow::Vec3[@width, @height, 0],
+        Snow::Vec3[     0, @height, 0],
       ]
       set_vertices(vertices)
     end

data/lib/gosling/sprite.rb

@@ -1,6 +1,12 @@
 require_relative 'rect.rb'
 
 module Gosling
+  ##
+  # This type of Actor accepts a Gosu::Image to be rendered in place of the standard flat-colored shape. It behaves very
+  # much like a Rect, except its width and height are automatically set to the width and height of the image given to it
+  # and cannot be modified otherwise. The image can be changed at runtime. Changing this actor's color or alpha
+  # applies tinting and transparency to the image rendered.
+  #
   class Sprite < Rect
     def initialize(window)
       super(window)
@@ -8,10 +14,16 @@ module Gosling
       @color = Gosu::Color.rgba(255, 255, 255, 255)
     end
 
+    ##
+    # Returns the image currently assigned to this Sprite.
+    #
     def get_image
       @image
     end
 
+    ##
+    # Assigns the image to this Sprite, setting its width and height to match the image's.
+    #
     def set_image(image)
       raise ArgumentError.new("Expected Image, but received #{image.inspect}!") unless image.is_a?(Gosu::Image)
       @image = image
@@ -19,6 +31,8 @@ module Gosling
       self.height = @image.height
     end
 
+    private
+
     def render(matrix)
       global_vertices = @vertices.map { |v| Transform.transform_point(matrix, v) }
       @image.draw_as_quad(

data/lib/gosling/transform.rb

@@ -1,116 +1,22 @@
-require 'matrix'
+require 'snow-math'
 
-module Gosling
-  class FastMatrix
-    @@multiply_buffer = []
-    @@cache = []
-
-    attr_reader :array
-    attr_accessor :row_count, :column_count
-
-    private
-
-    def initialize
-      @array = nil
-      reset
-    end
-
-    public
-
-    def self.create
-      if @@cache.empty?
-        FastMatrix.new
-      else
-        @@cache.pop.reset
-      end
-    end
-
-    def destroy
-      reset
-      @@cache.push(self)
-      nil
-    end
-
-    def reset
-      if @array
-        @array.clear
-      else
-        @array = []
-      end
-      @row_count = 0
-      @column_count = 0
-      self
-    end
-
-    def copy_from(matrix)
-      if matrix.is_a?(Matrix)
-        @array = matrix.to_a.flatten
-        @row_count = matrix.row_size
-        @column_count = matrix.column_size
-      elsif matrix.is_a?(FastMatrix)
-        @array = matrix.array
-        @row_count = matrix.row_count
-        @column_count = matrix.column_count
-      else
-        raise ArgumentError.new("Cannot copy from #{matrix.inspect}!")
-      end
-      self
-    end
-
-    def to_matrix
-      rows = (0...@row_count).map do |i|
-        @array[(@column_count * i)...(@column_count * (i + 1))]
-      end
-      Matrix.rows(rows)
-    end
-
-    def fast_multiply(mat2, result = nil)
-      raise ArgumentError.new() unless mat2.is_a?(FastMatrix) && result.is_a?(FastMatrix)
-      Matrix.Raise ErrDimensionMismatch if @column_count != mat2.row_count
-
-      i = 0
-      while i < @row_count do
-        j = 0
-        while j < mat2.column_count do
-          k = 0
-          sum = 0
-          while k < @column_count do
-            sum += @array[i * @column_count + k] * mat2.array[k * mat2.column_count + j]
-            k += 1
-          end
-          @@multiply_buffer[i * @column_count + j] = sum
-          j += 1
-        end
-        i += 1
-      end
-
-      result ||= FastMatrix.create
-      result.array.replace(@@multiply_buffer)
-      result.row_count = @row_count
-      result.column_count = mat2.column_count
-      result
-    end
-
-    def self.combine_matrices(*matrices)
-      raise ArgumentError.new("Transform.combine_matrices expects one or more matrices") unless matrices.reject { |m| m.is_a?(Matrix) }.empty?
-
-      fast_matrices = matrices.map { |mat| FastMatrix.create.copy_from(mat) }
-      result = nil
-      fast_matrices.each do |fast_matrix|
-        if result
-          result.fast_multiply(fast_matrix, result)
-        else
-          result = fast_matrix
-        end
-      end
-      result
-    end
-  end
+require_relative 'patches.rb'
+require_relative 'utils.rb'
 
+module Gosling
+  ##
+  # A helper class for performing vector transforms in 2D space. Relies heavily on the Vec3 and Mat3 classes of the
+  # SnowMath gem to remain performant.
+  #
   class Transform
+    ##
+    # Wraps Math.sin to produce rationals instead of floats. Common values are returned quickly from a lookup table.
+    #
     def self.rational_sin(r)
+      type_check(r, Numeric)
+
       r = r % (2 * Math::PI)
-      return case r
+      case r
       when 0.0
         0.to_r
       when Math::PI / 2
@@ -124,9 +30,14 @@ module Gosling
       end
     end
 
+    ##
+    # Wraps Math.cos to produce rationals instead of floats. Common values are returned quickly from a lookup table.
+    #
     def self.rational_cos(r)
+      type_check(r, Numeric)
+
       r = r % (2 * Math::PI)
-      return case r
+      case r
       when 0.0
         1.to_r
       when Math::PI / 2
@@ -140,84 +51,274 @@ module Gosling
       end
     end
 
-    attr_reader :center, :scale, :rotation, :translation
+    attr_reader :rotation
 
+    ##
+    # Creates a new transform object with no transformations (identity matrix).
     def initialize
-      set_center(Vector[0.to_r, 0.to_r, 0.to_r])
-      set_scale(Vector[1.to_r, 1.to_r])
-      set_rotation(0)
-      set_translation(Vector[0.to_r, 0.to_r, 0.to_r])
-    end
-
-    def set_center(v)
-      raise ArgumentError.new("Transform.set_center() requires a length 3 vector") unless v.is_a?(Vector) && v.size == 3
-      @center = Vector[v[0], v[1], 0.to_r]
-      @center_mat = Matrix[
-        [1.to_r, 0.to_r, -@center[0].to_r],
-        [0.to_r, 1.to_r, -@center[1].to_r],
-        [0.to_r, 0.to_r, 1.to_r]
-      ]
-      @is_dirty = true
-    end
-
-    def set_scale(v)
-      raise ArgumentError.new("Transform.set_scale() requires a length 2 vector") unless v.is_a?(Vector) && v.size == 2
-      @scale = v
-      @scale_mat = Matrix[
-        [@scale[0].to_r, 0.to_r, 0.to_r],
-        [0.to_r, @scale[1].to_r, 0.to_r],
-        [0.to_r, 0.to_r, 1.to_r]
-      ]
-      @is_dirty = true
-    end
-
-    def set_rotation(radians)
+      @center = Snow::Vec3[0.to_r, 0.to_r, 1.to_r]
+      @scale = Snow::Vec2[1.to_r, 1.to_r]
+      @translation = Snow::Vec3[0.to_r, 0.to_r, 1.to_r]
+      reset
+    end
+
+    ##
+    # Resets center and translation to [0, 0], scale to [1, 1], and rotation to 0, restoring this transformation to the identity
+    # matrix.
+    #
+    def reset
+      self.center = 0.to_r, 0.to_r
+      self.scale = 1.to_r, 1.to_r
+      self.rotation = 0.to_r
+      self.translation = 0.to_r, 0.to_r
+    end
+
+    ##
+    # Returns a duplicate of the center Vec3 (@center is read-only).
+    #
+    def center
+      @center.dup
+    end
+
+    ##
+    # Returns a duplicate of the scale Vec2 (@scale is read-only).
+    #
+    def scale
+      @scale.dup
+    end
+
+    ##
+    # Returns a duplicate of the translation Vec3 (@translation is read-only).
+    #
+    def translation
+      @translation.dup
+    end
+
+    ##
+    # Sets this transform's centerpoint. All other transforms are performed relative to this central point.
+    #
+    # The default centerpoint is [0, 0], which is the same as no transform. For a square defined by the vertices
+    # [[0, 0], [10, 0], [10, 10], [0, 10]], this would translate to that square's upper left corner. In this case, when scaled
+    # larger or smaller, only the square's right and bottom edges would expand or  contract, and when rotated it
+    # would spin around its upper left corner. For most applications, this is probably not what we want.
+    #
+    # By setting the centerpoint to something other than the origin, we can change the scaling and rotation to
+    # something that makes more sense. For the square defined above, we could set center to be the actual center of
+    # the square: [5, 5]. By doing so, scaling the square would cause it to expand evenly on all sides, and rotating it
+    # would cause it to spin about its center like a four-cornered wheel.
+    #
+    # You can set the centerpoint to be any point in local space, inside or even outside of the shape in question.
+    #
+    # If passed more than two numeric arguments, only the first two are used.
+    #
+    # Usage:
+    # - transform.center = x, y
+    # - transform.center = [x, y]
+    # - transform.center = Snow::Vec2[x, y]
+    # - transform.center = Snow::Vec3[x, y, z]
+    # - transform.center = Snow::Vec4[x, y, z, c]
+    #
+    def center=(args)
+      case args[0]
+      when Array
+        self.center = args[0][0], args[0][1]
+      when Snow::Vec2, Snow::Vec3, Snow::Vec4
+        @center.x = args[0].x
+        @center.y = args[0].y
+      when Numeric
+        raise ArgumentError.new("Cannot set center from #{args.inspect}: numeric array requires at least two arguments!") unless args.length >= 2
+        args.each { |arg| type_check(arg, Numeric) }
+        @center.x = args[0]
+        @center.y = args[1]
+      else
+        raise ArgumentError.new("Cannot set center from #{args.inspect}: bad type!")
+      end
+      @center_is_dirty = @is_dirty = true
+    end
+    alias :set_center :center=
+
+    ##
+    # Sets this transform's x/y scaling. A scale value of [1, 1] results in no scaling. Larger values make a shape bigger,
+    # while smaller values will make it smaller. Great for shrinking/growing animations, or to zoom the camera in/out.
+    #
+    # If passed more than two numeric arguments, only the first two are used.
+    #
+    # Usage:
+    # - transform.scale = x, y
+    # - transform.scale = [x, y]
+    # - transform.scale = Snow::Vec2[x, y]
+    # - transform.scale = Snow::Vec3[x, y, z]
+    # - transform.scale = Snow::Vec4[x, y, z, c]
+    #
+    def scale=(args)
+      case args[0]
+      when Array
+        self.scale = args[0][0], args[0][1]
+      when Snow::Vec2, Snow::Vec3, Snow::Vec4
+        @scale.x = args[0].x
+        @scale.y = args[0].y
+      when Numeric
+        raise ArgumentError.new("Cannot set scale from #{args.inspect}: numeric array requires at least two arguments!") unless args.length >= 2
+        args.each { |arg| type_check(arg, Numeric) }
+        @scale.x = args[0]
+        @scale.y = args[1]
+      else
+        raise ArgumentError.new("Cannot set scale from #{args.inspect}: bad type!")
+      end
+      @scale_is_dirty = @is_dirty = true
+    end
+    alias :set_scale :scale=
+
+    ##
+    # Sets this transform's rotation in radians. A value of 0 results in no rotation. Great for spinning animations, or
+    # rotating the player's camera view.
+    #
+    # Usage:
+    # - transform.rotation = radians
+    #
+    def rotation=(radians)
+      type_check(radians, Numeric)
       @rotation = radians
-      @rotate_mat = Matrix[
-        [Transform.rational_cos(@rotation), Transform.rational_sin(@rotation), 0.to_r],
-        [-Transform.rational_sin(@rotation), Transform.rational_cos(@rotation), 0.to_r],
-        [0.to_r, 0.to_r, 1.to_r]
-      ]
-      @is_dirty = true
+      @rotate_is_dirty = @is_dirty = true
     end
+    alias :set_rotation :rotation=
 
-    def set_translation(v)
-      raise ArgumentError.new("Transform.set_translation() requires a length 3 vector") unless v.is_a?(Vector) && v.size == 3
-      @translation = Vector[v[0], v[1], 0.to_r]
-      @translate_mat = Matrix[
-        [1.to_r, 0.to_r, @translation[0].to_r],
-        [0.to_r, 1.to_r, @translation[1].to_r],
-        [0.to_r, 0.to_r, 1.to_r]
-      ]
-      @is_dirty = true
+    ##
+    # Sets this transform's x/y translation in radians. A value of [0, 0] results in no translation. Great for moving
+    # actors across the screen or scrolling the camera.
+    #
+    # If passed more than two numeric arguments, only the first two are used.
+    #
+    # Usage:
+    # - transform.translation = x, y
+    # - transform.translation = [x, y]
+    # - transform.translation = Snow::Vec2[x, y]
+    # - transform.translation = Snow::Vec3[x, y, z]
+    # - transform.translation = Snow::Vec4[x, y, z, c]
+    #
+    def translation=(args)
+      case args[0]
+      when Array
+        self.translation = args[0][0], args[0][1]
+      when Snow::Vec2, Snow::Vec3, Snow::Vec4
+        @translation.x = args[0].x
+        @translation.y = args[0].y
+      when Numeric
+        raise ArgumentError.new("Cannot set translation from #{args.inspect}: numeric array requires at least two arguments!") unless args.length >= 2
+        args.each { |arg| type_check(arg, Numeric) }
+        @translation.x = args[0]
+        @translation.y = args[1]
+      else
+        raise ArgumentError.new("Cannot set translation from #{args.inspect}: bad type!")
+      end
+      @translate_is_dirty = @is_dirty = true
     end
+    alias :set_translation :translation=
 
+    ##
+    # Returns a Snow::Mat3 which combines our current center, scale, rotation, and translation into a single transform
+    # matrix. When a point in space is multiplied by this transform, the centering, scaling, rotation, and translation
+    # will all be applied to that point.
+    #
+    # This Snow::Mat3 is cached and will only be recalculated as needed.
+    #
     def to_matrix
-      return @matrix unless @is_dirty
-      #~ @matrix = @translate_mat * @rotate_mat * @scale_mat * @center_mat
-      @matrix = FastMatrix.combine_matrices(@translate_mat, @rotate_mat, @scale_mat, @center_mat).to_matrix
+      return @matrix unless @is_dirty || @matrix.nil?
+
+      update_center_matrix
+      update_scale_matrix
+      update_rotate_matrix
+      update_translate_matrix
+
+      @matrix = Snow::Mat3.new unless @matrix
+
+      @matrix.set(@center_mat)
+      @matrix.multiply!(@scale_mat)
+      @matrix.multiply!(@rotate_mat)
+      @matrix.multiply!(@translate_mat)
+
       @is_dirty = false
       @matrix
     end
 
+    ##
+    # Transforms a Vec3 using the provided Mat3 transform and returns the result as a new Vec3. This is the
+    # opposite of Transform.untransform_point.
+    #
     def self.transform_point(mat, v)
-      raise ArgumentError.new("Transform.transform_point() requires a length 3 vector") unless v.is_a?(Vector) && v.size == 3
-      result = mat * Vector[v[0], v[1], 1.to_r]
-      Vector[result[0], result[1], 0.to_r]
+      type_check(mat, Snow::Mat3)
+      type_check(v, Snow::Vec3)
+      result = mat * Snow::Vec3[v[0], v[1], 1.to_r]
+      result[2] = 0.to_r
+      result
     end
 
+    ##
+    # Applies all of our transformations to the point, returning the resulting point as a new Vec3. This is the opposite
+    # of Transform#untransform_point.
+    #
     def transform_point(v)
       Transform.transform_point(to_matrix, v)
     end
 
+    ##
+    # Transforms a Vec3 using the inverse of the provided Mat3 transform and returns the result as a new Vec3. This
+    # is the opposite of Transform.transform_point.
+    #
     def self.untransform_point(mat, v)
-      raise ArgumentError.new("Transform.transform_point() requires a length 3 vector") unless v.is_a?(Vector) && v.size == 3
-      result = mat.inverse * Vector[v[0], v[1], 1.to_r]
-      Vector[result[0], result[1], 0.to_r]
+      type_check(mat, Snow::Mat3)
+      type_check(v, Snow::Vec3)
+      inverse_mat = mat.inverse
+      unless inverse_mat
+        raise "Unable to invert matrix: #{mat}!"
+      end
+      result = mat.inverse * Snow::Vec3[v[0], v[1], 1.to_r]
+      result[2] = 0.to_r
+      result
     end
 
+    ##
+    # Applies the inverse of all of our transformations to the point, returning the resulting point as a new Vec3. This
+    # is the opposite of Transform#transform_point.
+    #
     def untransform_point(v)
       Transform.untransform_point(to_matrix, v)
     end
+
+    private
+
+    def update_center_matrix
+      return unless @center_is_dirty || @center_mat.nil?
+      @center_mat ||= Snow::Mat3.new
+      @center_mat[2] = -@center.x
+      @center_mat[5] = -@center.y
+      @center_is_dirty = false
+    end
+
+    def update_scale_matrix
+      return unless @scale_is_dirty || @scale_mat.nil?
+      @scale_mat ||= Snow::Mat3.new
+      @scale_mat[0] = @scale[0].to_r
+      @scale_mat[4] = @scale[1].to_r
+      @scale_is_dirty = false
+    end
+
+    def update_rotate_matrix
+      return unless @rotate_is_dirty || @rotate_mat.nil?
+      @rotate_mat ||= Snow::Mat3.new
+      @rotate_mat[0] = Transform.rational_cos(@rotation)
+      @rotate_mat[1] = Transform.rational_sin(@rotation)
+      @rotate_mat[3] = -Transform.rational_sin(@rotation)
+      @rotate_mat[4] = Transform.rational_cos(@rotation)
+      @rotate_is_dirty = false
+    end
+
+    def update_translate_matrix
+      return unless @translate_is_dirty || @translate_mat.nil?
+      @translate_mat ||= Snow::Mat3.new
+      @translate_mat[2] = @translation.x
+      @translate_mat[5] = @translation.y
+      @translate_is_dirty = false
+    end
   end
 end