Bumped version

lib/cyberarm_engine.rb

@@ -5,22 +5,24 @@ rescue LoadError => e
   require "gosu"
 end
 
-
 require_relative "cyberarm_engine/version"
 
 require_relative "cyberarm_engine/common"
 
+require_relative "cyberarm_engine/gosu_ext/circle"
+
 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/bounding_box.rb

@@ -68,11 +68,17 @@ module CyberarmEngine
       other.max.x <= max.x && other.max.y <= max.y && other.max.z <= max.z
     end
 
-    # returns whether the vector is inside of the bounding box
+    # returns whether the 3D vector is inside of the bounding box
+    def inside?(vector)
+      (vector.x.between?(@min.x, @max.x) || vector.x.between?(@max.x, @min.x)) &&
+      (vector.y.between?(@min.y, @max.y) || vector.y.between?(@max.y, @min.y)) &&
+      (vector.z.between?(@min.z, @max.z) || vector.z.between?(@max.z, @min.z))
+    end
+
+    # returns whether the 2D vector is inside of the bounding box
     def point?(vector)
-      vector.x.between?(@min.x, @max.x) &&
+      (vector.x.between?(@min.x, @max.x) || vector.x.between?(@max.x, @min.x)) &&
-      vector.y.between?(@min.y, @max.y) &&
+      (vector.y.between?(@min.y, @max.y) || vector.y.between?(@max.y, @min.y))
-      vector.z.between?(@min.z, @max.z)
     end
 
     def volume

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/gosu_ext/circle.rb

@@ -0,0 +1,9 @@
+module Gosu
+  # Sourced from https://gist.github.com/ippa/662583
+  def self.draw_circle(cx,cy,r, z = 9999,color = Gosu::Color::GREEN, step = 10)
+    0.step(360, step) do |a1|
+      a2 = a1 + step
+      draw_line(cx + Gosu.offset_x(a1, r), cy + Gosu.offset_y(a1, r), color, cx + Gosu.offset_x(a2, r), cy + Gosu.offset_y(a2, r), color, z)
+    end
+  end
+end

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/ui/theme.rb

@@ -65,7 +65,7 @@ module CyberarmEngine
       Button: { # < Label
         margin:   1,
         padding:  4,
-        border_thickness: 4,
+        border_thickness: 1,
         border_color: ["ffd59674".hex, "ffff8746".hex],
         border_radius: 0,
         background: ["ffc75e61".to_i(16), "ffe26623".to_i(16)],

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.0"
+  VERSION = "0.12.1"
 end