gosling 2.1.0 → 2.3.0

data/lib/gosling/image_library.rb

@@ -14,8 +14,8 @@ module Gosling
     # 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)
+        raise ArgumentError.new("File not found: '#{filename}' in '#{Dir.pwd}'") unless File.exists?(filename)
         @@cache[filename] = Gosu::Image.new(filename, tileable: true)
       end
       @@cache[filename]

data/lib/gosling/matrix_cache.rb

@@ -0,0 +1,21 @@
+require_relative 'object_cache.rb'
+
+class MatrixCache
+  include Singleton
+  include ObjectCache
+
+  def initialize
+    @cache = {}
+  end
+
+  protected
+
+  def create
+    Snow::Mat3.new
+  end
+
+  def reset(matrix)
+    type_check(matrix, Snow::Mat3)
+    matrix.load_identity
+  end
+end

data/lib/gosling/object_cache.rb

@@ -0,0 +1,48 @@
+require 'fiddle'
+
+class Object
+  FIDDLE_FREEZE_BIT = ~(1 << 3)
+
+  def unfreeze
+    ptr = @fiddle_pointer || Fiddle::Pointer.new(object_id * 2)
+    ptr[1] &= FIDDLE_FREEZE_BIT
+    @fiddle_pointer = ptr
+  end
+end
+
+module ObjectCache
+  def clear
+    @cache.clear
+  end
+
+  def recycle(obj)
+    return if @cache.key?(obj.object_id)
+    self.reset(obj)
+    obj.freeze
+    @cache[obj.object_id] = obj
+  end
+
+  def get
+    if @cache.empty?
+      self.create
+    else
+      obj = @cache.delete(@cache.keys.first)
+      obj.unfreeze
+      obj
+    end
+  end
+
+  def size
+    @cache.size
+  end
+
+  protected
+
+  def create
+    raise "Derived classes must implement create()."
+  end
+
+  def reset(obj)
+    raise "Derived classes must implement reset()."
+  end
+end

data/lib/gosling/polygon.rb

@@ -54,19 +54,52 @@ module Gosling
         @vertices.pop(@vertices.length - vertices.length)
       end
 
-      vertices.each_index do |i|
-        @vertices[i].x = vertices[i][0]
-        @vertices[i].y = vertices[i][1]
-        @vertices[i].z = 0
+      vertices.each_index { |i| @vertices[i].set(vertices[i][0], vertices[i][1], 0) }
+    end
+
+    ##
+    # Sets this polygon to a rectangular shape with the given width and height, with its upper left at local [0, 0].
+    #
+    def set_vertices_rect(width, height)
+      raise ArgumentError.new("Expected positive non-zero integer, but received #{width.inspect}!") unless width > 0
+      raise ArgumentError.new("Expected positive non-zero integer, but received #{height.inspect}!") unless height > 0
+
+      if @vertices.length < 4
+        @vertices.concat(Array.new(4 - @vertices.length) { Snow::Vec3.new })
+      elsif @vertices.length > 4
+        @vertices.pop(@vertices.length - 4)
       end
+
+      @vertices[0].set(    0,      0, 0)
+      @vertices[1].set(width,      0, 0)
+      @vertices[2].set(width, height, 0)
+      @vertices[3].set(    0, height, 0)
     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| Transformable.transform_point(tf, v) }
+    def get_global_vertices(out = nil)
+      type_check(out, Array) unless out.nil?
+
+      tf = MatrixCache.instance.get
+      get_global_transform(tf)
+
+      if out.nil?
+        return @vertices.map { |v| Transformable.transform_point(tf, v, Snow::Vec3.new) }
+      end
+
+      @vertices.each_index do |i|
+        v = @vertices[i]
+        if out[i]
+          Transformable.transform_point(tf, v, out[i])
+        else
+          out[i] = Transformable.transform_point(tf, v)
+        end
+      end
+      out
+    ensure
+      MatrixCache.instance.recycle(tf) if tf
     end
 
     ##
@@ -79,20 +112,11 @@ module Gosling
     private
 
     def render(matrix)
+      # TODO: write transformed vertices to a reserved list of vertices retained in memory each time
       type_check(matrix, Snow::Mat3)
       global_vertices = @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/rect.rb

@@ -33,13 +33,7 @@ module Gosling
     private
 
     def rebuild_vertices
-      vertices = [
-        Snow::Vec3[     0,       0, 0],
-        Snow::Vec3[@width,       0, 0],
-        Snow::Vec3[@width, @height, 0],
-        Snow::Vec3[     0, @height, 0],
-      ]
-      set_vertices(vertices)
+      set_vertices_rect(@width, @height)
     end
 
     private :set_vertices

data/lib/gosling/sprite.rb

@@ -34,7 +34,8 @@ module Gosling
     private
 
     def render(matrix)
-      global_vertices = @vertices.map { |v| Transformable.transform_point(matrix, v) }
+      # TODO: write transformed vertices to a reserved list of vertices retained in memory each time
+      global_vertices = @vertices.map { |v| Transformable.transform_point(matrix, v, Snow::Vec3.new) }
       @image.draw_as_quad(
         global_vertices[0][0].to_f, global_vertices[0][1].to_f, @color,
         global_vertices[1][0].to_f, global_vertices[1][1].to_f, @color,

data/lib/gosling/transformable.rb

@@ -43,14 +43,14 @@ module Gosling
     # Returns the x component of the centerpoint of this Transformable. See Transformable#center.
     #
     def center_x
-      @center.x
+      @center[0]
     end
 
     ##
     # Returns the y component of the centerpoint of this Transformable. See Transformable#center.
     #
     def center_y
-      @center.y
+      @center[1]
     end
 
     ##
@@ -64,14 +64,14 @@ module Gosling
     # Returns the x component of the scaling of this Transformable. See Transformable#scale.
     #
     def scale_x
-      @scale.x
+      @scale[0]
     end
 
     ##
     # Returns the y component of the scaling of this Transformable. See Transformable#scale.
     #
     def scale_y
-      @scale.y
+      @scale[1]
     end
 
     ##
@@ -86,14 +86,14 @@ module Gosling
     # Returns this Transformable's x position in relative space. See Transformable#translation.
     #
     def x
-      @translation.x
+      @translation[0]
     end
 
     ##
     # Returns this Transformable's y position in relative space. See Transformable#translation.
     #
     def y
-      @translation.y
+      @translation[1]
     end
 
     ##
@@ -119,21 +119,26 @@ module Gosling
     # - transform.center = Snow::Vec2[x, y]
     # - transform.center = Snow::Vec3[x, y, z]
     # - transform.center = Snow::Vec4[x, y, z, c]
+    # - transform.set_center { |c| c.add(-sprite.pos, 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]
+    def center=(args = nil)
+      if block_given?
+        yield(@center)
       else
-        raise ArgumentError.new("Cannot set center from #{args.inspect}: bad type!")
+        case args[0]
+        when Array
+          self.center = args[0][0], args[0][1]
+        when Snow::Vec2, Snow::Vec3, Snow::Vec4
+          @center[0] = args[0][0]
+          @center[1] = args[0][1]
+        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[0] = args[0]
+          @center[1] = args[1]
+        else
+          raise ArgumentError.new("Cannot set center from #{args.inspect}: bad type!")
+        end
       end
       @center_is_dirty = @is_dirty = true
     end
@@ -144,7 +149,7 @@ module Gosling
     #
     def center_x=(val)
       type_check(val, Numeric)
-      @center.x = val
+      @center[0] = val
       @center_is_dirty = @is_dirty = true
     end
 
@@ -153,7 +158,7 @@ module Gosling
     #
     def center_y=(val)
       type_check(val, Numeric)
-      @center.y = val
+      @center[1] = val
       @center_is_dirty = @is_dirty = true
     end
 
@@ -164,26 +169,41 @@ module Gosling
     # If passed more than two numeric arguments, only the first two are used.
     #
     # Usage:
+    # - transform.scale = scalar
     # - 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]
+    # - transform.set_scale { |s| s.multiply(0.5, s) }
     #
-    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]
+    def scale=(*args)
+      if block_given?
+        yield(@scale)
       else
-        raise ArgumentError.new("Cannot set scale from #{args.inspect}: bad type!")
+        if args.length >= 2
+          case args[0]
+          when Numeric
+            args.each { |arg| type_check(arg, Numeric) }
+            @scale[0] = args[0]
+            @scale[1] = args[1]
+          else
+            raise ArgumentError.new("Bad combination of arguments: #{args.inspect}! Please supply a Snow::Vec2, an Array of Numerics, or a single scalar.")
+          end
+        elsif args.length == 1
+          case args[0]
+          when Array
+            self.set_scale(*(args[0]))
+          when Snow::Vec2
+            self.set_scale(args[0][0], args[0][1])
+          when Numeric
+            self.set_scale(args[0], args[0])
+          else
+            raise ArgumentError.new("Bad combination of arguments: #{args.inspect}! Please supply a Snow::Vec2, an Array of Numerics, or a single scalar.")
+          end
+        else
+          raise ArgumentError.new("Bad combination of arguments: #{args.inspect}! Please supply a Snow::Vec2, an Array of Numerics, or a single scalar.")
+        end
       end
       @scale_is_dirty = @is_dirty = true
     end
@@ -194,7 +214,7 @@ module Gosling
     #
     def scale_x=(val)
       type_check(val, Numeric)
-      @scale.x = val
+      @scale[0] = val
       @scale_is_dirty = @is_dirty = true
     end
 
@@ -203,7 +223,7 @@ module Gosling
     #
     def scale_y=(val)
       type_check(val, Numeric)
-      @scale.y = val
+      @scale[1] = val
       @scale_is_dirty = @is_dirty = true
     end
 
@@ -230,27 +250,38 @@ module Gosling
     #
     # If passed more than two numeric arguments, only the first two are used.
     #
+    # Optionally, this method can be passed a block and no arguments. A reference to this Transformable's translation
+    # will be passed to the block as the first parameter, allowing direct manipulation using all of snow-math's Vec3
+    # methods. This is particularly useful when optimizing methods that MUST be as fast as possible, such as animation
+    # and game physics, since the result of your mathematics can be written directly to this Transformable's translation
+    # without having to instantiate an interim Vector during every physics step.
+    #
     # 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]
+    # - transform.set_translation { |t| t.add(velocity * elapsed, t) }
     #
-    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]
+    def translation=(args = nil)
+      if block_given?
+        yield(@translation)
       else
-        raise ArgumentError.new("Cannot set translation from #{args.inspect}: bad type!")
+        case args[0]
+        when Array
+          self.translation = args[0][0], args[0][1]
+        when Snow::Vec2, Snow::Vec3, Snow::Vec4
+          @translation[0] = args[0][0]
+          @translation[1] = args[0][1]
+        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[0] = args[0]
+          @translation[1] = args[1]
+        else
+          raise ArgumentError.new("Cannot set translation from #{args.inspect}: bad type!")
+        end
       end
       @translate_is_dirty = @is_dirty = true
     end
@@ -262,7 +293,7 @@ module Gosling
     #
     def x=(val)
       type_check(val, Numeric)
-      @translation.x = val
+      @translation[0] = val
       @translate_is_dirty = @is_dirty = true
     end
 
@@ -271,7 +302,7 @@ module Gosling
     #
     def y=(val)
       type_check(val, Numeric)
-      @translation.y = val
+      @translation[1] = val
       @translate_is_dirty = @is_dirty = true
     end
 
@@ -305,44 +336,43 @@ module Gosling
     # Transforms a Vec3 using the provided Mat3 transform and returns the result as a new Vec3. This is the
     # opposite of Transformable.untransform_point.
     #
-    def self.transform_point(mat, v)
-      type_check(mat, Snow::Mat3)
-      type_check(v, Snow::Vec3)
-      result = mat * Snow::Vec3[v[0], v[1], 1]
-      result[2] = 0
-      result
+    @@transformable_point
+    def self.transform_point(mat, point, out = nil)
+      @@transformable_point ||= Snow::Vec3.new
+      @@transformable_point.set(point[0], point[1], 1)
+
+      out ||= Snow::Vec3.new
+      mat.multiply(@@transformable_point, out)
+      out[2] = 0
+      out
     end
 
     ##
     # Applies all of our transformations to the point, returning the resulting point as a new Vec3. This is the opposite
     # of Transformable#untransform_point.
     #
-    def transform_point(v)
-      Transformable.transform_point(to_matrix, v)
+    def transform_point(point, out = nil)
+      Transformable.transform_point(to_matrix, point, out)
     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 Transformable.transform_point.
     #
-    def self.untransform_point(mat, v)
-      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]
-      result[2] = 0
-      result
+    def self.untransform_point(mat, point, out = nil)
+      inverse_mat = MatrixCache.instance.get
+      raise "Unable to invert matrix: #{mat}!" unless mat.inverse(inverse_mat)
+      transform_point(inverse_mat, point, out)
+    ensure
+      MatrixCache.instance.recycle(inverse_mat) if inverse_mat
     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 Transformable#transform_point.
     #
-    def untransform_point(v)
-      Transformable.untransform_point(to_matrix, v)
+    def untransform_point(point, out = nil)
+      Transformable.untransform_point(to_matrix, point, out)
     end
 
     private
@@ -350,8 +380,8 @@ module Gosling
     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_mat[2] = -@center[0]
+      @center_mat[5] = -@center[1]
       @center_is_dirty = false
     end
 
@@ -375,8 +405,8 @@ module Gosling
     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_mat[2] = @translation[0]
+      @translate_mat[5] = @translation[1]
       @translate_is_dirty = false
     end
   end