Bump version

lib/cyberarm_engine.rb

@@ -5,7 +5,6 @@ rescue LoadError => e
   require "gosu"
 end
 
-
 require_relative "cyberarm_engine/version"
 
 require_relative "cyberarm_engine/common"
@@ -13,14 +12,15 @@ require_relative "cyberarm_engine/common"
 require_relative "cyberarm_engine/game_object"
 require_relative "cyberarm_engine/engine"
 
-require_relative "cyberarm_engine/lib/bounding_box"
+require_relative "cyberarm_engine/bounding_box"
-require_relative "cyberarm_engine/lib/vector"
+require_relative "cyberarm_engine/vector"
-require_relative "cyberarm_engine/lib/ray"
+require_relative "cyberarm_engine/transform"
-require_relative "cyberarm_engine/lib/shader" if defined?(OpenGL)
+require_relative "cyberarm_engine/ray"
+require_relative "cyberarm_engine/shader" if defined?(OpenGL)
 require_relative "cyberarm_engine/background"
 
-require_relative "cyberarm_engine/objects/text"
+require_relative "cyberarm_engine/text"
-require_relative "cyberarm_engine/objects/timer"
+require_relative "cyberarm_engine/timer"
 
 require_relative "cyberarm_engine/ui/theme"
 require_relative "cyberarm_engine/ui/event"

lib/cyberarm_engine/common.rb

@@ -54,7 +54,7 @@ module CyberarmEngine
       return Gosu::Color.rgba(color.red, color.green, color.blue, alpha)
     end
 
-    def get_asset(path, hash, klass)
+    def get_asset(path, hash, klass, retro = false, tileable = false)
       asset = nil
       hash.detect do |_asset, instance|
         if _asset == path
@@ -64,7 +64,12 @@ module CyberarmEngine
       end
 
       unless asset
-        instance = klass.new(path)
+        instance = nil
+        if klass == Gosu::Image
+          instance = klass.new(path, retro: retro, tileable: tileable)
+        else
+          instance = klass.new(path)
+        end
         hash[path] = instance
         asset = instance
       end
@@ -72,8 +77,8 @@ module CyberarmEngine
       return asset
     end
 
-    def get_image(path)
+    def get_image(path, retro: false, tileable: false)
-      get_asset(path, Engine::IMAGES, Gosu::Image)
+      get_asset(path, Engine::IMAGES, Gosu::Image, retro, tileable)
     end
 
     def get_sample(path)

lib/cyberarm_engine/transform.rb

@@ -0,0 +1,84 @@
+module CyberarmEngine
+  class Transform
+    attr_reader :elements
+    def initialize(matrix)
+      @elements = matrix
+
+      raise "Transform is wrong size! Got #{@elements.size}, expected 16" if 16 != @elements.size
+    end
+
+    def self.rotate(angle, rotate_around = nil)
+      double c = Math.cos(angle).degrees_to_radians
+      double s = Math.sin(angle).degrees_to_radians
+      matrix = [
+          +c, +s, 0, 0,
+          -s, +c, 0, 0,
+          0,  0,  1, 0,
+          0,  0,  0, 1,
+      ]
+
+      rotate_matrix = Transform.new(matrix, rows: 4, columns: 4)
+
+      if rotate_around && (rotate_around.x != 0.0 || rotate_around.y != 0.0)
+        negative_rotate_around = Vector.new(-rotate_around.x, -rotate_around.y, -rotate_around.z)
+
+        rotate_matrix = concat(
+          concat(translate(negative_rotate_around), rotate_matrix),
+          translate(rotate_around)
+        )
+      end
+
+      return rotate_matrix
+    end
+
+    def self.translate(vector)
+      x, y, z = vector.to_a[0..2]
+      matrix = [
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        x, y, z, 1,
+      ]
+
+      Transform.new(matrix)
+    end
+
+    def self.scale(vector, center_around = nil)
+      scale_x, scale_y, scale_z = vector.to_a[0..2]
+      matrix = [
+        scale_x, 0,       0,       0,
+        0,       scale_y, 0,       0,
+        0,       0,       scale_z, 0,
+        0,       0,       0,       1,
+      ]
+
+      scale_matrix = Transform.new(matrix)
+
+      if center_around && (center_around.x != 0.0 || center_around.y != 0.0)
+        negative_center_around = Vector.new(-center_around.x, -center_around.y, -center_around.z)
+
+        scale_matrix = concat(
+          concat(translate(negative_center_around), scale_matrix),
+          translate(center_around)
+        )
+      end
+
+      return scale_matrix
+    end
+
+    def self.concat(left, right)
+      matrix = Array.new(left.elements.size)
+      rows = 4
+
+      matrix.size.times do |i|
+        matrix[i] = 0
+
+        rows.times do |j|
+          matrix[i] += left.elements[i / rows * rows + j] * right.elements[i % rows + j * rows]
+        end
+      end
+
+      Transform.new(matrix)
+    end
+  end
+end

lib/cyberarm_engine/vector.rb

@@ -40,6 +40,9 @@ module CyberarmEngine
     def weight; @weight; end
     def weight=(n); @weight = n; end
 
+    alias w weight
+    alias w= weight=
+
     def ==(other)
       if other.is_a?(Numeric)
         @x      == other &&

lib/cyberarm_engine/version.rb

@@ -1,4 +1,4 @@
 module CyberarmEngine
   NAME    = "InDev"
-  VERSION = "0.11.1"
+  VERSION = "0.12.0"
 end