gosling 2.1.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6522b7771bdf2e2b85a0bf3cbf7f440497d21a91
-  data.tar.gz: e0d6aa8c63c4361aeb7dffb1f25c6310bb050730
+  metadata.gz: f40ad4e1b06a4aeb3653172b748bb6b9cff0aaec
+  data.tar.gz: '0249b7dbe396d152de3791ad3e5548ffad9c8ece'
 SHA512:
-  metadata.gz: a1646556b4e6765ceda7ede9e7c7447cd71eda9af4eb510bd7413e9ba8e9116c4c4177e9b8096c3f2fc81584c0bcb310ab6caf00691d951f1b549b5ffb98eeb8
-  data.tar.gz: 719da8786b573ae344338586f2c53ebc0bc41987d392fc0383b218fc4408e94f5f411ffc3a506bf78a9958eae033ae34db14385db3c4702f380e6e312250d753
+  metadata.gz: 05a6efbacdee880176e86660408c0d005d0e32e86e1eca91a213e1552dfdbccfe40edf43d167669e0684690d2280299ce49448d2f3719b7604bb037c683e6a49
+  data.tar.gz: b5670a5dace288c80bb8ba339cbba83b171d1e0ec8d104b2ba327792e550dc4957783ec0ee710940bc45c115af4f40d958bf77563b7711b6a248fd31ed5a933b

data/lib/gosling/actor.rb

@@ -139,12 +139,19 @@ module Gosling
     # be skipped and not drawn.
     #
     def draw(matrix = nil)
-      matrix ||= Snow::Mat3.new
-      transform = to_matrix * matrix
+      transform = MatrixCache.instance.get
+      if matrix
+        to_matrix.multiply(matrix, transform)
+      else
+        transform.set(to_matrix)
+      end
+
       render(transform) if @is_visible
       if @are_children_visible
         @children.each { |child| child.draw(transform) }
       end
+    ensure
+      MatrixCache.instance.recycle(transform)
     end
 
     ##
@@ -209,12 +216,11 @@ module Gosling
     # space of its root ancestor).
     #
     def get_global_transform(out = nil)
+      out ||= Snow::Mat3.new
       if parent
-        out ||= Snow::Mat3.new
         to_matrix.multiply(parent.get_global_transform, out)
-        out
       else
-        to_matrix
+        out.set(to_matrix)
       end
     end
 
@@ -222,9 +228,13 @@ module Gosling
     # Returns the global x/y position of this actor (where it is relative to its root ancestor). This value is calculated
     # using the Actor's center (see Transformable#center).
     #
-    def get_global_position
-      tf = get_global_transform
-      Transformable.transform_point(tf, center)
+    def get_global_position(out = nil)
+      tf = MatrixCache.instance.get
+      get_global_transform(tf)
+      out ||= Snow::Vec3.new
+      Transformable.transform_point(tf, center, out)
+    ensure
+      MatrixCache.instance.recycle(tf)
     end
 
     ##
@@ -288,6 +298,19 @@ module Gosling
     def render(matrix)
     end
 
+    def fill_polygon(vertices)
+      (2...vertices.length).each do |i|
+        v0 = vertices[0]
+        v1 = vertices[i - 1]
+        v2 = vertices[i]
+        @window.draw_triangle(
+          v0[0].to_f, v0[1].to_f, @color,
+          v1[0].to_f, v1[1].to_f, @color,
+          v2[0].to_f, v2[1].to_f, @color,
+        )
+      end
+    end
+
     ##
     # Internal use only. See #add_child and #remove_child.
     #

data/lib/gosling/circle.rb

@@ -34,9 +34,10 @@ module Gosling
     ##
     # Returns the angle's corresponding unit vector times this circle's radius.
     #
-    def get_point_at_angle(radians)
+    def get_point_at_angle(radians, out = nil)
       raise ArgumentError.new("Expected Numeric, but received #{radians.inspect}!") unless radians.is_a?(Numeric)
-      Snow::Vec3[Math.cos(radians) * @radius, Math.sin(radians) * @radius, 0]
+      out ||= Snow::Vec3.new
+      out.set(Math.cos(radians) * @radius, Math.sin(radians) * @radius, 0)
     end
 
     ##
@@ -48,23 +49,17 @@ module Gosling
 
     private
 
+    # TODO: keep a cached, class-level list of local vertices that can be re-used during rendering
+
     def render(matrix)
+      # TODO: store these vertices in a cached, class-level array (see above)
       local_vertices = (0...RENDER_VERTEX_COUNT).map do |i|
         get_point_at_angle(Math::PI * 2 * i / RENDER_VERTEX_COUNT)
       end
+      # TODO: retain an array of vertices in memory; write transformed vertices to this array
       global_vertices = local_vertices.map { |v| Transformable.transform_point(matrix, v) }
-      i = 2
-      while i < global_vertices.length
-        v0 = global_vertices[0]
-        v1 = global_vertices[i-1]
-        v2 = global_vertices[i]
-        @window.draw_triangle(
-          v0[0].to_f, v0[1].to_f, @color,
-          v1[0].to_f, v1[1].to_f, @color,
-          v2[0].to_f, v2[1].to_f, @color,
-        )
-        i += 1
-      end
+
+      fill_polygon(global_vertices)
     end
   end
 end

data/lib/gosling/collision.rb

@@ -33,9 +33,11 @@ module Gosling
 
       return false if shapeA === shapeB
 
-      separation_axes = get_separation_axes(shapeA, shapeB)
+      get_separation_axes(shapeA, shapeB)
 
+      reset_projection_axis_tracking
       separation_axes.each do |axis|
+        next if axis_already_projected?(axis)
         projectionA = project_onto_axis(shapeA, axis)
         projectionB = project_onto_axis(shapeB, axis)
         return false unless projections_overlap?(projectionA, projectionB)
@@ -58,18 +60,26 @@ module Gosling
     # - penetration: if colliding, a vector representing how far shape B must move to be separated from (or merely
     #     touching) shape A; nil otherwise
     #
-    def self.get_collision_info(shapeA, shapeB)
-      info = { colliding: false, overlap: nil, penetration: nil }
+    def self.get_collision_info(shapeA, shapeB, info = nil)
+      if info
+        info.clear
+      else
+        info = {}
+      end
+      info.merge!(actors: [shapeA, shapeB], colliding: false, overlap: nil, penetration: nil)
 
       return info if shapeA.instance_of?(Actor) || shapeB.instance_of?(Actor)
 
       return info if shapeA === shapeB
 
-      separation_axes = get_separation_axes(shapeA, shapeB)
+      get_separation_axes(shapeA, shapeB)
+      return info if separation_axes.empty?
 
       smallest_overlap = nil
       smallest_axis = nil
+      reset_projection_axis_tracking
       separation_axes.each do |axis|
+        next if axis_already_projected?(axis)
         projectionA = project_onto_axis(shapeA, axis)
         projectionB = project_onto_axis(shapeB, axis)
         overlap = get_overlap(projectionA, projectionB)
@@ -77,7 +87,8 @@ module Gosling
         if smallest_overlap.nil? || smallest_overlap > overlap
           smallest_overlap = overlap
           flip = (projectionA[0] + projectionA[1]) * 0.5 > (projectionB[0] + projectionB[1]) * 0.5
-          smallest_axis = flip ? -axis : axis
+          smallest_axis = axis
+          smallest_axis.negate! if flip
         end
       end
 
@@ -85,7 +96,7 @@ module Gosling
       info[:overlap] = smallest_overlap
       info[:penetration] = smallest_axis.normalize * smallest_overlap
 
-      return info
+      info
     end
 
     ##
@@ -104,47 +115,240 @@ module Gosling
 
       return false if shape.instance_of?(Actor)
 
-      separation_axes = []
+      global_pos = nil
+      centers_axis = nil
+      global_vertices = nil
       if shape.instance_of?(Circle)
-        centers_axis = point - shape.get_global_position
-        separation_axes.push(centers_axis) if centers_axis && centers_axis.magnitude > 0
+        unless @@global_position_cache.key?(shape)
+          global_pos = VectorCache.instance.get
+          shape.get_global_position(global_pos)
+        end
+        centers_axis = VectorCache.instance.get
+        point.subtract(@@global_position_cache.fetch(shape, global_pos), centers_axis)
+        next_separation_axis.set(centers_axis) if centers_axis && (centers_axis[0] != 0 || centers_axis[1] != 0)
       else
-        separation_axes.concat(get_polygon_separation_axes(shape.get_global_vertices))
+        unless @@global_vertices_cache.key?(shape)
+          global_vertices = Array.new(shape.get_vertices.length) { VectorCache.instance.get }
+          shape.get_global_vertices(global_vertices)
+        end
+        get_polygon_separation_axes(@@global_vertices_cache.fetch(shape, global_vertices))
       end
 
+      reset_projection_axis_tracking
       separation_axes.each do |axis|
+        next if axis_already_projected?(axis)
         shape_projection = project_onto_axis(shape, axis)
         point_projection = point.dot_product(axis)
-        return false unless shape_projection.min <= point_projection && point_projection <= shape_projection.max
+        return false unless shape_projection.first <= point_projection && point_projection <= shape_projection.last
       end
 
       return true
+    ensure
+      VectorCache.instance.recycle(global_pos) if global_pos
+      VectorCache.instance.recycle(centers_axis) if centers_axis
+      global_vertices.each { |v| VectorCache.instance.recycle(v) } if global_vertices
+    end
+
+    @@collision_buffer = []
+    @@global_position_cache = {}
+    @@global_vertices_cache = {}
+    @@global_transform_cache = {}
+    @@buffer_iterator_a = nil
+    @@buffer_iterator_b = nil
+
+    ##
+    # Adds one or more descendents of Actor to the collision testing buffer. The buffer's iterators will be reset to the
+    # first potential collision in the buffer.
+    #
+    # When added to the buffer, important and expensive global-space collision values for each Actor - transform,
+    # position, and any vertices - are calculated and cached for re-use. This ensures that expensive transform
+    # calculations are only performed once per actor during each collision resolution step.
+    #
+    # If you modify a buffered actor's transforms in any way, you will need to update its cached values by calling
+    # buffer_shapes again. Otherwise, it will continue to use stale and inaccurate transform information.
+    #
+    def self.buffer_shapes(actors)
+      type_check(actors, Array)
+      actors.each { |a| type_check(a, Actor) }
+
+      reset_buffer_iterators
+
+      shapes = actors.reject { |a| a.instance_of?(Actor) }
+
+      @@collision_buffer = @@collision_buffer | shapes
+      shapes.each do |shape|
+        unless @@global_transform_cache.key?(shape)
+          @@global_transform_cache[shape] = MatrixCache.instance.get
+        end
+        shape.get_global_transform(@@global_transform_cache[shape])
+
+        unless @@global_position_cache.key?(shape)
+          @@global_position_cache[shape] = VectorCache.instance.get
+        end
+        # TODO: can we calculate this position using the global transform we already have?
+        @@global_position_cache[shape].set(shape.get_global_position)
+
+        if shape.is_a?(Polygon)
+          unless @@global_vertices_cache.key?(shape)
+            @@global_vertices_cache[shape] = Array.new(shape.get_vertices.length) { VectorCache.instance.get }
+          end
+          # TODO: can we calculate these vertices using the global transform we already have?
+          shape.get_global_vertices(@@global_vertices_cache[shape])
+        end
+      end
+    end
+
+    ##
+    # Removes one or more descendents of Actor from the collision testing buffer. Any cached values for the actors
+    # are discarded. The buffer's iterators will be reset to the first potential collision in the buffer.
+    #
+    def self.unbuffer_shapes(actors)
+      type_check(actors, Array)
+      actors.each { |a| type_check(a, Actor) }
+
+      reset_buffer_iterators
+
+      @@collision_buffer = @@collision_buffer - actors
+      actors.each do |actor|
+        if @@global_transform_cache.key?(actor)
+          MatrixCache.instance.recycle(@@global_transform_cache[actor])
+          @@global_transform_cache.delete(actor)
+        end
+
+        if @@global_position_cache.key?(actor)
+          VectorCache.instance.recycle(@@global_position_cache[actor])
+          @@global_position_cache.delete(actor)
+        end
+
+        if @@global_vertices_cache.key?(actor)
+          @@global_vertices_cache[actor].each do |vertex|
+            VectorCache.instance.recycle(vertex)
+          end
+          @@global_vertices_cache.delete(actor)
+        end
+      end
+    end
+
+    ##
+    # Removes all actors from the collision testing buffer. See Collision.unbuffer_shapes.
+    #
+    def self.clear_buffer
+      unbuffer_shapes(@@collision_buffer)
+    end
+
+    ##
+    # Returns collision information for the next pair of actors in the collision buffer, or returns nil if all pairs in the
+    # buffer have been tested. Advances the buffer's iterators to the next pair. See Collision.get_collision_info.
+    #
+    def self.next_collision_info
+      reset_buffer_iterators if @@buffer_iterator_a.nil? || @@buffer_iterator_b.nil?
+      return if iteration_complete?
+
+      info = get_collision_info(@@collision_buffer[@@buffer_iterator_a], @@collision_buffer[@@buffer_iterator_b])
+      skip_next_collision
+      info
+    end
+
+    ##
+    # Returns the pair of actors in the collision buffer that would be tested during the next call to
+    # Collision.next_collision_info, or returns nil if all pairs in the buffer have been tested. Does not perform
+    # collision testing or advance the buffer's iterators.
+    #
+    # One use of this method is to look at the two actors about to be tested and, using some custom and likely more
+    # efficient logic, determine if it's worth bothering to collision test these actors at all. If not, the pair's collision test
+    # can be skipped by calling Collision.skip_next_collision.
+    #
+    def self.peek_at_next_collision
+      reset_buffer_iterators if @@buffer_iterator_a.nil? || @@buffer_iterator_b.nil?
+      return if iteration_complete?
+
+      [@@collision_buffer[@@buffer_iterator_a], @@collision_buffer[@@buffer_iterator_b]]
+    end
+
+    ##
+    # Advances the collision buffer's iterators to the next pair of actors in the buffer without performing any collision
+    # testing. By using this method in conjunction with Collision.peek_at_next_collision, it is possible to selectively
+    # skip collision testing for pairs of actors that meet certain criteria.
+    #
+    def self.skip_next_collision
+      reset_buffer_iterators if @@buffer_iterator_a.nil? || @@buffer_iterator_b.nil?
+      return if iteration_complete?
+
+      @@buffer_iterator_b += 1
+      if @@buffer_iterator_b >= @@buffer_iterator_a
+        @@buffer_iterator_b = 0
+        @@buffer_iterator_a += 1
+      end
     end
 
     private
 
-    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]
+    def self.iteration_complete?
+      @@buffer_iterator_a >= @@collision_buffer.length
     end
 
-    def self.get_polygon_separation_axes(vertices)
-      type_check(vertices, Array)
-      vertices.each { |v| type_check(v, Snow::Vec3) }
+    def self.reset_buffer_iterators
+      @@buffer_iterator_a = 1
+      @@buffer_iterator_b = 0
+    end
+
+    def self.get_normal(vector, out = nil)
+      raise ArgumentError.new("Cannot determine normal of zero-length vector") if vector[0] == 0 && vector[1] == 0
+      out ||= Snow::Vec3.new
+      out.set(-vector[1], vector[0], 0)
+    end
+
+    @@separation_axes = []
+    @@separation_axis_count = 0
+
+    def self.reset_separation_axes
+      @@separation_axis_count = 0
+    end
+
+    def self.next_separation_axis
+      axis = @@separation_axes[@@separation_axis_count] ||= Snow::Vec3.new
+      @@separation_axis_count += 1
+      axis
+    end
+
+    def self.separation_axes
+      @@separation_axes[0...@@separation_axis_count]
+    end
 
-      axes = (0...vertices.length).map do |i|
-        axis = vertices[(i + 1) % vertices.length] - vertices[i]
-        (axis.magnitude > 0) ? get_normal(axis).normalize : nil
+    @@gpsa_axis = Snow::Vec3.new
+    def self.get_polygon_separation_axes(vertices)
+      # TODO: special case for Rects - only return two axes to avoid duplicitous math
+      vertices.each_index do |i|
+        vertices[i].subtract(vertices[i - 1], @@gpsa_axis)
+        if @@gpsa_axis[0] != 0 || @@gpsa_axis[1] != 0
+          get_normal(@@gpsa_axis, @@gpsa_axis).normalize(next_separation_axis)
+        end
       end
-      axes.compact
+      nil
     end
 
+    @@global_pos_a = nil
+    @@global_pos_b = nil
+    @@gcsa_axis = nil
     def self.get_circle_separation_axis(circleA, circleB)
-      type_check(circleA, Actor)
-      type_check(circleB, Actor)
-      axis = circleB.get_global_position - circleA.get_global_position
-      (axis.magnitude > 0) ? axis.normalize : nil
+      unless @@global_position_cache.key?(circleA)
+        @@global_pos_a ||= Snow::Vec3.new
+        circleA.get_global_position(@@global_pos_a)
+      end
+
+      unless @@global_position_cache.key?(circleB)
+        @@global_pos_b ||= Snow::Vec3.new
+        circleB.get_global_position(@@global_pos_b)
+      end
+
+      @@gcsa_axis ||= Snow::Vec3.new
+      @@global_pos_a = @@global_position_cache.fetch(circleA, @@global_pos_a)
+      @@global_pos_b = @@global_position_cache.fetch(circleB, @@global_pos_b)
+      @@global_pos_b.subtract(@@global_pos_a, @@gcsa_axis)
+      if @@gcsa_axis[0] != 0 || @@gcsa_axis[1] != 0
+        @@gcsa_axis.normalize(next_separation_axis)
+      end
+      nil
     end
 
     def self.get_separation_axes(shapeA, shapeB)
@@ -156,40 +360,123 @@ module Gosling
         raise ArgumentError.new("Expected a child of the Actor class, but received #{shapeB.inspect}!")
       end
 
-      separation_axes = []
+      reset_separation_axes
+      global_vertices = nil
 
       unless shapeA.instance_of?(Circle)
-        separation_axes.concat(get_polygon_separation_axes(shapeA.get_global_vertices))
+        unless @@global_vertices_cache.key?(shapeA)
+          global_vertices = Array.new(shapeA.get_vertices.length) { VectorCache.instance.get }
+          shapeA.get_global_vertices(global_vertices)
+        end
+        get_polygon_separation_axes(@@global_vertices_cache.fetch(shapeA, global_vertices))
       end
 
       unless shapeB.instance_of?(Circle)
-        separation_axes.concat(get_polygon_separation_axes(shapeB.get_global_vertices))
+        unless @@global_vertices_cache.key?(shapeB)
+          global_vertices ||= []
+          (shapeB.get_vertices.length - global_vertices.length).times do
+            global_vertices.push(VectorCache.instance.get)
+          end
+          (global_vertices.length - shapeB.get_vertices.length).times do
+            VectorCache.instance.recycle(global_vertices.pop)
+          end
+          shapeB.get_global_vertices(global_vertices)
+        end
+        get_polygon_separation_axes(@@global_vertices_cache.fetch(shapeB, global_vertices))
       end
 
       if shapeA.instance_of?(Circle) || shapeB.instance_of?(Circle)
-        axis = get_circle_separation_axis(shapeA, shapeB)
-        separation_axes.push(axis) if axis
+        get_circle_separation_axis(shapeA, shapeB)
       end
 
-      separation_axes.map! { |v| v[0] < 0 ? v * -1 : v }
-      separation_axes.uniq
+      nil
+    ensure
+      global_vertices.each { |v| VectorCache.instance.recycle(v) } if global_vertices
     end
 
-    def self.project_onto_axis(shape, axis)
-      type_check(shape, Actor)
-      type_check(axis, Snow::Vec3)
+    @@poa_zero_z_axis = nil
+    @@poa_local_axis = nil
+    @@poa_intersection = nil
+    @@poa_global_tf = nil
+    @@poa_global_tf_inverse = nil
+    def self.get_circle_vertices_by_axis(shape, axis)
+      unless @@global_transform_cache.key?(shape)
+        @@poa_global_tf ||= Snow::Mat3.new
+        shape.get_global_transform(@@poa_global_tf)
+      end
 
-      global_vertices = if shape.instance_of?(Circle)
-        global_tf = shape.get_global_transform
-        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| Transformable.transform_point(global_tf, vertex) }
-      else
-        shape.get_global_vertices
+      @@poa_zero_z_axis ||= Snow::Vec3.new
+      @@poa_zero_z_axis.set(axis[0], axis[1], 0)
+
+      @@poa_global_tf_inverse ||= Snow::Mat3.new
+      @@global_transform_cache.fetch(shape, @@poa_global_tf).inverse(@@poa_global_tf_inverse)
+
+      @@poa_local_axis ||= Snow::Vec3.new
+      @@poa_global_tf_inverse.multiply(@@poa_zero_z_axis, @@poa_local_axis)
+
+      @@poa_intersection ||= Snow::Vec3.new
+      shape.get_point_at_angle(Math.atan2(@@poa_local_axis[1], @@poa_local_axis[0]), @@poa_intersection)
+
+      Transformable.transform_point(@@global_transform_cache.fetch(shape, @@poa_global_tf), @@poa_intersection, next_global_vertex)
+
+      @@poa_intersection.negate!
+      Transformable.transform_point(@@global_transform_cache.fetch(shape, @@poa_global_tf), @@poa_intersection, next_global_vertex)
+    end
+
+    @@global_vertices = nil
+    @@global_vertices_count = 0
+
+    def self.reset_global_vertices
+      @@global_vertices ||= []
+      @@global_vertices_count = 0
+    end
+
+    def self.next_global_vertex
+      vertex = @@global_vertices[@@global_vertices_count] ||= Snow::Vec3.new
+      @@global_vertices_count += 1
+      vertex
+    end
+
+    @@projected_axes = nil
+
+    def self.reset_projection_axis_tracking
+      @@projected_axes ||= {}
+      @@projected_axes.clear
+    end
+
+    def self.axis_already_projected?(axis)
+      key = axis.to_s
+      return true if @@projected_axes.key?(key)
+      @@projected_axes[key] = nil
+    end
+
+    def self.project_onto_axis(shape, axis, out = nil)
+      unless @@global_vertices_cache.key?(shape)
+        reset_global_vertices
+        if shape.instance_of?(Circle)
+          get_circle_vertices_by_axis(shape, axis)
+        else
+          shape.get_global_vertices(@@global_vertices)
+          @@global_vertices_count = shape.get_vertices.length
+        end
       end
 
-      projections = global_vertices.map { |vertex| vertex.dot_product(axis) }.sort
-      [projections.first, projections.last]
+      min = nil
+      max = nil
+      @@global_vertices_cache.fetch(shape, @@global_vertices[0...@@global_vertices_count]).each do |vertex|
+        projection = vertex.dot_product(axis)
+        if min.nil?
+          min = projection
+          max = projection
+        else
+          min = projection if projection < min
+          max = projection if projection > max
+        end
+      end
+      out ||= []
+      out[1] = max
+      out[0] = min
+      out
     end
 
     def self.projections_overlap?(a, b)
@@ -198,12 +485,8 @@ module Gosling
     end
 
     def self.get_overlap(a, b)
-      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
-
+      raise ArgumentError.new("Projection array must be length 2, not #{a.inspect}!") unless a.length == 2
+      raise ArgumentError.new("Projection array must be length 2, not #{b.inspect}!") unless b.length == 2
       a.sort! if a[0] > a[1]
       b.sort! if b[0] > b[1]
       return b[1] - b[0] if a[0] <= b[0] && b[1] <= a[1]