Bumpe version

Gemfile.lock

@@ -1,24 +0,0 @@
-PATH
-  remote: .
-  specs:
-    cyberarm_engine (0.24.4)
-      gosu (~> 1.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    gosu (1.4.6)
-    minitest (5.25.5)
-    rake (13.2.1)
-
-PLATFORMS
-  x64-mingw-ucrt
-
-DEPENDENCIES
-  bundler (~> 2.2)
-  cyberarm_engine!
-  minitest (~> 5.0)
-  rake (~> 13.0)
-
-BUNDLED WITH
-   2.5.3

assets/shaders/fragment/g_buffer.glsl

@@ -1,30 +0,0 @@
-# version 330 core
-
-layout(location  = 0) out vec3 fragPosition;
-layout (location = 1) out vec4 fragColor;
-layout (location = 2) out vec3 fragNormal;
-layout (location = 3) out vec3 fragUV;
-
-in vec3 out_position, out_color, out_normal, out_uv, out_frag_pos, out_camera_pos;
-out vec4 outputFragColor;
-flat in int out_has_texture;
-
-uniform sampler2D diffuse_texture;
-
-void main() {
-  vec3 result;
-
-  if (out_has_texture == 0) {
-    result = out_color;
-  } else {
-    result = texture(diffuse_texture, out_uv.xy).xyz + 0.25;
-  }
-
-  fragPosition = out_position;
-  fragColor = vec4(result, 1.0);
-  fragNormal = out_normal;
-  fragUV = out_uv;
-
-  float gamma = 2.2;
-  outputFragColor.rgb = pow(fragColor.rgb, vec3(1.0 / gamma));
-}

assets/shaders/fragment/lighting.glsl

@@ -1,115 +0,0 @@
-#version 330 core
-@include "light_struct"
-
-out vec4 frag_color;
-
-const int DIRECTIONAL = 0;
-const int POINT = 1;
-const int SPOT = 2;
-
-in vec2 out_tex_coords;
-flat in int out_light_count;
-flat in Light out_lights[7];
-
-uniform sampler2D diffuse, position, texcoord, normal, depth;
-
-vec4 directionalLight(Light light) {
-  vec3 norm = normalize(texture(normal, out_tex_coords).rgb);
-  vec3 diffuse_color = texture(diffuse, out_tex_coords).rgb;
-  vec3 frag_pos = texture(position, out_tex_coords).rgb;
-
-  vec3 lightDir = normalize(light.position - frag_pos);
-  float diff = max(dot(norm, lightDir), 0);
-
-  vec3 _ambient = light.ambient;
-  vec3 _diffuse = light.diffuse * diff;
-  vec3 _specular = light.specular;
-
-  return vec4(_diffuse + _ambient + _specular, 1.0);
-}
-
-void main() {
-  Light light;
-  light.type = DIRECTIONAL;
-
-  light.position = vec3(100, 100, 100);
-
-  light.diffuse = vec3(0.5, 0.5, 0.5);
-  light.ambient = vec3(0.8, 0.8, 0.8);
-  light.specular = vec3(0.2, 0.2, 0.2);
-
-  light.intensity = 1.0;
-
-  frag_color = texture(diffuse, out_tex_coords) * directionalLight(light);
-}
-
-// #version 330 core
-// @include "light_struct"
-
-// out vec4 frag_color;
-
-// const int DIRECTIONAL = 0;
-// const int POINT = 1;
-// const int SPOT = 2;
-
-// in vec2 out_tex_coords;
-// flat in int out_light_count;
-// flat in Light out_lights[7];
-
-// uniform sampler2D diffuse, position, texcoord, normal, depth;
-
-// vec4 directionalLight(Light light) {
-//   vec3 norm = normalize(texture(normal, out_tex_coords).rgb);
-//   vec3 diffuse_color = texture(diffuse, out_tex_coords).rgb;
-//   vec3 frag_pos = texture(position, out_tex_coords).rgb;
-
-//   vec3 lightDir = normalize(light.position - frag_pos);
-//   float diff = max(dot(norm, lightDir), 0);
-
-//   vec3 _ambient = light.ambient;
-//   vec3 _diffuse = light.diffuse * diff;
-//   vec3 _specular = light.specular;
-
-//   return vec4(_diffuse + _ambient + _specular, 1.0);
-// }
-
-// vec4 pointLight(Light light) {
-//   return vec4(0.25, 0.25, 0.25, 1);
-// }
-
-// vec4 spotLight(Light light) {
-//   return vec4(0.5, 0.5, 0.5, 1);
-// }
-
-// vec4 calculateLighting(Light light) {
-//   vec4 result;
-
-//   // switch(light.type) {
-//   //   case DIRECTIONAL: {
-//   //     result = directionalLight(light);
-//   //   }
-//   //   case SPOT: {
-//   //     result = spotLight(light);
-//   //   }
-//   //   default: {
-//   //     result = pointLight(light);
-//   //   }
-//   // }
-
-//   if (light.type == DIRECTIONAL) {
-//     result = directionalLight(light);
-//   } else {
-//     result = pointLight(light);
-//   }
-
-//   return result;
-// }
-
-// void main() {
-//   frag_color = vec4(0.0);
-
-//   for(int i = 0; i < out_light_count; i++)
-//   {
-//     frag_color += texture(diffuse, out_tex_coords) * calculateLighting(out_lights[i]);
-//   }
-// }

assets/shaders/include/light_struct.glsl

@@ -1,11 +0,0 @@
-struct Light {
-  int  type;
-  vec3 direction;
-  vec3 position;
-
-  vec3 diffuse;
-  vec3 ambient;
-  vec3 specular;
-
-  float intensity;
-};

assets/shaders/include/material_struct.glsl

@@ -1,16 +0,0 @@
-struct Material {
-  vec3 color;
-  vec3 roughness;
-  vec3 metalic;
-  vec3 specular;
-
-  bool use_color_texture;
-  bool use_roughness_texture;
-  bool use_metalic_texture;
-  bool use_specular_texture;
-
-  sampler2D color_tex;
-  sampler2D roughness_tex;
-  sampler2D metalic_tex;
-  sampler2D specular_tex;
-};

assets/shaders/vertex/g_buffer.glsl

@@ -1,28 +0,0 @@
-#version 330 core
-
-layout(location = 0) in vec3 in_position;
-layout(location = 1) in vec3 in_color;
-layout(location = 2) in vec3 in_normal;
-layout(location = 3) in vec3 in_uv;
-
-uniform mat4 projection, view, model;
-uniform int has_texture;
-uniform vec3 camera_pos;
-
-out vec3 out_position, out_color, out_normal, out_uv;
-out vec3 out_frag_pos, out_view_pos, out_camera_pos;
-flat out int out_has_texture;
-
-void main() {
-  // projection * view * model * position
-  out_position = in_position;
-  out_color = in_color;
-  out_normal= normalize(transpose(inverse(mat3(model))) * in_normal);
-  out_uv    = in_uv;
-  out_has_texture = has_texture;
-  out_camera_pos = camera_pos;
-
-  out_frag_pos = vec3(model * vec4(in_position, 1.0));
-
-  gl_Position = projection * view * model * vec4(in_position, 1.0);
-}

assets/shaders/vertex/lighting.glsl

@@ -1,24 +0,0 @@
-#version 330 core
-@include "light_struct"
-
-layout (location = 0) in vec3 in_position;
-layout (location = 1) in vec2 in_tex_coords;
-
-uniform sampler2D diffuse, position, texcoord, normal, depth;
-uniform int light_count;
-uniform Light lights[7];
-
-out vec2 out_tex_coords;
-flat out int out_light_count;
-flat out Light out_lights[7];
-
-void main() {
-  gl_Position = vec4(in_position.x, in_position.y, in_position.z, 1.0);
-  out_tex_coords = in_tex_coords;
-  out_light_count = light_count;
-
-  for(int i = 0; i < light_count; i++)
-  {
-    out_lights[i] = lights[i];
-  }
-}

cyberarm_engine.gemspec

@@ -27,7 +27,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = %w[lib assets]
 
+  spec.add_dependency "clipboard", "~> 1.3.5"
+  spec.add_dependency "excon", "~> 0.78.0"
   spec.add_dependency "gosu", "~> 1.1"
+  spec.add_dependency "gosu_more_drawables", "~> 0.3"
   # spec.add_dependency "ffi", :platforms => [:mswin, :mingw] # Required by Clipboard on Windows
 
   spec.add_development_dependency "bundler", "~> 2.2"

lib/cyberarm_engine.rb

@@ -6,19 +6,15 @@ else
   require "gosu"
 end
 require "json"
+require "excon"
+require "gosu_more_drawables"
+require "clipboard"
 
 require_relative "cyberarm_engine/version"
 require_relative "cyberarm_engine/stats"
 
 require_relative "cyberarm_engine/common"
 
-require_relative "cyberarm_engine/gosu_ext/draw_arc"
-require_relative "cyberarm_engine/gosu_ext/draw_circle"
-require_relative "cyberarm_engine/gosu_ext/draw_path"
-
-require_relative "cyberarm_engine/notification"
-require_relative "cyberarm_engine/notification_manager"
-
 require_relative "cyberarm_engine/game_object"
 require_relative "cyberarm_engine/window"
 
@@ -27,19 +23,12 @@ require_relative "cyberarm_engine/vector"
 require_relative "cyberarm_engine/transform"
 require_relative "cyberarm_engine/ray"
 require_relative "cyberarm_engine/background"
-require_relative "cyberarm_engine/background_nine_slice"
-require_relative "cyberarm_engine/background_image"
 require_relative "cyberarm_engine/animator"
 
 require_relative "cyberarm_engine/text"
 require_relative "cyberarm_engine/timer"
 require_relative "cyberarm_engine/config_file"
 
-require_relative "cyberarm_engine/console"
-require_relative "cyberarm_engine/console/command"
-require_relative "cyberarm_engine/console/subcommand"
-require_relative "cyberarm_engine/console/commands/help_command"
-
 require_relative "cyberarm_engine/ui/dsl"
 
 require_relative "cyberarm_engine/ui/theme"
@@ -61,10 +50,16 @@ require_relative "cyberarm_engine/ui/elements/check_box"
 require_relative "cyberarm_engine/ui/elements/radio"
 require_relative "cyberarm_engine/ui/elements/progress"
 require_relative "cyberarm_engine/ui/elements/slider"
-require_relative "cyberarm_engine/ui/elements/menu"
-require_relative "cyberarm_engine/ui/elements/menu_item"
 
 require_relative "cyberarm_engine/game_state"
 require_relative "cyberarm_engine/ui/gui_state"
 
+require_relative "cyberarm_engine/model"
+require_relative "cyberarm_engine/model_cache"
+require_relative "cyberarm_engine/model/material"
+require_relative "cyberarm_engine/model/model_object"
+require_relative "cyberarm_engine/model/parser"
+require_relative "cyberarm_engine/model/parsers/wavefront_parser"
+require_relative "cyberarm_engine/model/parsers/collada_parser" if defined?(Nokogiri)
+
 require_relative "cyberarm_engine/builtin/intro_state"

lib/cyberarm_engine/animator.rb

@@ -43,177 +43,14 @@ module CyberarmEngine
       Gosu::Color.from_ahsv(alpha, hue, saturation, value)
     end
 
-    # Tween functions based on those provided here: https://github.com/danro/easing-js/blob/master/easing.js
-    # Under MIT / BSD
+    # NOTE: Use this for future reference? https://github.com/danro/easing-js/blob/master/easing.js
 
     def tween_linear(t)
       t
     end
 
-    def tween_ease_in_quad(t)
-      t ** 2
-    end
-
-    def tween_ease_out_quad(t)
-      -((t - 1) ** 2) -1
-    end
-
-    def tween_ease_in_out_quad(t)
-      return 0.5 * (t ** 2) if (t /= 0.5) < 1
-      return -0.5 * ((t -= 2) * t - 2)
-    end
-
-    def tween_ease_in_cubic(t)
-      t ** 3
-    end
-
-    def tween_ease_out_cubic(t)
-      ((t - 1) ** 3) + 1
-    end
-
-    def tween_ease_in_out_cubic(t)
-      return 0.5 * (t ** 3) if ((t /= 0.5) < 1)
-      return 0.5 * ((t - 2) ** 3) + 2
-    end
-
-    def tween_ease_in_quart(t)
-      t ** 4
-    end
-
-    def tween_ease_out_quart(t)
-      -((t - 1) ** 4) - 1
-    end
-
-    def tween_ease_in_out_quart(t)
-      return 0.5 * (t ** 4) if ((t /= 0.5) < 1)
-      return -0.5 * ((t -= 2) * (t ** 3) - 2)
-    end
-
-    def tween_ease_in_quint(t)
-      t ** 5
-    end
-
-    def tween_ease_out_quint(t)
-      ((t - 1) ** 5) + 1
-    end
-
-    def tween_ease_in_out_quint(t)
-      return 0.5 * (t ** 5) if ((t /= 0.5) < 1)
-      return 0.5 * ((t - 2) ** 5) + 2
-    end
-
-    def tween_ease_in(t) # sine
-      -Math.cos(t * (Math::PI / 2)) + 1
-    end
-
-    def tween_ease_out(t) # sine
-      Math.sin(t * (Math::PI / 2))
-    end
-
-    def tween_ease_in_out(t) # sine
+    def tween_ease_in_out(t)
       (-0.5 * (Math.cos(Math::PI * t) - 1))
     end
-
-    def tween_ease_in_expo(t)
-      (t == 0) ? 0 : 2 ** 10 * (t - 1)
-    end
-
-    def tween_ease_out_expo(t)
-      (t == 1) ? 1 : -(2 ** -10 * t) + 1
-    end
-
-    def tween_ease_in_out_expo(t)
-      return 0 if (t == 0)
-      return 1 if (t == 1)
-      return 0.5 * (2 ** 10 * (t - 1)) if ((t /= 0.5) < 1)
-      return 0.5 * (-(2 ** -10 * (t -= 1)) + 2)
-    end
-
-    def tween_ease_in_circ(t)
-      -(Math.sqrt(1 - (t * t)) - 1)
-    end
-
-    def tween_ease_out_circ(t)
-      Math.sqrt(1 - ((t - 1) ** 2))
-    end
-
-    def tween_ease_in_out_circ(t)
-      return -0.5 * (Math.sqrt(1 - t * t) - 1) if ((t /= 0.5) < 1)
-      return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1)
-    end
-
-    def tween_ease_in_back(t)
-      s = 1.70158
-      t * t * ((s + 1) * t - s)
-    end
-
-    def tween_ease_out_back(t)
-      s = 1.70158
-      (t = t - 1) * t * ((s + 1) * t + s) + 1
-    end
-
-    def tween_ease_in_out_back(t)
-      s = 1.70158
-      return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s)) if ((t /= 0.5) < 1)
-      return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2)
-    end
-
-    def tween_elastic(t)
-      -1 * (4 ** (-8 * t)) * Math.sin((t * 6 - 1) * (2 * Math::PI) / 2) + 1
-    end
-
-    def tween_swing_from_to(t)
-      s = 1.70158
-      return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s)) if (t /= 0.5) < 1
-      return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2)
-    end
-
-    def tween_swing_from(t)
-      s = 1.70158;
-      t * t * ((s + 1) * t - s)
-    end
-
-    def tween_swing_to(t)
-      s = 1.70158
-      (t -= 1) * t * ((s + 1) * t + s) + 1
-    end
-
-    def tween_bounce(t)
-      if (t < (1 / 2.75))
-        (7.5625 * t * t)
-      elsif (t < (2 / 2.75))
-        (7.5625 * (t -= (1.5 / 2.75)) * t + 0.75)
-      elsif (t < (2.5 / 2.75))
-        (7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375)
-      else
-        (7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375)
-      end
-    end
-
-    def tween_bounce_past(t)
-      if (t < (1 / 2.75))
-        # missing "2 -"?
-        (7.5625 * t * t)
-      elsif (t < (2 / 2.75))
-        2 - (7.5625 * (t -= (1.5 / 2.75)) * t + 0.75)
-      elsif (t < (2.5 / 2.75))
-        2 - (7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375)
-      else
-        2 - (7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375)
-      end
-    end
-
-    def tween_ease_from_to(t)
-      return 0.5 * (t ** 4) if ((t /= 0.5) < 1)
-      return -0.5 * ((t -= 2) * (t ** 3) - 2)
-    end
-
-    def tween_ease_from(t)
-      t ** 4
-    end
-
-    def tween_ease_to(t)
-      t ** 0.25
-    end
   end
 end

lib/cyberarm_engine/background.rb

@@ -163,18 +163,17 @@ module CyberarmEngine
       elsif background.is_a?(Range)
         set([background.begin, background.begin, background.end, background.end])
       else
-        raise ArgumentError, "background '#{background.inspect}' of type '#{background.class}' was not able to be processed"
+        raise ArgumentError, "background '#{background}' of type '#{background.class}' was not able to be processed"
       end
     end
   end
 end
 
 # Add <=> method to support Range based gradients
-# NOTE: Disabled, causes stack overflow 🙃
-# module Gosu
-#   class Color
-#     def <=>(_other)
-#       self
-#     end
-#   end
-# end
+module Gosu
+  class Color
+    def <=>(_other)
+      self
+    end
+  end
+end

lib/cyberarm_engine/background_image.rb

@@ -1,93 +0,0 @@
-module CyberarmEngine
-  class BackgroundImage
-    include CyberarmEngine::Common
-    attr_accessor :x, :y, :z, :mode
-    attr_reader :image, :width, :height, :color
-
-    def initialize(image_path: nil, x: 0, y: 0, z: 0, width: 0, height: 0, mode: :fill, color: Gosu::Color::WHITE)
-      @image_path = image_path
-      @image = get_image(image_path) if image_path
-
-      @x = x
-      @y = y
-      @z = z
-      @width = width
-      @height = height
-
-      @mode = mode
-
-      @color = color
-
-      @cached_tiling = nil
-    end
-
-    def image=(image_path)
-      @cached_tiling = nil if image_path != @image_path
-      @image_path = image_path
-      @image = image_path ? get_image(image_path) : image_path
-    end
-
-    def width=(n)
-      @cached_tiling = nil if @width != n
-      @width = n
-    end
-
-    def height=(n)
-      @cached_tiling = nil if @height != n
-      @height = n
-    end
-
-    def color=(c)
-      @cached_tiling = nil if @color != c
-      @color = c
-    end
-
-    def width_scale
-      (@width.to_f / @image.width).abs
-    end
-
-    def height_scale
-      (@height.to_f / @image.height).abs
-    end
-
-    def draw
-      return unless @image
-
-      Gosu.clip_to(@x, @y, @width, @height) do
-        send(:"draw_#{mode}")
-      end
-    end
-
-    def draw_stretch
-      @image.draw(@x, @y, @z, width_scale, height_scale, @color)
-    end
-
-    def draw_tiled
-      @cached_tiling ||= Gosu.record(@width, @height) do
-        height_scale.ceil.times do |y|
-          width_scale.ceil.times do |x|
-            @image.draw(x * @image.width, y * @image.height, @z, 1, 1, @color)
-          end
-        end
-      end
-
-      @cached_tiling.draw(@x, @y, @z)
-    end
-
-    def draw_fill
-      if (@image.width * width_scale) >= @width && (@image.height * width_scale) >= @height
-        draw_fill_width
-      else
-        draw_fill_height
-      end
-    end
-
-    def draw_fill_width
-      @image.draw(@x, @y, @z, width_scale, width_scale, @color)
-    end
-
-    def draw_fill_height
-      @image.draw(@x, @y, @z, height_scale, height_scale, @color)
-    end
-  end
-end

lib/cyberarm_engine/background_nine_slice.rb

@@ -1,11 +1,10 @@
 module CyberarmEngine
   class BackgroundNineSlice
     include CyberarmEngine::Common
-    attr_accessor :x, :y, :z, :width, :height, :left, :top, :right, :bottom, :mode, :color
-    attr_reader :image
+    attr_accessor :x, :y, :z, :width, :height
 
-    def initialize(image_path: nil, x: 0, y: 0, z: 0, width: 0, height: 0, mode: :tiled, left: 1, top: 1, right: 1, bottom: 1, color: Gosu::Color::WHITE)
-      @image = get_image(image_path) if image_path
+    def initialize(image_path:, x: 0, y: 0, z: 0, width: 64, height: 64, mode: :tiled, left: 4, top: 4, right: 56, bottom: 56)
+      @image = get_image(image_path)
 
       @x = x
       @y = y
@@ -21,33 +20,23 @@ module CyberarmEngine
       @right = right
       @bottom = bottom
 
-      @color = color
-
-      nine_slice if @image
-    end
-
-    def image=(image_path)
-      old_image = @image
-      @image = image_path ? get_image(image_path) : image_path
-      nine_slice if @image && old_image != @image
+      nine_slice
     end
 
     def nine_slice
-      # pp [@left, @top, @right, @bottom, @image.width]
+      @segment_top_left = Gosu.render(@left, @top) { @image.draw(0, 0, 0) }
+      @segment_top_right = Gosu.render(@image.width - @right, @top) { @image.draw(-@right, 0, 0) }
 
-      @segment_top_left = @image.subimage(0, 0, @left, @top)
-      @segment_top_right = @image.subimage(@image.width - @right, 0, @right, @top)
+      @segment_left = Gosu.render(@left, @bottom - @top) { @image.draw(0, -@top, 0) }
+      @segment_right = Gosu.render(@image.width - @right, @bottom - @top) { @image.draw(-@right, -@top, 0) }
 
-      @segment_left = @image.subimage(0, @top, @left, @image.height - (@top + @bottom))
-      @segment_right = @image.subimage(@image.width - @right, @top, @left, @image.height - (@top + @bottom))
+      @segment_bottom_left = Gosu.render(@left, @image.height - @bottom) { @image.draw(0, -@bottom, 0) }
+      @segment_bottom_right = Gosu.render(@image.width - @right, @image.height - @bottom) { @image.draw(-@right, -@bottom, 0) }
 
-      @segment_bottom_left = @image.subimage(0, @image.height - @bottom, @left, @bottom)
-      @segment_bottom_right = @image.subimage(@image.width - @right, @image.height - @bottom, @right, @bottom)
+      @segment_top = Gosu.render(@right - @left, @top) { @image.draw(-@left, 0, 0) }
+      @segment_bottom = Gosu.render(@right - @left, @image.height - @bottom) { @image.draw(-@left, -@bottom, 0) }
 
-      @segment_top = @image.subimage(@left, 0, @image.width - (@left + @right), @top)
-      @segment_bottom = @image.subimage(@left, @image.height - @bottom, @image.width - (@left + @right), @bottom)
-
-      @segment_middle = @image.subimage(@left, @top, @image.width - (@left + @right), @image.height - (@top + @bottom))
+      @segment_middle = Gosu.render(@right - @left, @bottom - @top) { @image.draw(-@left, -@top, 0) }
     end
 
     def cx
@@ -67,73 +56,67 @@ module CyberarmEngine
     end
 
     def width_scale
-      scale = (@width.to_f - (@left + @right)) / (@image.width - (@left + @right))
-      scale.abs
+      width_scale = (@width - (@left + (@image.width - @right))).to_f / (@right - @left)
     end
 
     def height_scale
-      scale = (@height - (@top + @bottom)).to_f / (@image.height - (@top + @bottom))
-      scale.abs
+      height_scale = (@height - (@top + (@image.height - @bottom))).to_f / (@bottom - @top)
     end
 
     def draw
-      return unless @image && @segment_top_left
-
       @mode == :tiled ? draw_tiled : draw_stretched
     end
 
     def draw_stretched
-      @segment_top_left.draw(@x, @y, @z, 1, 1, @color)
-      @segment_top.draw(@x + @segment_top_left.width, @y, @z, width_scale, 1, @color) # SCALE X
-      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z, 1, 1, @color)
+      @segment_top_left.draw(@x, @y, @z)
+      @segment_top.draw(@x + @segment_top_left.width, @y, @z, width_scale) # SCALE X
+      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z)
 
-      @segment_right.draw((@x + @width) - @segment_right.width, @y + @top, @z, 1, height_scale, @color) # SCALE Y
-      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z, 1, 1, @color)
-      @segment_bottom.draw(@x + @segment_bottom_left.width, (@y + @height) - @segment_bottom.height, @z, width_scale, 1, @color) # SCALE X
-      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z, 1, 1, @color)
-      @segment_left.draw(@x, @y + @top, @z, 1, height_scale, @color) # SCALE Y
-      @segment_middle.draw(@x + @segment_top_left.width, @y + @segment_top.height, @z, width_scale, height_scale, @color) # SCALE X and SCALE Y
+      @segment_right.draw((@x + @width) - @segment_right.width, @y + @top, @z, 1, height_scale) # SCALE Y
+      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z)
+      @segment_bottom.draw(@x + @segment_bottom_left.width, (@y + @height) - @segment_bottom.height, @z, width_scale) # SCALE X
+      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z)
+      @segment_left.draw(@x, @y + @top, @z, 1, height_scale) # SCALE Y
+      @segment_middle.draw(@x + @segment_top_left.width, @y + @segment_top.height, @z, width_scale, height_scale) # SCALE X and SCALE Y
     end
 
     def draw_tiled
-      @segment_top_left.draw(@x, @y, @z, 1, 1, @color)
-
-      # p [width_scale, height_scale]
+      @segment_top_left.draw(@x, @y, @z)
 
       Gosu.clip_to(@x + @segment_top_left.width, @y, @segment_top.width * width_scale, @segment_top.height) do
         width_scale.ceil.times do |i|
-          @segment_top.draw(@x + @segment_top_left.width + (@segment_top.width * i), @y, @z, 1, 1, @color) # SCALE X
+          @segment_top.draw(@x + @segment_top_left.width + (@segment_top.width * i), @y, @z) # SCALE X
         end
       end
 
-      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z, 1, 1, @color)
+      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z)
 
       Gosu.clip_to(@x + @width - @segment_top_right.width, @y + @top, @segment_right.width, @segment_right.height * height_scale) do
         height_scale.ceil.times do |i|
-          @segment_right.draw((@x + @width) - @segment_right.width, @y + @top + (@segment_right.height * i), @z, 1, 1, @color) # SCALE Y
+          @segment_right.draw((@x + @width) - @segment_right.width, @y + @top + (@segment_right.height * i), @z) # SCALE Y
         end
       end
 
-      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z, 1, 1, @color)
+      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z)
 
       Gosu.clip_to(@x + @segment_top_left.width, @y + @height - @segment_bottom.height, @segment_top.width * width_scale, @segment_bottom.height) do
         width_scale.ceil.times do |i|
-          @segment_bottom.draw(@x + @segment_bottom_left.width + (@segment_bottom.width * i), (@y + @height) - @segment_bottom.height, @z, 1, 1, @color) # SCALE X
+          @segment_bottom.draw(@x + @segment_bottom_left.width + (@segment_bottom.width * i), (@y + @height) - @segment_bottom.height, @z) # SCALE X
         end
       end
 
-      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z, 1, 1, @color)
+      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z)
 
       Gosu.clip_to(@x, @y + @top, @segment_left.width, @segment_left.height * height_scale) do
         height_scale.ceil.times do |i|
-          @segment_left.draw(@x, @y + @top + (@segment_left.height * i), @z, 1, 1, @color) # SCALE Y
+          @segment_left.draw(@x, @y + @top + (@segment_left.height * i), @z) # SCALE Y
         end
       end
 
       Gosu.clip_to(@x + @segment_top_left.width, @y + @segment_top.height, @width - (@segment_left.width + @segment_right.width), @height - (@segment_top.height + @segment_bottom.height)) do
         height_scale.ceil.times do |y|
           width_scale.ceil.times do |x|
-            @segment_middle.draw(@x + @segment_top_left.width + (@segment_middle.width * x), @y + @segment_top.height + (@segment_middle.height * y), @z, 1, 1, @color) # SCALE X and SCALE Y
+            @segment_middle.draw(@x + @segment_top_left.width + (@segment_middle.width * x), @y + @segment_top.height + (@segment_middle.height * y), @z) # SCALE X and SCALE Y
           end
         end
       end

lib/cyberarm_engine/builtin/intro_state.rb

@@ -7,8 +7,8 @@ module CyberarmEngine
       @title_size = 56
       @caption_size = 24
 
-      @title = CyberarmEngine::Text.new("", size: @title_size, shadow_color: 0xaa_222222, static: true)
-      @caption = CyberarmEngine::Text.new("", size: @caption_size, shadow_color: 0xaa_222222, static: true)
+      @title = CyberarmEngine::Text.new("", size: @title_size, shadow_color: 0xaa_222222)
+      @caption = CyberarmEngine::Text.new("", size: @caption_size, shadow_color: 0xaa_222222)
 
       @spacer_width = 256
       @spacer_height = 6
@@ -18,23 +18,22 @@ module CyberarmEngine
 
       @gosu_logo = generate_proxy("Gosu",     "Game Library",         0xff_111111)
       @ruby_logo = generate_proxy("Ruby",     "Programming Language", 0xff_880000)
-      @opengl_logo = generate_proxy("OpenGL", "Graphics API",         0xff_5586a4) if RUBY_ENGINE != "mruby" && defined?(OpenGL)
+      @opengl_logo = generate_proxy("OpenGL", "Graphics API",         0xff_5586a4) if defined?(OpenGL)
 
       base_time = Gosu.milliseconds
 
-      @born_time = Gosu.milliseconds
-      @continue_after = 5_000
-
       @animators = [
         Animator.new(start_time: base_time += 1000, duration: 100,   from: 0.0, to: 1.0, tween: :ease_in_out),
         Animator.new(start_time: base_time += -500, duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
         Animator.new(start_time: base_time += 500,  duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
         Animator.new(start_time: base_time += 500,  duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
         Animator.new(start_time: base_time +  500,  duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
-        Animator.new(start_time: Gosu.milliseconds + @continue_after - 1_000,  duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
 
-        Animator.new(start_time: Gosu.milliseconds + 250, duration: 500, from: 0.0, to: 1.0, tween: :swing_to) # CyberarmEngine LOGO
+        Animator.new(start_time: Gosu.milliseconds + 250, duration: 500, from: 0.0, to: 1.0, tween: :ease_in_out) # CyberarmEngine LOGO
       ]
+
+      @born_time = Gosu.milliseconds
+      @continue_after = 5_000
     end
 
     def draw
@@ -61,7 +60,7 @@ module CyberarmEngine
         Gosu::Color::WHITE
       )
 
-      @title.x = window.width / 2 - @title.text_width / 2
+      @title.x = window.width / 2 - @title.width / 2
       @title.y = (window.height / 2 + (@spacer_height / 2) + @padding) * @animators[1].transition
       @title.text = "Powered By"
 
@@ -90,8 +89,6 @@ module CyberarmEngine
           )
         end
       end
-
-      Gosu.draw_rect(0, 0, window.width, window.height, Gosu::Color.rgba(0, 0, 0, 255 * @animators[5].transition), 10_000)
     end
 
     def update
@@ -115,14 +112,14 @@ module CyberarmEngine
       height = @title_size + @caption_size + @spacer_height + 2 * @padding + @spacer_height
 
       Gosu.record(width.ceil, height.ceil) do
-        @title.x = (width - @padding * 2) / 2 - @title.text_width / 2
+        @title.x = (width - @padding * 2) / 2 - @title.width / 2
         @title.y = @padding
         @title.draw
 
         Gosu.draw_rect(0, @padding + @title_size + @padding, @spacer_width, @spacer_height, Gosu::Color::WHITE)
         Gosu.draw_rect(1, @padding + @title_size + @padding + 1, @spacer_width - 2, @spacer_height - 2, color_hint)
 
-        @caption.x =  (width - @padding * 2) / 2 - @caption.text_width / 2
+        @caption.x =  (width - @padding * 2) / 2 - @caption.width / 2
         @caption.y = @padding + @title_size + @padding + @spacer_height + @padding
         @caption.draw
       end

lib/cyberarm_engine/cache/download_manager.rb

@@ -1,5 +1,3 @@
-require "excon"
-
 module CyberarmEngine
   module Cache
     class DownloadManager

lib/cyberarm_engine/common.rb

@@ -1,7 +1,5 @@
 module CyberarmEngine
   module Common
-    ImageBlob = Data.define(:to_blob, :columns, :rows)
-
     def push_state(klass, options = {})
       window.push_state(klass, options)
     end
@@ -10,11 +8,8 @@ module CyberarmEngine
       window.current_state
     end
 
-    def previous_state(state = nil)
-      raise "Only available for CyberarmEngine::GameState and subclasses" unless is_a?(CyberarmEngine::GameState) || state.is_a?(CyberarmEngine::GameState)
-
-      i = window.states.index(state || self)
-      window.states[i - 1] unless (i - 1).negative?
+    def previous_state
+      window.previous_state
     end
 
     def pop_state
@@ -33,20 +28,8 @@ module CyberarmEngine
       window.show_cursor = boolean
     end
 
-    def find_element_by_tag(container, tag, list = [])
-      return unless container
-
-      container.children.each do |child|
-        list << child if child.style.tag == tag
-
-        find_element_by_tag(child, tag, list) if child.is_a?(CyberarmEngine::Element::Container)
-      end
-
-      list.first
-    end
-
-    def draw_rect(x, y, width, height, color, z = 0, mode = :default)
-      Gosu.draw_rect(x, y, width, height, color, z, mode)
+    def draw_rect(x, y, width, height, color, z = 0)
+      Gosu.draw_rect(x, y, width, height, color, z)
     end
 
     def fill(color, z = 0)
@@ -54,7 +37,7 @@ module CyberarmEngine
     end
 
     def lighten(color, amount = 25)
-      if color.respond_to?(:alpha)
+      if defined?(color.alpha)
         Gosu::Color.rgba(color.red + amount, color.green + amount, color.blue + amount, color.alpha)
       else
         Gosu::Color.rgb(color.red + amount, color.green + amount, color.blue + amount)
@@ -62,7 +45,7 @@ module CyberarmEngine
     end
 
     def darken(color, amount = 25)
-      if color.respond_to?(:alpha)
+      if defined?(color.alpha)
         Gosu::Color.rgba(color.red - amount, color.green - amount, color.blue - amount, color.alpha)
       else
         Gosu::Color.rgb(color.red - amount, color.green - amount, color.blue - amount)
@@ -87,8 +70,7 @@ module CyberarmEngine
       unless asset
         instance = nil
         instance = if klass == Gosu::Image
-                     path_or_blob = path.is_a?(String) ? path : ImageBlob.new(path.to_blob, path.width, path.height)
-                     klass.new(path_or_blob, retro: retro, tileable: tileable)
+                     klass.new(path, retro: retro, tileable: tileable)
                    else
                      klass.new(path)
                    end
@@ -113,19 +95,7 @@ module CyberarmEngine
     end
 
     def window
-      CyberarmEngine::Window.instance
-    end
-
-    def control_down?
-      Gosu.button_down?(Gosu::KB_LEFT_CONTROL) || Gosu.button_down?(Gosu::KB_RIGHT_CONTROL)
-    end
-
-    def shift_down?
-      Gosu.button_down?(Gosu::KB_LEFT_SHIFT) || Gosu.button_down?(Gosu::KB_RIGHT_SHIFT)
-    end
-
-    def alt_down?
-      Gosu.button_down?(Gosu::KB_LEFT_ALT) || Gosu.button_down?(Gosu::KB_RIGHT_ALT)
+      $window
     end
   end
 end

lib/cyberarm_engine/console.rb

@@ -1,248 +0,0 @@
-# frozen_string_literal: true
-
-module CyberarmEngine
-  class Console
-    Z = 100_000
-    PADDING = 2
-    include Common
-
-    attr_reader :text_input
-
-    def initialize(font: Gosu.default_font_name)
-      @text_input = Gosu::TextInput.new
-      @width  = window.width  / 4 * 3
-      @height = window.height / 4 * 3
-
-      @input = Text.new("", x: 4, y: @height - (PADDING * 2), z: Console::Z + 1, font: font)
-      @input.y -= @input.height
-
-      @history = Text.new("", x: 4, z: Console::Z + 1, font: font, border: true, border_color: Gosu::Color::BLACK)
-      update_history_y
-
-      @command_history       = []
-      @command_history_index = 0
-
-      @memory = ""
-
-      @background_color = Gosu::Color.rgba(0, 0, 0, 200)
-      @foreground_color = Gosu::Color.rgba(100, 100, 100, 100)
-      @input_color      = Gosu::Color.rgba(100, 100, 100, 200)
-
-      @showing_cursor = false
-      @active_text_input = nil
-
-      @show_caret = true
-      @caret_last_change = Gosu.milliseconds
-      @caret_interval = 250
-      @caret_color = Gosu::Color::WHITE
-      @selection_color = Gosu::Color.new(0x5522ff22)
-    end
-
-    def draw
-      # Background/Border
-      draw_rect(0, 0, @width, @height, @background_color, Console::Z)
-      # Foregound/History
-      draw_rect(PADDING, PADDING, @width - (PADDING * 2), @height - (PADDING * 2), @foreground_color, Console::Z)
-      # Text bar
-      draw_rect(2, @input.y, @width - (PADDING * 2), @input.height, @input_color, Console::Z)
-
-      @history.draw
-      @input.draw
-      # Caret
-      if @show_caret
-        draw_rect(@input.x + caret_from_left, @input.y, Console::PADDING, @input.height, @caret_color, Console::Z + 2)
-      end
-      # Caret selection
-      if caret_start != caret_end
-        if caret_start < @text_input.selection_start
-          draw_rect(@input.x + caret_from_left, @input.y, caret_selection_width, @input.height, @selection_color, Console::Z)
-        else
-          draw_rect((@input.x + caret_from_left) - caret_selection_width, @input.y, caret_selection_width, @input.height, @selection_color, Console::Z)
-        end
-      end
-    end
-
-    def caret_from_left
-      return 0 if @text_input.caret_pos.zero?
-
-      @input.textobject.text_width(@text_input.text[0..@text_input.caret_pos - 1])
-    end
-
-    def caret_selection_width
-      @input.textobject.text_width(@text_input.text[caret_start..(caret_end - 1)])
-    end
-
-    def caret_pos
-      @text_input.caret_pos
-    end
-
-    def caret_start
-      @text_input.selection_start < @text_input.caret_pos ? @text_input.selection_start : @text_input.caret_pos
-    end
-
-    def caret_end
-      @text_input.selection_start > @text_input.caret_pos ? @text_input.selection_start : @text_input.caret_pos
-    end
-
-    def update
-      if Gosu.milliseconds - @caret_last_change >= @caret_interval
-        @caret_last_change = Gosu.milliseconds
-        @show_caret = !@show_caret
-      end
-
-      if @width != window.width || @height != @height
-        @width  = window.width  / 4 * 3
-        @height = window.height / 4 * 3
-
-        @input.y = @height - (PADDING * 2 + @input.height)
-        update_history_y
-      end
-
-      @input.text = @text_input.text
-    end
-
-    def button_down(id)
-      case id
-      when Gosu::KB_ENTER, Gosu::KB_RETURN
-        return unless @text_input.text.length.positive?
-
-        @history.text += "\n<c=999999>> #{@text_input.text}</c>"
-        @command_history << @text_input.text
-        @command_history_index = @command_history.size
-        update_history_y
-        handle_command
-        @text_input.text = ""
-
-      when Gosu::KB_UP
-        @command_history_index -= 1
-        @command_history_index = 0 if @command_history_index.negative?
-        @text_input.text = @command_history[@command_history_index]
-
-      when Gosu::KB_DOWN
-        @command_history_index += 1
-        if @command_history_index > @command_history.size - 1
-          @text_input.text = "" unless @command_history_index > @command_history.size
-          @command_history_index = @command_history.size
-        else
-          @text_input.text = @command_history[@command_history_index]
-        end
-
-      when Gosu::KB_TAB
-        split = @text_input.text.split(" ")
-
-        if !@text_input.text.end_with?(" ") && split.size == 1
-          list = abbrev_search(Console::Command.list_commands.map { |cmd| cmd.command.to_s }, @text_input.text)
-
-          if list.size == 1
-            @text_input.text = "#{list.first} "
-          elsif list.size.positive?
-            stdin("\n#{list.map { |cmd| Console::Style.highlight(cmd) }.join(', ')}")
-          end
-        elsif split.size.positive? && cmd = Console::Command.find(split.first)
-          cmd.autocomplete(self)
-        end
-
-      when Gosu::KB_BACKTICK
-        # Remove backtick character from input
-        @text_input.text = if @text_input.text.size > 1
-                             @text_input.text[0..@text_input.text.size - 2]
-                           else
-                             ""
-                           end
-
-      # Copy
-      when Gosu::KB_C
-        if control_down? && shift_down?
-          @memory = @text_input.text[caret_start..caret_end - 1] if caret_start != caret_end
-          p @memory
-        elsif control_down?
-          @text_input.text = ""
-        end
-
-      # Paste
-      when Gosu::KB_V
-        if control_down? && shift_down?
-          string = @text_input.text.chars.insert(caret_pos, @memory).join
-          _caret_pos = caret_pos
-          @text_input.text = string
-          @text_input.caret_pos = _caret_pos + @memory.length
-          @text_input.selection_start = _caret_pos + @memory.length
-        end
-
-      # Cut
-      when Gosu::KB_X
-        if control_down? && shift_down?
-          @memory = @text_input.text[caret_start..caret_end - 1] if caret_start != caret_end
-          string  = @text_input.text.chars
-          Array(caret_start..caret_end - 1).each_with_index do |i, j|
-            string.delete_at(i - j)
-          end
-
-          @text_input.text = string.join
-        end
-
-      # Delete word to left of caret
-      when Gosu::KB_W
-        if control_down?
-          split = @text_input.text.split(" ")
-          split.delete(split.last)
-          @text_input.text = split.join(" ")
-        end
-
-      # Clear history
-      when Gosu::KB_L
-        @history.text = "" if control_down?
-      end
-    end
-
-    def button_up(id)
-    end
-
-    def update_history_y
-      @history.y = @height - (PADDING * 2) - @input.height - (@history.text.lines.count * @history.textobject.height)
-    end
-
-    def handle_command
-      string = @text_input.text
-      split  = string.split(" ")
-      command = split.first
-      arguments = split.length.positive? ? split[1..split.length - 1] : []
-
-      CyberarmEngine::Console::Command.use(command, arguments, self)
-    end
-
-    def abbrev_search(array, text)
-      return [] unless text.length.positive?
-
-      list = []
-      Abbrev.abbrev(array).each do |abbrev, value|
-        next unless abbrev&.start_with?(text)
-
-        list << value
-      end
-
-      list.uniq
-    end
-
-    def stdin(string)
-      @history.text += "\n#{string}"
-      update_history_y
-    end
-
-    def focus
-      @active_text_input = window.text_input
-      window.text_input = @text_input
-
-      @showing_cursor = window.needs_cursor
-      window.needs_cursor = true
-
-      @show_caret = true
-      @caret_last_change = Gosu.milliseconds
-    end
-
-    def blur
-      window.text_input  = @active_text_input
-      window.needs_cursor = @showing_cursor
-    end
-  end
-end

lib/cyberarm_engine/console/command.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-module CyberarmEngine
-  class Console
-    module Style
-      def self.error(string)
-        "<c=ff5555>#{string}</c>"
-      end
-
-      def self.warn(string)
-        "<c=ff7700>#{string}</c>"
-      end
-
-      def self.notice(string)
-        "<c=55ff55>#{string}</c>"
-      end
-
-      def self.highlight(string, color = "5555ff")
-        "<c=#{color}>#{string}</c>"
-      end
-    end
-
-    class Command
-      def self.inherited(subclass)
-        @list ||= []
-        @commands ||= []
-        @list << subclass
-      end
-
-      def self.setup
-        @list ||= []
-        @commands = []
-        @list.each do |subclass|
-          cmd = subclass.new
-          if @commands.detect { |c| c.command == cmd.command }
-            raise "Command '#{cmd.command}' from '#{cmd.class}' already exists!"
-          end
-
-          @commands << cmd
-        end
-      end
-
-      def self.use(command, arguments, console)
-        found_command = @commands.detect { |cmd| cmd.command == command.to_sym }
-
-        if found_command
-          found_command.handle(arguments, console)
-        else
-          console.stdin("Command #{Style.error(command)} not found.")
-        end
-      end
-
-      def self.find(command)
-        @commands.detect { |cmd| cmd.command == command.to_sym }
-      end
-
-      def self.list_commands
-        @commands
-      end
-
-      def initialize
-        @store = {}
-        @subcommands = []
-
-        setup
-      end
-
-      def setup
-      end
-
-      def subcommand(command, type)
-        if @subcommands.detect { |subcmd| subcmd.command == command.to_sym }
-          raise "Subcommand '#{command}' for '#{self.command}' already exists!"
-        end
-
-        @subcommands << SubCommand.new(self, command, type)
-      end
-
-      def get(key)
-        @store[key]
-      end
-
-      def set(key, value)
-        @store[key] = value
-      end
-
-      def group
-        raise NotImplementedError
-      end
-
-      def command
-        raise NotImplementedError
-      end
-
-      def handle(arguments, console)
-        raise NotImplementedError
-      end
-
-      def autocomplete(console)
-        split = console.text_input.text.split(" ")
-
-        if @subcommands.size.positive?
-          if !console.text_input.text.end_with?(" ") && split.size == 2
-            list = console.abbrev_search(@subcommands.map { |cmd| cmd.command.to_s }, split.last)
-
-            if list.size == 1
-              console.text_input.text = "#{split.first} #{list.first} "
-            else
-              return unless list.size.positive?
-
-              console.stdin(list.map { |cmd| Console::Style.highlight(cmd) }.join(", ").to_s)
-            end
-
-          # List available options on subcommand
-          elsif (console.text_input.text.end_with?(" ") && split.size == 2) || !console.text_input.text.end_with?(" ") && split.size == 3
-            subcommand = @subcommands.detect { |cmd| cmd.command.to_s == (split[1]) }
-
-            if subcommand
-              if split.size == 2
-                console.stdin("Available options: #{subcommand.values.map { |value| Console::Style.highlight(value) }.join(',')}")
-              else
-                list = console.abbrev_search(subcommand.values, split.last)
-                if list.size == 1
-                  console.text_input.text = "#{split.first} #{split[1]} #{list.first} "
-                elsif list.size.positive?
-                  console.stdin("Available options: #{list.map { |value| Console::Style.highlight(value) }.join(',')}")
-                end
-              end
-            end
-
-          # List available subcommands if command was entered and has only a space after it
-          elsif console.text_input.text.end_with?(" ") && split.size == 1
-            console.stdin("Available subcommands: #{@subcommands.map { |cmd| Console::Style.highlight(cmd.command) }.join(', ')}")
-          end
-        end
-      end
-
-      def handle_subcommand(arguments, console)
-        if arguments.size.zero?
-          console.stdin(usage)
-          return
-        end
-        subcommand = arguments.delete_at(0)
-
-        found_command = @subcommands.detect { |cmd| cmd.command == subcommand.to_sym }
-        if found_command
-          found_command.handle(arguments, console)
-        else
-          console.stdin("Unknown subcommand #{Style.error(subcommand)} for #{Style.highlight(command)}")
-        end
-      end
-
-      def usage
-        raise NotImplementedError
-      end
-    end
-  end
-end

lib/cyberarm_engine/console/commands/help_command.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module CyberarmEngine
-  class Console
-    class HelpCommand < CyberarmEngine::Console::Command
-      def group
-        :global
-      end
-
-      def command
-        :help
-      end
-
-      def handle(arguments, console)
-        console.stdin(usage(arguments.first))
-      end
-
-      def autocomplete(console)
-        split = console.text_input.text.split(" ")
-        if !console.text_input.text.start_with?(" ") && split.size == 2
-          list = console.abbrev_search(Command.list_commands.map { |cmd| cmd.command.to_s }, split.last)
-          if list.size == 1
-            console.text_input.text = "#{split.first} #{list.first} "
-          elsif list.size > 1
-            console.stdin(list.map { |cmd| Style.highlight(cmd) }.join(", "))
-          end
-        end
-      end
-
-      def usage(command = nil)
-        if command
-          if cmd = Command.find(command)
-            cmd.usage
-          else
-            "#{Style.error(command)} is not a command"
-          end
-        else
-          "Available commands:\n#{Command.list_commands.map { |cmd| Style.highlight(cmd.command).to_s }.join(', ')}"
-        end
-      end
-    end
-  end
-end

lib/cyberarm_engine/console/subcommand.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module CyberarmEngine
-  class Console
-    class Command
-      class SubCommand
-        def initialize(parent, command, type)
-          @parent = parent
-          @command = command
-          @type = type
-        end
-
-        attr_reader :command
-
-        def handle(arguments, console)
-          if arguments.size > 1
-            console.stdin("to many arguments for #{Style.highlight(command.to_s)}, got #{Style.error(arguments.size)} expected #{Style.notice(1)}.")
-            return
-          end
-
-          case @type
-          when :boolean
-            case arguments.last
-            when "", nil
-              var = @parent.get(command.to_sym) || false
-              console.stdin("#{command}: #{Style.highlight(var)}")
-            when "on"
-              var = @parent.set(command.to_sym, true)
-              console.stdin("#{command} => #{Style.highlight(var)}")
-            when "off"
-              var = @parent.set(command.to_sym, false)
-              console.stdin("#{command} => #{Style.highlight(var)}")
-            else
-              console.stdin("Invalid argument for #{Style.highlight(command.to_s)}, got #{Style.error(arguments.last)} expected #{Style.notice('on')}, or #{Style.notice('off')}.")
-            end
-          when :string
-            case arguments.last
-            when "", nil
-              var = @parent.get(command.to_sym) || "\"\""
-              console.stdin("#{command}: #{Style.highlight(var)}")
-            else
-              var = @parent.set(command.to_sym, arguments.last)
-              console.stdin("#{command} => #{Style.highlight(var)}")
-            end
-          when :integer
-            case arguments.last
-            when "", nil
-              var = @parent.get(command.to_sym) || "nil"
-              console.stdin("#{command}: #{Style.highlight(var)}")
-            else
-              begin
-                var = @parent.set(command.to_sym, Integer(arguments.last))
-                console.stdin("#{command} => #{Style.highlight(var)}")
-              rescue ArgumentError
-                console.stdin("Error: #{Style.error("Expected an integer, got '#{arguments.last}'")}")
-              end
-            end
-          when :decimal
-            case arguments.last
-            when "", nil
-              var = @parent.get(command.to_sym) || "nil"
-              console.stdin("#{command}: #{Style.highlight(var)}")
-            else
-              begin
-                var = @parent.set(command.to_sym, Float(arguments.last))
-                console.stdin("#{command} => #{Style.highlight(var)}")
-              rescue ArgumentError
-                console.stdin("Error: #{Style.error("Expected a decimal or integer, got '#{arguments.last}'")}")
-              end
-            end
-          else
-            raise RuntimeError
-          end
-        end
-
-        def values
-          case @type
-          when :boolean
-            %w[on off]
-          else
-            []
-          end
-        end
-
-        def usage
-          case @type
-          when :boolean
-            "#{Style.highlight(command)} #{Style.notice('[on|off]')}"
-          when :string
-            "#{Style.highlight(command)} #{Style.notice('[string]')}"
-          when :integer
-            "#{Style.highlight(command)} #{Style.notice('[0]')}"
-          when :decimal
-            "#{Style.highlight(command)} #{Style.notice('[0.0]')}"
-          end
-        end
-      end
-    end
-  end
-end

lib/cyberarm_engine/game_object.rb

@@ -7,7 +7,7 @@ module CyberarmEngine
     attr_reader :alpha
 
     def initialize(options = {})
-      window.current_state.add_game_object(self) if options[:auto_manage] || options[:auto_manage].nil?
+      $window.current_state.add_game_object(self) if options[:auto_manage] || options[:auto_manage].nil?
 
       @options = options
       @image = options[:image] ? image(options[:image]) : nil
@@ -42,7 +42,7 @@ module CyberarmEngine
         @radius = if options[:radius]
                     options[:radius]
                   else
-                    @image.respond_to?(:width) ? ((@image.width + @image.height) / 4) * scale : 1
+                    defined?(@image.width) ? ((@image.width + @image.height) / 4) * scale : 1
                   end
       end
     end
@@ -55,9 +55,9 @@ module CyberarmEngine
 
       if $debug
         show_debug_heading
-        Gosu.draw_circle(@position.x, @position.y, radius, 9999, @debug_color)
+        $window.draw_circle(@position.x, @position.y, radius, 9999, @debug_color)
         if @debug_text.text != ""
-          Gosu.draw_rect(@debug_text.x - 10, (@debug_text.y - 10), @debug_text.width + 20, @debug_text.height + 20,
+          $window.draw_rect(@debug_text.x - 10, (@debug_text.y - 10), @debug_text.width + 20, @debug_text.height + 20,
                             Gosu::Color.rgba(0, 0, 0, 200), 9999)
           @debug_text.draw
         end
@@ -102,13 +102,13 @@ module CyberarmEngine
     end
 
     def _x_visible
-      x.between?((window.width / 2) - @world_center_point.x, (window.width / 2) + @world_center_point.x) ||
-        x.between?((@world_center_point.x - window.width / 2), (window.width / 2) + @world_center_point.x)
+      x.between?(($window.width / 2) - @world_center_point.x, ($window.width / 2) + @world_center_point.x) ||
+        x.between?((@world_center_point.x - $window.width / 2), ($window.width / 2) + @world_center_point.x)
     end
 
     def _y_visible
-      y.between?((window.height / 2) - @world_center_point.y, (window.height / 2) + @world_center_point.y) ||
-        y.between?(@world_center_point.y - (window.height / 2), (window.height / 2) + @world_center_point.y)
+      y.between?(($window.height / 2) - @world_center_point.y, ($window.height / 2) + @world_center_point.y) ||
+        y.between?(@world_center_point.y - ($window.height / 2), ($window.height / 2) + @world_center_point.y)
     end
 
     def heading(ahead_by = 100, _object = nil, angle_only = false)
@@ -153,6 +153,10 @@ module CyberarmEngine
       @color = Gosu::Color.rgba(@color.red, @color.green, @color.blue, int)
     end
 
+    def draw_rect(x, y, width, height, color, z = 0)
+      $window.draw_rect(x, y, width, height, color, z)
+    end
+
     def button_up(id)
     end
 
@@ -186,12 +190,12 @@ module CyberarmEngine
     # Duplication... so DRY.
     def each_circle_collision(object, _resolve_with = :width, &block)
       if object.class != Class && object.instance_of?(object.class)
-        window.current_state.game_objects.select { |i| i.instance_of?(object.class) }.each do |o|
+        $window.current_state.game_objects.select { |i| i.instance_of?(object.class) }.each do |o|
           distance = Gosu.distance(x, y, object.x, object.y)
           block.call(o, object) if distance <= radius + object.radius && block
         end
       else
-        list = window.current_state.game_objects.select { |i| i.instance_of?(object) }
+        list = $window.current_state.game_objects.select { |i| i.instance_of?(object) }
         list.each do |o|
           next if self == o
 
@@ -202,9 +206,9 @@ module CyberarmEngine
     end
 
     def destroy
-      if window.current_state
-        window.current_state.game_objects.each do |o|
-          window.current_state.game_objects.delete(o) if o.is_a?(self.class) && o == self
+      if $window.current_state
+        $window.current_state.game_objects.each do |o|
+          $window.current_state.game_objects.delete(o) if o.is_a?(self.class) && o == self
         end
       end
     end
@@ -216,13 +220,13 @@ module CyberarmEngine
 
     def self.each_circle_collision(object, _resolve_with = :width, &block)
       if object.class != Class && object.instance_of?(object.class)
-        window.current_state.game_objects.select { |i| i.instance_of?(self) }.each do |o|
+        $window.current_state.game_objects.select { |i| i.instance_of?(self) }.each do |o|
           distance = Gosu.distance(o.x, o.y, object.x, object.y)
           block.call(o, object) if distance <= o.radius + object.radius && block
         end
       else
-        lista = window.current_state.game_objects.select { |i| i.instance_of?(self) }
-        listb = window.current_state.game_objects.select { |i| i.instance_of?(object) }
+        lista = $window.current_state.game_objects.select { |i| i.instance_of?(self) }
+        listb = $window.current_state.game_objects.select { |i| i.instance_of?(object) }
         lista.product(listb).each do |o, o2|
           next if o == o2
 
@@ -234,9 +238,9 @@ module CyberarmEngine
 
     def self.destroy_all
       INSTANCES.clear
-      if window.current_state
-        window.current_state.game_objects.each do |o|
-          window.current_state.game_objects.delete(o) if o.is_a?(self.class)
+      if $window.current_state
+        $window.current_state.game_objects.each do |o|
+          $window.current_state.game_objects.delete(o) if o.is_a?(self.class)
         end
       end
     end

lib/cyberarm_engine/game_state.rb

@@ -9,7 +9,7 @@ module CyberarmEngine
       @options = options
       @game_objects = []
       @global_pause = false
-      window.text_input = nil unless options[:preserve_text_input]
+      $window.text_input = nil unless options[:preserve_text_input]
 
       @down_keys = {}
     end
@@ -30,27 +30,48 @@ module CyberarmEngine
       @game_objects.each(&:update)
     end
 
-    def needs_redraw?
-      true
+    def draw_bounding_box(box)
+      x = box.x
+      y = box.y
+      max_x = box.max_x
+      max_y = box.max_y
+
+      color = Gosu::Color.rgba(255, 127, 64, 240)
+
+      # pipe = 4
+      # Gosu.draw_rect(x-width, y-height, x+(width*2), y+(height*2), color, Float::INFINITY)
+      # puts "BB render: #{x}:#{y} w:#{x.abs+width} h:#{y.abs+height}"
+      # Gosu.draw_rect(x, y, x.abs+width, y.abs+height, color, Float::INFINITY)
+
+      # TOP LEFT to BOTTOM LEFT
+      $window.draw_line(
+        x, y, color,
+        x, max_y, color,
+        Float::INFINITY
+      )
+      # BOTTOM LEFT to BOTTOM RIGHT
+      $window.draw_line(
+        x, max_y, color,
+        max_x, max_y, color,
+        Float::INFINITY
+      )
+      # BOTTOM RIGHT to TOP RIGHT
+      $window.draw_line(
+        max_x, max_y, color,
+        max_x, y, color,
+        Float::INFINITY
+      )
+      # TOP RIGHT to TOP LEFT
+      $window.draw_line(
+        max_x, y, color,
+        x, y, color,
+        Float::INFINITY
+      )
     end
 
-    def needs_repaint?
-      true
-    end
-
-    def drop(filename)
-    end
-
-    def gamepad_connected(index)
-    end
-
-    def gamepad_disconnected(index)
-    end
-
-    def gain_focus
-    end
-
-    def lose_focus
+    def destroy
+      @options.clear
+      @game_objects.clear
     end
 
     def button_down(id)
@@ -69,54 +90,6 @@ module CyberarmEngine
       end
     end
 
-    def close
-      window.close!
-    end
-
-    def draw_bounding_box(box)
-      x = box.x
-      y = box.y
-      max_x = box.max_x
-      max_y = box.max_y
-
-      color = Gosu::Color.rgba(255, 127, 64, 240)
-
-      # pipe = 4
-      # Gosu.draw_rect(x-width, y-height, x+(width*2), y+(height*2), color, Float::INFINITY)
-      # puts "BB render: #{x}:#{y} w:#{x.abs+width} h:#{y.abs+height}"
-      # Gosu.draw_rect(x, y, x.abs+width, y.abs+height, color, Float::INFINITY)
-
-      # TOP LEFT to BOTTOM LEFT
-      Gosu.draw_line(
-        x, y, color,
-        x, max_y, color,
-        Float::INFINITY
-      )
-      # BOTTOM LEFT to BOTTOM RIGHT
-      Gosu.draw_line(
-        x, max_y, color,
-        max_x, max_y, color,
-        Float::INFINITY
-      )
-      # BOTTOM RIGHT to TOP RIGHT
-      Gosu.draw_line(
-        max_x, max_y, color,
-        max_x, y, color,
-        Float::INFINITY
-      )
-      # TOP RIGHT to TOP LEFT
-      Gosu.draw_line(
-        max_x, y, color,
-        x, y, color,
-        Float::INFINITY
-      )
-    end
-
-    def destroy
-      @options.clear
-      @game_objects.clear
-    end
-
     def add_game_object(object)
       @game_objects << object
     end

lib/cyberarm_engine/gosu_ext/draw_arc.rb

@@ -1,111 +0,0 @@
-module Gosu
-  # Draw an arc around the point x and y.
-  #
-  # Color accepts the following: *Gosu::Color*, *Array* (with 2 colors), or a *Hash* with keys: _from:_ and _to:_ both colors.
-  #
-  # With a *Gosu::Color* the arc will be painted with color
-  #
-  # With an *Array* the first *Gosu::Color* with be the innermost color and the last *Gosu::Color* with be the outermost color
-  #
-  # With a *Hash* the arc will smoothly transition from the start of the arc to the end
-  # @example
-  #   # Using a Hash
-  #   Gosu.draw_arc(100, 100, 50, 0.5, 128, 4, {from: Gosu::Color::BLUE, to: Gosu::Color::GREEN}, 0, :default)
-  #
-  #   # Using an Array
-  #   Gosu.draw_arc(100, 100, 50, 0.5, 128, 4, [Gosu::Color::BLUE, Gosu::Color::GREEN], 0, :default)
-  #
-  #   # Using a Gosu::Color
-  #   Gosu.draw_arc(100, 100, 50, 0.5, 128, 4, Gosu::Color::BLUE, 0, :default)
-  #
-  #
-  # @param x X position.
-  # @param y Y position.
-  # @param radius radius of arc, in pixels.
-  # @param percentage how complete the segment is, _0.0_ is 0% and _1.0_ is 100%.
-  # @param segments how many segments for arc, more will appear smoother, less will appear jagged.
-  # @param thickness how thick arc will be.
-  # @param color [Gosu::Color, Array<Gosu::Color, Gosu::Color>, Hash{from: start_color, to: end_color}] color or colors to draw the arc with.
-  # @param z Z position.
-  # @param mode blend mode.
-  #
-  # @note _thickness_ is subtracted from radius, meaning that the arc will grow towards the origin, not away from it.
-  #
-  # @return [void]
-  def self.draw_arc(x, y, radius, percentage = 1.0, segments = 128, thickness = 4, color = Gosu::Color::WHITE, z = 0, mode = :default)
-    return if percentage == 0.0
-
-    angle_per_segment = 360.0 / segments
-    arc_completion = 360 * percentage
-    next_segment_angle = angle_per_segment
-
-    angle = 0
-    loop do
-      break if angle >= arc_completion
-
-      if angle + angle_per_segment > arc_completion
-        next_segment_angle = arc_completion - angle
-      else
-        next_segment_angle = angle_per_segment
-      end
-
-      angle2 = angle + next_segment_angle
-
-      point_a_left_x = x + Gosu.offset_x(angle, radius - thickness)
-      point_a_left_y = y + Gosu.offset_y(angle, radius - thickness)
-
-      point_a_right_x = x + Gosu.offset_x(angle2, radius - thickness)
-      point_a_right_y = y + Gosu.offset_y(angle2, radius - thickness)
-
-      point_b_left_x = x + Gosu.offset_x(angle, radius)
-      point_b_left_y = y + Gosu.offset_y(angle, radius)
-
-      point_b_right_x = x + Gosu.offset_x(angle2, radius)
-      point_b_right_y = y + Gosu.offset_y(angle2, radius)
-
-      if color.is_a?(Array)
-        Gosu.draw_quad(
-          point_a_left_x, point_a_left_y, color.first,
-          point_b_left_x, point_b_left_y, color.last,
-          point_a_right_x, point_a_right_y, color.first,
-          point_b_right_x, point_b_right_y, color.last,
-          z, mode
-        )
-      elsif color.is_a?(Hash)
-        start_color = color[:from]
-        end_color = color[:to]
-
-        color_a = Gosu::Color.rgba(
-          (end_color.red - start_color.red) * (angle / 360.0) + start_color.red,
-          (end_color.green - start_color.green) * (angle / 360.0) + start_color.green,
-          (end_color.blue - start_color.blue) * (angle / 360.0) + start_color.blue,
-          (end_color.alpha - start_color.alpha) * (angle / 360.0) + start_color.alpha,
-        )
-        color_b = Gosu::Color.rgba(
-          (end_color.red - start_color.red) * (angle2 / 360.0) + start_color.red,
-          (end_color.green - start_color.green) * (angle2 / 360.0) + start_color.green,
-          (end_color.blue - start_color.blue) * (angle2 / 360.0) + start_color.blue,
-          (end_color.alpha - start_color.alpha) * (angle2 / 360.0) + start_color.alpha,
-        )
-
-        Gosu.draw_quad(
-          point_a_left_x, point_a_left_y, color_a,
-          point_b_left_x, point_b_left_y, color_a,
-          point_a_right_x, point_a_right_y, color_b,
-          point_b_right_x, point_b_right_y, color_b,
-          z, mode
-        )
-      else
-        Gosu.draw_quad(
-          point_a_left_x, point_a_left_y, color,
-          point_b_left_x, point_b_left_y, color,
-          point_a_right_x, point_a_right_y, color,
-          point_b_right_x, point_b_right_y, color,
-          z, mode
-        )
-      end
-
-      angle += next_segment_angle
-    end
-  end
-end

lib/cyberarm_engine/gosu_ext/draw_circle.rb

@@ -1,31 +0,0 @@
-module Gosu
-  ##
-  # Draw a filled circled around point X and Y.
-  #
-  # @param x X position.
-  # @param y Y position.
-  # @param radius radius of circle, in pixels.
-  # @param step_size resolution of circle, more steps will apear smoother, less will appear jagged.
-  # @param color color to draw circle with.
-  # @param mode blend mode.
-  #
-  # @return [void]
-  def self.draw_circle(x, y, radius, step_size = 36, color = Gosu::Color::WHITE, z = 0, mode = :default)
-    step_size = (360.0 / step_size).floor
-
-    0.step(359, step_size) do |angle|
-      angle2 = angle + step_size
-
-      point_lx = x + Gosu.offset_x(angle, radius)
-      point_ly = y + Gosu.offset_y(angle, radius)
-      point_rx = x + Gosu.offset_x(angle2, radius)
-      point_ry = y + Gosu.offset_y(angle2, radius)
-
-      Gosu.draw_triangle(
-        point_lx, point_ly, color,
-	      point_rx, point_ry, color,
-	      x, y, color, z, mode
-      )
-    end
-  end
-end

lib/cyberarm_engine/gosu_ext/draw_path.rb

@@ -1,17 +0,0 @@
-module Gosu
-  PathNode = Struct.new(:x, :y)
-
-  def self.draw_path(nodes, color = Gosu::Color::WHITE, z = 0, mode = :default)
-    last_node = nodes.first
-
-    nodes[1..nodes.size - 1].each do |current_node|
-      Gosu.draw_line(
-        last_node.x, last_node.y, color,
-        current_node.x, current_node.y, color,
-        z, mode
-      )
-
-      last_node = current_node
-    end
-  end
-end

lib/cyberarm_engine/model.rb

@@ -1,13 +1,9 @@
 module CyberarmEngine
   class Model
-    include OpenGL
-    include CyberarmEngine
-
     attr_accessor :objects, :materials, :vertices, :uvs, :texures, :normals, :faces, :colors, :bones, :material_file,
                   :current_material, :current_object, :vertex_count, :smoothing
     attr_reader :position, :bounding_box, :textured_material, :file_path, :positions_buffer_id, :colors_buffer_id,
-                :normals_buffer_id, :uvs_buffer_id, :textures_buffer_id, :vertex_array_id, :aabb_tree,
-                :vertices_count
+                :normals_buffer_id, :uvs_buffer_id, :textures_buffer_id, :vertex_array_id, :aabb_tree
 
     def initialize(file_path:)
       @file_path = file_path
@@ -27,8 +23,6 @@ module CyberarmEngine
       @bones    = []
       @smoothing = 0
 
-      @vertices_count = 0
-
       @bounding_box = BoundingBox.new
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
 
@@ -38,8 +32,6 @@ module CyberarmEngine
 
       parse(parser)
 
-      @vertices_count = @vertices.size
-
       @has_texture = false
 
       @materials.each do |_key, material|
@@ -53,8 +45,7 @@ module CyberarmEngine
       @objects.each { |o| @vertex_count += o.vertices.size }
 
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
-      build_collision_tree
-      puts "    Building mesh collision tree took #{((Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start_time) / 1000.0).round(2)} seconds"
+      # build_collision_tree
     end
 
     def parse(parser)
@@ -154,24 +145,24 @@ module CyberarmEngine
       glBindBuffer(GL_ARRAY_BUFFER, @positions_buffer_id)
       gl_error?
 
-      #                     in_position
+      #                     inPosition
       glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nil)
       gl_error?
       # colors
       glBindBuffer(GL_ARRAY_BUFFER, @colors_buffer_id)
-      #                     in_color
+      #                     inColor
       glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nil)
       gl_error?
       # normals
       glBindBuffer(GL_ARRAY_BUFFER, @normals_buffer_id)
-      #                     in_normal
+      #                     inNormal
       glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, nil)
       gl_error?
 
       if has_texture?
         # uvs
         glBindBuffer(GL_ARRAY_BUFFER, @uvs_buffer_id)
-        #                     in_uv
+        #                     inUV
         glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, nil)
         gl_error?
       end

lib/cyberarm_engine/model/model_object.rb

@@ -1,6 +1,6 @@
 module CyberarmEngine
   class Model
-    class Mesh
+    class ModelObject
       attr_reader :id, :name, :vertices, :uvs, :normals, :materials, :bounding_box, :debug_color
       attr_accessor :faces, :scale
 

lib/cyberarm_engine/model/parser.rb

@@ -48,12 +48,12 @@ module CyberarmEngine
         if _model
           @model.current_object = _model
         else
-          raise "Couldn't find Mesh!"
+          raise "Couldn't find ModelObject!"
         end
       end
 
       def change_object(id, name)
-        @model.objects << Model::Mesh.new(id, name)
+        @model.objects << Model::ModelObject.new(id, name)
         @model.current_object = @model.objects.last
       end
 

lib/cyberarm_engine/notification.rb

@@ -1,83 +0,0 @@
-module CyberarmEngine
-  class Notification
-    WIDTH = 500
-    HEIGHT = 64
-    EDGE_WIDTH = 8
-    TRANSITION_DURATION = 750
-    PADDING = 8
-
-    TTL_LONG   = 5_000
-    TTL_MEDIUM = 3_250
-    TTL_SHORT  = 1_500
-    TIME_TO_LIVE = TTL_MEDIUM
-
-    BACKGROUND_COLOR = Gosu::Color.new(0xaa313533)
-    EDGE_COLOR    = Gosu::Color.new(0xaa010101)
-    ICON_COLOR    = Gosu::Color.new(0xddffffff)
-    TITLE_COLOR   = Gosu::Color.new(0xddffffff)
-    TAGLINE_COLOR = Gosu::Color.new(0xddaaaaaa)
-
-    TITLE_SIZE = 28
-    TAGLINE_SIZE = 18
-    ICON_SIZE = HEIGHT - PADDING * 2
-
-    TITLE_FONT = Gosu::Font.new(TITLE_SIZE, bold: true)
-    TAGLINE_FONT = Gosu::Font.new(TAGLINE_SIZE)
-
-    PRIORITY_HIGH   = 1.0
-    PRIORITY_MEDIUM = 0.5
-    PRIORITY_LOW    = 0.0
-
-    LINEAR_TRANSITION = :linear
-    EASE_IN_OUT_TRANSITION = :ease_in_out
-
-    attr_reader :priority, :title, :tagline, :icon, :time_to_live, :transition_duration, :transition_type
-    def initialize(
-      host:, priority:, title:, title_color: TITLE_COLOR, tagline: "", tagline_color: TAGLINE_COLOR, icon: nil, icon_color: ICON_COLOR,
-      edge_color: EDGE_COLOR, background_color: BACKGROUND_COLOR, time_to_live: TIME_TO_LIVE, transition_duration: TRANSITION_DURATION,
-      transition_type: EASE_IN_OUT_TRANSITION
-    )
-      @host = host
-
-      @priority = priority
-      @title = title
-      @title_color = title_color
-      @tagline = tagline
-      @tagline_color = tagline_color
-      @icon = icon
-      @icon_color = icon_color
-      @edge_color = edge_color
-      @background_color = background_color
-      @time_to_live = time_to_live
-      @transition_duration = transition_duration
-      @transition_type = transition_type
-
-      @icon_scale = ICON_SIZE.to_f / @icon.width if @icon
-    end
-
-    def draw
-      Gosu.draw_rect(0, 0, WIDTH, HEIGHT, @background_color)
-
-      if @host.edge == :top
-        Gosu.draw_rect(0, HEIGHT - EDGE_WIDTH, WIDTH, EDGE_WIDTH, @edge_color)
-        @icon.draw(EDGE_WIDTH + PADDING, PADDING, 0, @icon_scale, @icon_scale, @icon_color) if @icon
-
-      elsif @host.edge == :bottom
-        Gosu.draw_rect(0, 0, WIDTH, EDGE_WIDTH, @edge_color)
-        @icon.draw(EDGE_WIDTH + PADDING, PADDING, 0, @icon_scale, @icon_scale, @icon_color) if @icon
-
-      elsif @host.edge == :right
-        Gosu.draw_rect(0, 0, EDGE_WIDTH, HEIGHT, @edge_color)
-        @icon.draw(EDGE_WIDTH + PADDING, PADDING, 0, @icon_scale, @icon_scale, @icon_color) if @icon
-
-      else
-        Gosu.draw_rect(WIDTH - EDGE_WIDTH, 0, EDGE_WIDTH, HEIGHT, @edge_color)
-        @icon.draw(PADDING, PADDING, 0, @icon_scale, @icon_scale, @icon_color) if @icon
-      end
-
-      icon_space = @icon ? ICON_SIZE + PADDING : 0
-      TITLE_FONT.draw_text(@title, PADDING + EDGE_WIDTH + icon_space, PADDING, 0, 1, 1, @title_color)
-      TAGLINE_FONT.draw_text(@tagline, PADDING + EDGE_WIDTH + icon_space, PADDING + TITLE_FONT.height, 0, 1, 1, @tagline_color)
-    end
-  end
-end

lib/cyberarm_engine/notification_manager.rb

@@ -1,242 +0,0 @@
-module CyberarmEngine
-  class NotificationManager
-    EDGE_TOP = :top
-    EDGE_BOTTOM = :bottom
-    EDGE_RIGHT = :right
-    EDGE_LEFT = :left
-
-    MODE_DEFAULT = :slide
-    MODE_CIRCLE  = :circle
-
-    attr_reader :edge, :mode, :max_visible, :notifications
-    def initialize(edge: EDGE_RIGHT, mode: MODE_DEFAULT, window:, max_visible: 1)
-      @edge = edge
-      @mode = mode
-      @window = window
-      @max_visible = max_visible
-
-      @notifications = []
-      @drivers = []
-      @slots = Array.new(max_visible, nil)
-    end
-
-    def draw
-      @drivers.each do |driver|
-        case @edge
-        when :left, :right
-          x = @edge == :right ? @window.width + driver.x : -Notification::WIDTH + driver.x
-          y = driver.y + Notification::HEIGHT / 2
-
-          Gosu.translate(x, y + (Notification::HEIGHT + Notification::PADDING) * driver.slot) do
-            driver.draw
-          end
-
-        when :top, :bottom
-          x = @window.width / 2 - Notification::WIDTH / 2
-          y = @edge == :top ? driver.y - Notification::HEIGHT : @window.height + driver.y
-          slot_position = (Notification::HEIGHT + Notification::PADDING) * driver.slot
-          slot_position *= -1 if @edge == :bottom
-
-          Gosu.translate(x, y + slot_position) do
-            driver.draw
-          end
-        end
-      end
-    end
-
-    def update
-      show_next_notification if @drivers.size < @max_visible
-      @drivers.each do |driver|
-        if driver.done?
-          @slots[driver.slot] = nil
-          @drivers.delete(driver)
-        end
-      end
-
-      @drivers.each(&:update)
-    end
-
-    def show_next_notification
-      notification = @notifications.sort { |n| n.priority }.reverse.shift
-      return unless notification
-      return if available_slot_index < lowest_used_slot
-      @notifications.delete(notification)
-
-      @drivers << Driver.new(edge: @edge, mode: @mode, notification: notification, slot: available_slot_index)
-      slot = @slots[available_slot_index] = @drivers.last
-    end
-
-    def available_slot_index
-      @slots.each_with_index do |slot, i|
-        return i unless slot
-      end
-
-      return -1
-    end
-
-    def lowest_used_slot
-      @slots.each_with_index do |slot, i|
-        return i if slot
-      end
-
-      return -1
-    end
-
-    def highest_used_slot
-      _slot = -1
-      @slots.each_with_index do |slot, i|
-        _slot = i if slot
-      end
-
-      return _slot
-    end
-
-    def create_notification(**args)
-      notification = Notification.new(host: self, **args)
-      @notifications << notification
-    end
-
-    class Driver
-      attr_reader :x, :y, :notification, :slot
-      def initialize(edge:, mode:, notification:, slot:)
-        @edge = edge
-        @mode = mode
-        @notification = notification
-        @slot = slot
-
-        @x, @y = 0, 0
-        @delta = Gosu.milliseconds
-        @accumulator = 0.0
-
-        @born_at = Gosu.milliseconds
-        @duration_completed_at = Float::INFINITY
-        @transition_completed_at = Float::INFINITY
-      end
-
-      def transition_in_complete?
-        Gosu.milliseconds - @born_at >= @notification.transition_duration
-      end
-
-      def duration_completed?
-        Gosu.milliseconds - @transition_completed_at >= @notification.time_to_live
-      end
-
-      def done?
-        Gosu.milliseconds - @duration_completed_at >= @notification.transition_duration
-      end
-
-      def draw
-        ratio = 0.0
-
-        if not transition_in_complete?
-          ratio = animation_ratio
-        elsif transition_in_complete? and not duration_completed?
-          ratio = 1.0
-        elsif duration_completed?
-          ratio = 1.0 - animation_ratio
-        end
-
-        case @mode
-        when MODE_DEFAULT
-          Gosu.clip_to(0, 0, Notification::WIDTH, Notification::HEIGHT * ratio) do
-            @notification.draw
-          end
-        when MODE_CIRCLE
-          half = Notification::WIDTH / 2
-
-          Gosu.clip_to(half - (half * ratio), 0, Notification::WIDTH * ratio, Notification::HEIGHT) do
-            @notification.draw
-          end
-        end
-      end
-
-      def update
-        case @mode
-        when MODE_DEFAULT
-          update_default
-        when MODE_CIRCLE
-          update_circle
-        end
-
-        @accumulator += Gosu.milliseconds - @delta
-        @delta = Gosu.milliseconds
-      end
-
-
-      def update_default
-        case @edge
-        when :left, :right
-          if not transition_in_complete? # Slide In
-            @x = @edge == :right ? -x_offset : x_offset
-          elsif transition_in_complete? and not duration_completed?
-            @x = @edge == :right ? -Notification::WIDTH : Notification::WIDTH if @x.abs != Notification::WIDTH
-            @transition_completed_at = Gosu.milliseconds if @transition_completed_at == Float::INFINITY
-            @accumulator = 0.0
-          elsif duration_completed? # Slide Out
-            @x = @edge == :right ? x_offset - Notification::WIDTH : Notification::WIDTH - x_offset
-            @x = 0 if @edge == :left and @x <= 0
-            @x = 0 if @edge == :right and @x >= 0
-            @duration_completed_at = Gosu.milliseconds if @duration_completed_at == Float::INFINITY
-          end
-
-        when :top, :bottom
-          if not transition_in_complete? # Slide In
-            @y = @edge == :top ? y_offset : -y_offset
-          elsif transition_in_complete? and not duration_completed?
-            @y = @edge == :top ? Notification::HEIGHT : -Notification::HEIGHT if @x.abs != Notification::HEIGHT
-            @transition_completed_at = Gosu.milliseconds if @transition_completed_at == Float::INFINITY
-            @accumulator = 0.0
-          elsif duration_completed? # Slide Out
-            @y = @edge == :top ? Notification::HEIGHT - y_offset : y_offset - Notification::HEIGHT
-            @y = 0 if @edge == :top and @y <= 0
-            @y = 0 if @edge == :bottom and @y >= 0
-            @duration_completed_at = Gosu.milliseconds if @duration_completed_at == Float::INFINITY
-          end
-        end
-      end
-
-      def update_circle
-        case @edge
-        when :top, :bottom
-          @y = @edge == :top ? Notification::HEIGHT : -Notification::HEIGHT
-        when :left, :right
-          @x = @edge == :right ? -Notification::WIDTH : Notification::WIDTH
-        end
-
-        if transition_in_complete? and not duration_completed?
-          @transition_completed_at = Gosu.milliseconds if @transition_completed_at == Float::INFINITY
-          @accumulator = 0.0
-        elsif duration_completed?
-          @duration_completed_at = Gosu.milliseconds if @duration_completed_at == Float::INFINITY
-        end
-      end
-
-      def animation_ratio
-        x = (@accumulator / @notification.transition_duration)
-
-        case @notification.transition_type
-        when Notification::LINEAR_TRANSITION
-          x.clamp(0.0, 1.0)
-        when Notification::EASE_IN_OUT_TRANSITION # https://easings.net/#easeInOutQuint
-          (x < 0.5 ? 16 * x * x * x * x * x : 1 - ((-2 * x + 2) ** 5) / 2).clamp(0.0, 1.0)
-        end
-      end
-
-      def x_offset
-        if not transition_in_complete? or duration_completed?
-          Notification::WIDTH * animation_ratio
-        else
-          0
-        end
-      end
-
-      def y_offset
-        if not transition_in_complete? or duration_completed?
-          Notification::HEIGHT * animation_ratio
-        else
-          0
-        end
-      end
-    end
-  end
-end

lib/cyberarm_engine/opengl.rb

@@ -1,6 +1,5 @@
 begin
   require "opengl"
-  require "glu"
 rescue LoadError
   puts "Required gem is not installed, please install 'opengl-bindings' and try again."
   exit(1)
@@ -9,22 +8,10 @@ end
 module CyberarmEngine
   def gl_error?
     e = glGetError
-    if e != OpenGL::GL_NO_ERROR
+    if e != GL_NO_ERROR
       warn "OpenGL error detected by handler at: #{caller[0]}"
       warn "    #{gluErrorString(e)} (#{e})\n"
-      exit if Window.instance&.exit_on_opengl_error?
-    end
-  end
-
-  def preload_default_shaders
-    shaders = %w[g_buffer lighting]
-    shaders.each do |shader|
-      Shader.new(
-        name: shader,
-        includes_dir: "#{CYBERARM_ENGINE_ROOT_PATH}/assets/shaders/include",
-        vertex: "#{CYBERARM_ENGINE_ROOT_PATH}/assets/shaders/vertex/#{shader}.glsl",
-        fragment: "#{CYBERARM_ENGINE_ROOT_PATH}/assets/shaders/fragment/#{shader}.glsl"
-      )
+      exit if window.exit_on_opengl_error?
     end
   end
 end
@@ -39,15 +26,3 @@ require_relative "opengl/renderer/g_buffer"
 require_relative "opengl/renderer/bounding_box_renderer"
 require_relative "opengl/renderer/opengl_renderer"
 require_relative "opengl/renderer/renderer"
-
-require_relative "trees/aabb_tree_debug"
-require_relative "trees/aabb_node"
-require_relative "trees/aabb_tree"
-
-require_relative "model"
-require_relative "model_cache"
-require_relative "model/material"
-require_relative "model/mesh"
-require_relative "model/parser"
-require_relative "model/parsers/wavefront_parser"
-require_relative "model/parsers/collada_parser" if RUBY_ENGINE != "mruby" && defined?(Nokogiri)

lib/cyberarm_engine/opengl/light.rb

@@ -1,7 +1,5 @@
 module CyberarmEngine
   class Light
-    include OpenGL
-
     DIRECTIONAL = 0
     POINT = 1
     SPOT = 2

lib/cyberarm_engine/opengl/perspective_camera.rb

@@ -1,13 +1,10 @@
 module CyberarmEngine
   class PerspectiveCamera
-    include OpenGL
-    include GLU
-
     attr_accessor :position, :orientation, :aspect_ratio, :field_of_view,
                   :min_view_distance, :max_view_distance
 
-    def initialize(position:, aspect_ratio:, orientation: Vector.new(0, 0, 0),
-                   field_of_view: 70.0, min_view_distance: 0.1, max_view_distance: 1024.0)
+    def initialize(position:, aspect_ratio:, orientation: Vector.new(0, 0,
+                                                                     0), field_of_view: 70.0, min_view_distance: 0.1, max_view_distance: 155.0)
       @position = position
       @orientation = orientation
 

lib/cyberarm_engine/opengl/renderer/g_buffer.rb

@@ -1,9 +1,6 @@
 module CyberarmEngine
   class GBuffer
-    include OpenGL
-
     attr_reader :screen_vbo, :vertices, :uvs
-    attr_reader :width, :height
 
     def initialize(width:, height:)
       @width = width

lib/cyberarm_engine/opengl/renderer/opengl_renderer.rb

@@ -1,20 +1,14 @@
 module CyberarmEngine
   class OpenGLRenderer
-    include OpenGL
-    include CyberarmEngine
-
     @@immediate_mode_warning = false
 
     attr_accessor :show_wireframe
-    attr_reader :number_of_vertices
 
     def initialize(width:, height:, show_wireframe: false)
       @width = width
       @height = height
       @show_wireframe = show_wireframe
 
-      @number_of_vertices = 0
-
       @g_buffer = GBuffer.new(width: @width, height: @height)
     end
 
@@ -26,8 +20,6 @@ module CyberarmEngine
     end
 
     def render(camera, lights, entities)
-      @number_of_vertices = 0
-
       glViewport(0, 0, @width, @height)
       glEnable(GL_DEPTH_TEST)
 
@@ -47,13 +39,11 @@ module CyberarmEngine
             shader.uniform_transform("projection", camera.projection_matrix)
             shader.uniform_transform("view", camera.view_matrix)
             shader.uniform_transform("model", entity.model_matrix)
-            shader.uniform_vector3("camera_position", camera.position)
+            shader.uniform_vec3("cameraPosition", camera.position)
 
             gl_error?
             draw_model(entity.model, shader)
             entity.draw
-
-            @number_of_vertices += entity.model.vertices_count
           end
         end
 
@@ -100,8 +90,6 @@ module CyberarmEngine
           draw_mesh(entity.model)
           entity.draw
           glPopMatrix
-
-          @number_of_vertices += entity.model.vertices_count
         end
       end
 
@@ -157,21 +145,15 @@ module CyberarmEngine
         glBindTexture(GL_TEXTURE_2D, @g_buffer.texture(:depth))
         shader.uniform_integer("depth", 4)
 
-        # FIXME: Try to figure out how to up this to 32 and/or beyond
-        #        (currently fails with more then 7 lights passed in to shader)
-        lights.each_slice(7).each do |light_group|
-          light_group.each_with_index do |light, _i|
-            shader.uniform_integer("light_count", light_group.size)
+        lights.each_with_index do |light, _i|
+          shader.uniform_integer("light[0].type", light.type)
+          shader.uniform_vec3("light[0].direction", light.direction)
+          shader.uniform_vec3("light[0].position", light.position)
+          shader.uniform_vec3("light[0].diffuse", light.diffuse)
+          shader.uniform_vec3("light[0].ambient", light.ambient)
+          shader.uniform_vec3("light[0].specular", light.specular)
 
-            shader.uniform_integer("lights[#{_i}].type",      light.type)
-            shader.uniform_vector3("lights[#{_i}].direction", light.direction)
-            shader.uniform_vector3("lights[#{_i}].position",  light.position)
-            shader.uniform_vector3("lights[#{_i}].diffuse",   light.diffuse)
-            shader.uniform_vector3("lights[#{_i}].ambient",   light.ambient)
-            shader.uniform_vector3("lights[#{_i}].specular",  light.specular)
-
-            glDrawArrays(GL_TRIANGLES, 0, @g_buffer.vertices.size)
-          end
+          glDrawArrays(GL_TRIANGLES, 0, @g_buffer.vertices.size)
         end
 
         glBindVertexArray(0)
@@ -224,7 +206,7 @@ module CyberarmEngine
 
       offset = 0
       model.objects.each do |object|
-        shader.uniform_boolean("has_texture", object.has_texture?)
+        shader.uniform_boolean("hasTexture", object.has_texture?)
 
         if object.has_texture?
           glBindTexture(GL_TEXTURE_2D, object.materials.find { |mat| mat.texture_id }.texture_id)

lib/cyberarm_engine/opengl/renderer/renderer.rb

@@ -4,23 +4,12 @@ module CyberarmEngine
 
     def initialize
       @bounding_box_renderer = BoundingBoxRenderer.new
-      @opengl_renderer = OpenGLRenderer.new(width: CyberarmEngine::Window.instance.width, height: CyberarmEngine::Window.instance.height)
+      @opengl_renderer = OpenGLRenderer.new(width: $window.width, height: $window.height)
     end
 
     def draw(camera, lights, entities)
-      Stats.frame.start_timing(:opengl_renderer)
-
-      Stats.frame.start_timing(:opengl_model_renderer)
       @opengl_renderer.render(camera, lights, entities)
-      Stats.frame.end_timing(:opengl_model_renderer)
-
-      if @show_bounding_boxes
-        Stats.frame.start_timing(:opengl_boundingbox_renderer)
-        @bounding_box_renderer.render(entities)
-        Stats.frame.end_timing(:opengl_boundingbox_renderer)
-      end
-
-      Stats.frame.end_timing(:opengl_renderer)
+      @bounding_box_renderer.render(entities) if @show_bounding_boxes
     end
 
     def canvas_size_changed

lib/cyberarm_engine/opengl/shader.rb

@@ -2,7 +2,6 @@ module CyberarmEngine
   # Ref: https://github.com/vaiorabbit/ruby-opengl/blob/master/sample/OrangeBook/brick.rb
   class Shader
     include OpenGL
-
     @@shaders = {} # Cache for {Shader} instances
     PREPROCESSOR_CHARACTER = "@".freeze # magic character for preprocessor phase of {Shader} compilation
 
@@ -299,7 +298,6 @@ module CyberarmEngine
     # @see Shader.use Shader.use
     def use(&block)
       return unless compiled?
-
       raise "Another shader is already in use! #{Shader.active_shader.name.inspect}" if Shader.active_shader
 
       Shader.active_shader = self
@@ -387,7 +385,7 @@ module CyberarmEngine
     # @param value [Vector]
     # @param location [Integer]
     # @return [void]
-    def uniform_vector3(variable, value, location = nil)
+    def uniform_vec3(variable, value, location = nil)
       attr_loc = location || attribute_location(variable)
 
       glUniform3f(attr_loc, *value.to_a[0..2])
@@ -399,7 +397,7 @@ module CyberarmEngine
     # @param value [Vector]
     # @param location [Integer]
     # @return [void]
-    def uniform_vector4(variable, value, location = nil)
+    def uniform_vec4(variable, value, location = nil)
       attr_loc = location || attribute_location(variable)
 
       glUniform4f(attr_loc, *value.to_a)

lib/cyberarm_engine/stats.rb

@@ -1,199 +1,20 @@
 module CyberarmEngine
   class Stats
-    @frames = []
-    @frame_index = -1
-    @max_frame_history = 1024
+    @@hash = {
+      gui_recalculations_last_frame: 0
+    }
 
-    def self.new_frame
-      if @frames.size < @max_frame_history
-        @frames << Frame.new
-      else
-        @frames[@frame_index] = Frame.new
-      end
+    def self.get(key)
+      @@hash.dig(key)
     end
 
-    def self.frame
-      @frames[@frame_index]
+    def self.increment(key, n)
+      @@hash[key] += n
     end
 
-    def self.end_frame
-      frame&.complete
-
-      @frame_index += 1
-      @frame_index %= @max_frame_history
-    end
-
-    def self.frames
-      if @frames.size < @max_frame_history
-        @frames
-      else
-        @frames.rotate(@frame_index - (@max_frame_history - (@frames.size - 1)))
-      end
-    end
-
-    def self.frame_index
-      @frame_index
-    end
-
-    def self.max_frame_history
-      @max_frame_history
-    end
-
-    class Frame
-      Timing = Struct.new(:start_time, :end_time, :duration)
-
-      attr_reader :frame_timing, :counters, :timings, :multitimings
-      def initialize
-        @frame_timing = Timing.new(Gosu.milliseconds, -1, -1)
-        @attempted_multitiming = false
-
-        @counters = {
-          gui_recalculations: 0
-        }
-
-        @timings = {}
-        @multitimings = {}
-      end
-
-      def increment(key, number = 1)
-        @counters[key] ||= 0
-        @counters[key] += number
-      end
-
-      def start_timing(key)
-        raise "key must be a symbol!" unless key.is_a?(Symbol)
-        if @timings[key]
-          # FIXME: Make it not spammy...
-          # warn "Only one timing per key per frame. (Timing for #{key.inspect} already exists!)"
-          @attempted_multitiming = true
-          @multitimings[key] = true
-
-          return
-        end
-
-        @timings[key] = Timing.new(Gosu.milliseconds, -1, -1)
-      end
-
-      def end_timing(key)
-        timing = @timings[key]
-
-        # FIXME: Make it not spammy...
-        # warn "Timing #{key.inspect} already ended!" if timing.end_time != -1
-
-        timing.end_time = Gosu.milliseconds
-        timing.duration = timing.end_time - timing.start_time
-      end
-
-      def complete
-        @frame_timing.end_time = Gosu.milliseconds
-        @frame_timing.duration = @frame_timing.end_time - @frame_timing.start_time
-
-        # Lock data structures
-        @frame_timing.freeze
-        @counters.freeze
-        @timings.freeze
-        @multitimings.freeze
-      end
-
-      def complete?
-        @frame_timing.duration != -1
-      end
-
-      def attempted_multitiming?
-        @attempted_multitiming
-      end
-    end
-
-    class StatsPlotter
-      attr_reader :position
-
-      def initialize(x, y, z = Float::INFINITY, width = 128, height = 128)
-        @position = Vector.new(x, y, z)
-        @width = width
-        @height = height
-
-        @padding = 2
-        @text_size = 16
-
-        @max_timing_label = CyberarmEngine::Text.new("", x: x + @padding + 1, y: y + @padding, z: z, size: @text_size, border: true, static: true)
-        @avg_timing_label = CyberarmEngine::Text.new("", x: x + @padding + 1, y: y + @padding + @height / 2 - @text_size / 2, z: z, size: @text_size, border: true, static: true)
-        @min_timing_label = CyberarmEngine::Text.new("", x: x + @padding + 1, y: y + @height - (@text_size + @padding / 2), z: z, size: @text_size, border: true, static: true)
-
-        @data_label = CyberarmEngine::Text.new("", x: x + @padding + @width + @padding, y: y + @padding, z: z, size: @text_size, border: true, static: true)
-
-        @frame_stats = []
-        @graphs = {
-          frame_timings: []
-        }
-      end
-
-      def calculate_graphs
-        calculate_frame_timings_graph
-      end
-
-      def calculate_frame_timings_graph
-        @graphs[:frame_timings].clear
-
-        samples = @width - @padding
-        nodes = Array.new(samples.ceil) { [] }
-
-        slice = 0
-        @frame_stats.each_slice((CyberarmEngine::Stats.max_frame_history / samples.to_f).ceil) do |bucket|
-          bucket.each do |frame|
-            nodes[slice] << frame.frame_timing.duration
-          end
-
-          slice += 1
-        end
-
-        max_node = CyberarmEngine::Stats.frames.select(&:complete?).map { |f| f.frame_timing.duration }.max
-        scale = 1
-        scale = (@height - @padding).to_f / max_node
-        scale = 1 if scale > 1
-
-        nodes.each_with_index do |cluster, i|
-          break if cluster.empty?
-
-          @graphs[:frame_timings] << CyberarmEngine::Vector.new(@position.x + @padding + 1 * i, (@position.y + @height - @padding) - cluster.max * scale)
-        end
-      end
-
-      def draw
-        @frame_stats = CyberarmEngine::Stats.frames.select(&:complete?)
-        return if @frame_stats.empty?
-
-        calculate_graphs
-
-        @max_timing_label.text = "<c=d44>Max:</c> #{@frame_stats.map { |f| f.frame_timing.duration }.max.to_s.rjust(3, " ")}ms"
-        @avg_timing_label.text = "<c=f80>Avg:</c> #{(@frame_stats.map { |f| f.frame_timing.duration }.sum / @frame_stats.size).to_s.rjust(3, " ")}ms"
-        @min_timing_label.text = "<c=0d0>Min:</c> #{@frame_stats.map { |f| f.frame_timing.duration }.min.to_s.rjust(3, " ")}ms"
-
-        Gosu.draw_rect(@position.x, @position.y, @width, @height, 0xaa_222222, @position.z)
-        Gosu.draw_rect(@position.x + @padding, @position.y + @padding, @width - @padding * 2, @height - @padding * 2, 0xaa_222222, @position.z)
-
-        draw_graphs
-
-        @max_timing_label.draw
-        @avg_timing_label.draw
-        @min_timing_label.draw
-
-        # TODO: Make this optional
-        draw_timings_and_counters
-      end
-
-      def draw_graphs
-        Gosu.draw_path(@graphs[:frame_timings], Gosu::Color::WHITE, Float::INFINITY)
-      end
-
-      def draw_timings_and_counters
-        frame = @frame_stats.last
-
-        @data_label.text = "<c=f8f>COUNTERS:</c>\n#{frame.counters.map { |t, v| "#{t}: #{v}" }.join("\n")}\n\n"\
-        "<c=f80>TIMINGS:</c>\n#{frame.attempted_multitiming? ? "<c=d00>Attempted Multitiming!\nTimings may be inaccurate for:\n#{frame.multitimings.map { |m, _| m}.join("\n") }</c>\n\n" : ''}#{frame.timings.map { |t, v| "#{t}: #{v.duration}ms" }.join("\n")}"
-        Gosu.draw_rect(@data_label.x - @padding, @data_label.y - @padding, @data_label.width + @padding * 2, @data_label.height + @padding * 2, 0xdd_222222, @position.z)
-        @data_label.draw
-
-        # puts "Recalcs this frame: #{frame.counters[:gui_recalculations]} [dt: #{(CyberarmEngine::Window.dt * 1000).round} ms]" if frame.counters[:gui_recalculations] && frame.counters[:gui_recalculations].positive?
+    def self.clear
+      @@hash.each do |key, _value|
+        @@hash[key] = 0
       end
     end
   end

lib/cyberarm_engine/text.rb

@@ -3,9 +3,7 @@ module CyberarmEngine
     CACHE = {}
 
     attr_accessor :x, :y, :z, :size, :options
-    attr_reader :text, :textobject, :factor_x, :factor_y, :color,
-                :border, :border_size, :border_alpha, :border_color,
-                :shadow, :shadow_size, :shadow_alpha, :shadow_color
+    attr_reader :text, :textobject, :factor_x, :factor_y, :color, :shadow, :shadow_size, :shadow_alpha, :shadow_color
 
     def initialize(text, options = {})
       @text = text.to_s || ""
@@ -17,27 +15,16 @@ module CyberarmEngine
       @z = options[:z] || 1025
       @factor_x = options[:factor_x]  || 1
       @factor_y = options[:factor_y]  || 1
-      if options[:color]
-        @color = options[:color].is_a?(Gosu::Color) ? options[:color] : Gosu::Color.new(options[:color])
-      else
-        @color = Gosu::Color::WHITE
-      end
-      @mode      = options[:mode]      || :default
+      @color    = options[:color]     || Gosu::Color::WHITE
+      @mode     = options[:mode]      || :default
       @alignment = options[:alignment] || nil
-
-      @border   = options[:border]
-      @border   = true if options[:border].nil?
-      @border_size = options[:border_size] || 1
-      @border_alpha = options[:border_alpha] || 30
-      @border_color = options[:border_color] || Gosu::Color::BLACK
-
-      @shadow = options[:shadow]
-      @shadow_size = options[:shadow_size] || 2
+      @shadow   = true  if options[:shadow] == true
+      @shadow   = false if options[:shadow] == false
+      @shadow   = true if options[:shadow].nil?
+      @shadow_size = options[:shadow_size] || 1
       @shadow_alpha = options[:shadow_alpha] || 30
-      @shadow_color = options[:shadow_color] || Gosu::Color::BLACK
-
-      @static = options[:static] || (options[:static].nil? || options[:static] == false ? false : true)
-
+      @shadow_alpha = options[:shadow_alpha] || 30
+      @shadow_color = options[:shadow_color]
       @textobject = check_cache(@size, @font)
 
       if @alignment
@@ -45,11 +32,13 @@ module CyberarmEngine
         when :left
           @x = 0 + BUTTON_PADDING
         when :center
-          @x = (CyberarmEngine::Window.instance.width / 2) - (@textobject.text_width(@text) / 2)
+          @x = ($window.width / 2) - (@textobject.text_width(@text) / 2)
         when :right
-          @x = CyberarmEngine::Window.instance.width - BUTTON_PADDING - @textobject.text_width(@text)
+          @x = $window.width - BUTTON_PADDING - @textobject.text_width(@text)
         end
       end
+
+      self
     end
 
     def check_cache(size, font_name)
@@ -81,163 +70,90 @@ module CyberarmEngine
         @size = size
         @font = font_name
 
-        invalidate_cache!
         @textobject = check_cache(size, font_name)
       end
     end
 
     def text=(string)
-      invalidate_cache! if @text != string
+      @rendered_shadow = nil
       @text = string
     end
 
     def factor_x=(n)
-      invalidate_cache! if @factor_x != n
+      @rendered_shadow = nil
       @factor_x = n
     end
 
     def factor_y=(n)
-      invalidate_cache! if @factor_y != n
+      @rendered_shadow = nil
       @factor_y = n
     end
 
     def color=(color)
-      old_color = @color
-
-      if color
-        @color = color.is_a?(Gosu::Color) ? color : Gosu::Color.new(color)
-      else
-        raise "color cannot be nil"
-      end
-
-      invalidate_cache! if old_color != color
+      @rendered_shadow = nil
+      @color = color
     end
 
-    def border=(boolean)
-      invalidate_cache! if @border != boolean
-      @border = boolean
+    def shadow=(boolean)
+      @rendered_shadow = nil
+      @shadow = boolean
     end
 
-    def border_size=(n)
-      invalidate_cache! if @border_size != n
-      @border_size = n
+    def shadow_size=(n)
+      @rendered_shadow = nil
+      @shadow_size = n
     end
 
-    def border_alpha=(n)
-      invalidate_cache! if @border_alpha != n
-      @border_alpha = n
+    def shadow_alpha=(n)
+      @rendered_shadow = nil
+      @shadow_alpha = n
     end
 
-    def border_color=(n)
-      invalidate_cache! if @border_color != n
-      @border_color = n
+    def shadow_color=(n)
+      @rendered_shadow = nil
+      @shadow_color = n
     end
 
     def width(text = @text)
-      markup_width(text)
-    end
-
-    def text_width(text = @text)
-      spacing = 0
-      spacing += @border_size if @border
-      spacing += @shadow_size if @shadow
-
-      if text == @text && @static && @gosu_cached_text_image
-        @gosu_cached_text_image&.width + spacing
-      else
-        textobject.text_width(text) + spacing
-      end
+      textobject.text_width(text)
     end
 
     def markup_width(text = @text)
-      text = text.to_s
-
-      spacing = 0
-      spacing += @border_size if @border
-      spacing += @shadow_size if @shadow
-
-      if text == @text && @static && @gosu_cached_text_image
-        @gosu_cached_text_image&.width + spacing
-      else
-        textobject.markup_width(text) + spacing
-      end
+      textobject.markup_width(text)
     end
 
     def height(text = @text)
-      if text.lines.count > 0
-        text.lines.count * textobject.height + @border_size + @shadow_size
-      else
-        @textobject.height + @border_size + @shadow_size
-      end
+      text.lines.count > 0 ? text.lines.count * textobject.height : @textobject.height
     end
 
     def draw(method = :draw_markup)
-      if @static
-        if @border && !@cached_text_border_image
-          _x = @border_size
-          _y = @border_size
-          _width = method == :draw_markup ? text_width : markup_width
-          img = Gosu::Image.send(:"from_#{method.to_s.split("_").last}", @text, @size, font: @font)
+      if @shadow && !ARGV.join.include?("--no-shadow")
+        shadow_alpha = @color.alpha <= 30 ? @color.alpha : @shadow_alpha
+        shadow_color = @shadow_color || Gosu::Color.rgba(@color.red, @color.green, @color.blue,
+                                                         shadow_alpha)
+        white = Gosu::Color::WHITE
 
-          @cached_text_border_image = Gosu.render((_width + (@border_size * 2)).ceil, (height + (@border_size * 2)).ceil) do
-            img.draw(-_x, 0, @z, @factor_x, @factor_y, @border_color, @mode)
-            img.draw(-_x, -_y, @z, @factor_x, @factor_y, @border_color, @mode)
+        _x = @shadow_size
+        _y = @shadow_size
 
-            img.draw(0, -_y, @z, @factor_x, @factor_y, @border_color, @mode)
-            img.draw(_x, -_y, @z, @factor_x, @factor_y, @border_color, @mode)
+        @rendered_shadow ||= Gosu.render((width + (shadow_size * 2)).ceil, (height + (@shadow_size * 2)).ceil) do
+          @textobject.send(method, @text, _x - @shadow_size, _y, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x - @shadow_size, _y - @shadow_size, @z, @factor_x, @factor_y, white, :add)
 
-            img.draw(_x, 0, @z, @factor_x, @factor_y, @border_color, @mode)
-            img.draw(_x, _y, @z, @factor_x, @factor_y, @border_color, @mode)
+          @textobject.send(method, @text, _x, _y - @shadow_size, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x + @shadow_size, _y - @shadow_size, @z, @factor_x, @factor_y, white, :add)
 
-            img.draw(0, _y, @z, @factor_x, @factor_y, @border_color, @mode)
-            img.draw(-_x, _y, @z, @factor_x, @factor_y, @border_color, @mode)
-          end
+          @textobject.send(method, @text, _x, _y + @shadow_size, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x - @shadow_size, _y + @shadow_size, @z, @factor_x, @factor_y, white, :add)
+
+          @textobject.send(method, @text, _x + @shadow_size, _y, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x + @shadow_size, _y + @shadow_size, @z, @factor_x, @factor_y, white, :add)
         end
 
-        @cached_text_shadow_image ||= Gosu::Image.send(:"from_#{method.to_s.split("_").last}", @text, @size, font: @font) if @shadow
-
-        @gosu_cached_text_image ||= Gosu::Image.send(:"from_#{method.to_s.split("_").last}", @text, @size, font: @font)
-
-        @cached_text_border_image.draw(@x, @y, @z, @factor_x, @factor_y, @border_color, @mode) if @border
-
-        @cached_text_shadow_image.draw(@x + @shadow_size, @y + @shadow_size, @z, @factor_x, @factor_y, @shadow_color, @mode) if @shadow
-
-        @gosu_cached_text_image.draw(@x, @y, @z, @factor_x, @factor_y, @color, @mode)
-      else
-        if @border && !ARGV.join.include?("--no-border")
-          border_alpha = @color.alpha <= 30 ? @color.alpha : @border_alpha
-          border_color = @border_color || Gosu::Color.rgba(@color.red, @color.green, @color.blue,
-                                                          border_alpha)
-          white = Gosu::Color::WHITE
-
-          _x = @border_size
-          _y = @border_size
-          _width = method == :draw_markup ? text_width : markup_width
-
-          @cached_text_border_image ||= Gosu.render((_width + (border_size * 2)).ceil, (height + (@border_size * 2)).ceil) do
-            @textobject.send(method, @text, _x - @border_size, _y, @z, @factor_x, @factor_y, white, @mode)
-            @textobject.send(method, @text, _x - @border_size, _y - @border_size, @z, @factor_x, @factor_y, white, @mode)
-
-            @textobject.send(method, @text, _x, _y - @border_size, @z, @factor_x, @factor_y, white, @mode)
-            @textobject.send(method, @text, _x + @border_size, _y - @border_size, @z, @factor_x, @factor_y, white, @mode)
-
-            @textobject.send(method, @text, _x, _y + @border_size, @z, @factor_x, @factor_y, white, @mode)
-            @textobject.send(method, @text, _x - @border_size, _y + @border_size, @z, @factor_x, @factor_y, white, @mode)
-
-            @textobject.send(method, @text, _x + @border_size, _y, @z, @factor_x, @factor_y, white, @mode)
-            @textobject.send(method, @text, _x + @border_size, _y + @border_size, @z, @factor_x, @factor_y, white, @mode)
-          end
-
-          @cached_text_border_image.draw(@x - @border_size, @y - @border_size, @z, @factor_x, @factor_y, border_color)
-        end
-
-        if @shadow
-          shadow_color = @shadow_color || Gosu::Color.rgba(@color.red, @color.green, @color.blue, @shadow_alpha)
-          @textobject.send(method, @text, @x + @shadow_size, @y + @shadow_size, @z, @factor_x, @factor_y, shadow_color, @mode)
-        end
-
-        @textobject.send(method, @text, @x, @y, @z, @factor_x, @factor_y, @color, @mode)
+        @rendered_shadow.draw(@x - @shadow_size, @y - @shadow_size, @z, @factor_x, @factor_y, shadow_color)
       end
+
+      @textobject.send(method, @text, @x, @y, @z, @factor_x, @factor_y, @color, @mode)
     end
 
     def alpha=(n)
@@ -250,11 +166,5 @@ module CyberarmEngine
 
     def update
     end
-
-    def invalidate_cache!
-      @cached_text_border_image = nil
-      @cached_text_shadow_image = nil
-      @gosu_cached_text_image = nil
-    end
   end
 end

lib/cyberarm_engine/trees/aabb_node.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module CyberarmEngine
-  class AABBTree
-    class AABBNode
-      attr_accessor :bounding_box, :parent, :object
-      attr_reader :a, :b
-
-      def initialize(parent:, object:, bounding_box:)
-        @parent = parent
-        @object = object
-        @bounding_box = bounding_box
-
-        @a = nil
-        @b = nil
-      end
-
-      def a=(leaf)
-        @a = leaf
-        @a.parent = self
-      end
-
-      def b=(leaf)
-        @b = leaf
-        @b.parent = self
-      end
-
-      def leaf?
-        @object
-      end
-
-      def insert_subtree(leaf)
-        if leaf?
-          new_node = AABBNode.new(parent: nil, object: nil, bounding_box: @bounding_box.union(leaf.bounding_box))
-
-          new_node.a = self
-          new_node.b = leaf
-
-          new_node
-        else
-          cost_a = @a.bounding_box.volume + @b.bounding_box.union(leaf.bounding_box).volume
-          cost_b = @b.bounding_box.volume + @a.bounding_box.union(leaf.bounding_box).volume
-
-          if cost_a == cost_b
-            cost_a = @a.proximity(leaf)
-            cost_b = @b.proximity(leaf)
-          end
-
-          if cost_b < cost_a
-            self.b = @b.insert_subtree(leaf)
-          else
-            self.a = @a.insert_subtree(leaf)
-          end
-
-          @bounding_box = @bounding_box.union(leaf.bounding_box)
-
-          self
-        end
-      end
-
-      def search_subtree(collider, items = [])
-        if @bounding_box.intersect?(collider)
-          if leaf?
-            items << self
-          else
-            @a.search_subtree(collider, items)
-            @b.search_subtree(collider, items)
-          end
-        end
-
-        items
-      end
-
-      def remove_subtree(leaf)
-        if leaf
-          self
-        elsif leaf.parent == self
-          other_child = other(leaf)
-          other_child.parent = @parent
-          other_child
-        else
-          leaf.parent.disown_child(leaf)
-          self
-        end
-      end
-
-      def other(leaf)
-        @a == leaf ? @b : @a
-      end
-
-      def disown_child(leaf)
-        value = other(leaf)
-        raise "Can not replace child of a leaf!" if @parent.leaf?
-        raise "Node is not a child of parent!" unless leaf.child_of?(@parent)
-
-        if @parent.a == self
-          @parent.a = value
-        else
-          @parent.b = value
-        end
-
-        @parent.update_bounding_box
-      end
-
-      def child_of?(leaf)
-        self == leaf.a || self == leaf.b
-      end
-
-      def proximity(leaf)
-        (@bounding_box - leaf.bounding_box).sum.abs
-      end
-
-      def update_bounding_box
-        node = self
-
-        unless node.leaf?
-          node.bounding_box = node.a.bounding_box.union(node.b.bounding_box)
-
-          while (node = node.parent)
-            node.bounding_box = node.a.bounding_box.union(node.b.bounding_box)
-          end
-        end
-      end
-    end
-  end
-end

lib/cyberarm_engine/trees/aabb_tree.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module CyberarmEngine
-  class AABBTree
-    include AABBTreeDebug
-
-    attr_reader :root, :objects, :branches, :leaves
-
-    def initialize
-      @objects = {}
-      @root = nil
-      @branches = 0
-      @leaves   = 0
-    end
-
-    def insert(object, bounding_box)
-      raise "BoundingBox can't be nil!" unless bounding_box
-      raise "Object can't be nil!" unless object
-      # raise "Object already in tree!" if @objects[object] # FIXME
-
-      leaf = AABBNode.new(parent: nil, object: object, bounding_box: bounding_box.dup)
-      @objects[object] = leaf
-
-      insert_leaf(leaf)
-    end
-
-    def insert_leaf(leaf)
-      @root = @root ? @root.insert_subtree(leaf) : leaf
-    end
-
-    def update(object, bounding_box)
-      leaf = remove(object)
-      leaf.bounding_box = bounding_box
-      insert_leaf(leaf)
-    end
-
-    # Returns a list of all objects that collided with collider
-    def search(collider, return_nodes = false)
-      items = []
-      if @root
-        items = @root.search_subtree(collider)
-        items.map!(&:object) unless return_nodes
-      end
-
-      items
-    end
-
-    def remove(object)
-      leaf  = @objects.delete(object)
-      @root = @root.remove_subtree(leaf) if leaf
-
-      leaf
-    end
-  end
-end

lib/cyberarm_engine/trees/aabb_tree_debug.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module CyberarmEngine
-  # Gets included into AABBTree
-  module AABBTreeDebug
-    def inspect
-      @branches = 0
-      @leaves = 0
-      if @root
-        node = @root
-
-        debug_search(node.a)
-        debug_search(node.b)
-      end
-
-      puts "<#{self.class}:#{object_id}> has #{@branches} branches and #{@leaves} leaves"
-    end
-
-    def debug_search(node)
-      if node.leaf?
-        @leaves += 1
-      else
-        @branches += 1
-        debug_search(node.a)
-        debug_search(node.b)
-      end
-    end
-  end
-end

lib/cyberarm_engine/ui/border_canvas.rb

@@ -62,11 +62,11 @@ module CyberarmEngine
 
     def update
       # TOP
-      @top.x = @element.x + @element.style.border_thickness_left
+      @top.x = @element.x # + @element.border_thickness_left
       @top.y = @element.y
       @top.z = @element.z
 
-      @top.width  = @element.width - @element.style.border_thickness_left
+      @top.width  = @element.width
       @top.height = @element.style.border_thickness_top
 
       # RIGHT

lib/cyberarm_engine/ui/dsl.rb

@@ -8,8 +8,12 @@ module CyberarmEngine
       container(CyberarmEngine::Element::Stack, options, &block)
     end
 
-    def menu(options = {}, &block)
-      container(CyberarmEngine::Element::Menu, options, &block)
+    # TODO: Remove in version 0.16.0+
+    def label(text, options = {}, &block)
+      options[:parent] = element_parent
+      options[:theme] = current_theme
+
+      add_element(Element::TextBlock.new(text, options, block))
     end
 
     [
@@ -23,79 +27,72 @@ module CyberarmEngine
       "Link"
     ].each do |const|
       define_method(:"#{const.downcase}") do |text, options = {}, &block|
-        options[:parent] ||= element_parent
-        options[:theme] ||= current_theme
+        options[:parent] = element_parent
+        options[:theme] = current_theme
 
         add_element(Element.const_get(const).new(text, options, block))
       end
     end
 
     def button(text, options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       add_element(Element::Button.new(text, options, block) { block.call if block.is_a?(Proc) })
     end
 
     def list_box(options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       add_element(Element::ListBox.new(options, block) { block.call if block.is_a?(Proc) })
     end
 
-    def menu_item(text, options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
-
-      add_element(Element::MenuItem.new(text, options, block) { block.call if block.is_a?(Proc) })
-    end
-
     def edit_line(text, options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       add_element(Element::EditLine.new(text, options, block))
     end
 
     def edit_box(text, options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       add_element(Element::EditBox.new(text, options, block))
     end
 
     def toggle_button(options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       add_element(Element::ToggleButton.new(options, block))
     end
 
     def check_box(text, options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       add_element(Element::CheckBox.new(text, options, block))
     end
 
     def image(path, options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       add_element(Element::Image.new(path, options, block))
     end
 
     def progress(options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       add_element(Element::Progress.new(options, block))
     end
 
     def slider(options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       add_element(Element::Slider.new(options, block))
     end
@@ -105,7 +102,7 @@ module CyberarmEngine
     end
 
     def theme(theme)
-      element_parent.options[:theme] ||= theme
+      element_parent.options[:theme] = theme
     end
 
     def current_theme
@@ -119,22 +116,22 @@ module CyberarmEngine
     end
 
     private def element_parent
-      CyberarmEngine::Element::Container.current_container
+      $__current_container__
     end
 
     private def container(klass, options = {}, &block)
-      options[:parent] ||= element_parent
-      options[:theme] ||= current_theme
+      options[:parent] = element_parent
+      options[:theme] = current_theme
 
       _container = klass.new(options, block)
 
       old_parent = element_parent
-      CyberarmEngine::Element::Container.current_container = _container
+      $__current_container__ = _container
 
       _container.build
-      _container.parent.add(_container) unless _container.is_a?(CyberarmEngine::Element::Menu)
+      _container.parent.add(_container)
 
-      CyberarmEngine::Element::Container.current_container = old_parent
+      $__current_container__ = old_parent
 
       _container
     end

lib/cyberarm_engine/ui/element.rb

@@ -4,7 +4,7 @@ module CyberarmEngine
     include Event
     include Common
 
-    attr_accessor :x, :y, :z, :tip, :element_visible
+    attr_accessor :x, :y, :z, :enabled, :tip
     attr_reader :parent, :options, :style, :event_handler, :background_canvas, :border_canvas
 
     def initialize(options = {}, block = nil)
@@ -13,9 +13,9 @@ module CyberarmEngine
       @options = options
       @block = block
 
-      @focus   = !@options.key?(:focus)   ? false : @options[:focus]
-      @enabled = !@options.key?(:enabled) ? true  : @options[:enabled]
-      @visible = !@options.key?(:visible) ? true  : @options[:visible]
+      @focus   = @options[:focus].nil?   ? false : @options[:focus]
+      @enabled = @options[:enabled].nil? ? true  : @options[:enabled]
+      @visible = @options[:visible].nil? ? true  : @options[:visible]
       @tip     = @options[:tip] || ""
 
       @debug_color = @options[:debug_color].nil? ? Gosu::Color::RED : @options[:debug_color]
@@ -24,14 +24,11 @@ module CyberarmEngine
 
       @root ||= nil
       @gui_state ||= nil
-      @element_visible = true
 
       @x = @style.x
       @y = @style.y
       @z = @style.z
 
-      @old_width  = 0
-      @old_height = 0
       @width  = 0
       @height = 0
 
@@ -39,9 +36,7 @@ module CyberarmEngine
       @style.height = default(:height) || nil
 
       @style.background_canvas = Background.new
-      @style.background_nine_slice_canvas = BackgroundNineSlice.new
-      @style.background_image_canvas = BackgroundImage.new
-      @style.border_canvas = BorderCanvas.new(element: self)
+      @style.border_canvas     = BorderCanvas.new(element: self)
 
       @style_event = :default
 
@@ -55,35 +50,17 @@ module CyberarmEngine
     def stylize
       set_static_position
 
-      set_color
-      set_font
-
       set_padding
       set_margin
 
       set_background
-      set_background_nine_slice
-      set_background_image
 
       set_border_thickness
       set_border_color
-
-      root.gui_state.request_repaint
     end
 
-    def safe_style_fetch(key, fallback_key = nil)
-      # Attempt to return value for requested key
-      v = @style.hash.dig(@style_event, key)
-      return v if v
-
-      # Attempt to return overriding value
-      if fallback_key
-        v = @style.hash.dig(@style_event, fallback_key)
-        return v if v
-      end
-
-      # Fallback to default style
-      @style.hash.dig(:default, key) || default(key)
+    def safe_style_fetch(*args)
+      @style.hash.dig(@style_event, *args) || @style.hash.dig(:default, *args) || default(*args)
     end
 
     def set_static_position
@@ -91,60 +68,28 @@ module CyberarmEngine
       @y = @style.y if @style.y != 0
     end
 
-    def set_color
-      @style.color = safe_style_fetch(:color)
-      @text&.color = @style.color
-    end
-
-    def set_font
-      @text&.swap_font(safe_style_fetch(:text_size), safe_style_fetch(:font))
-    end
-
     def set_background
       @style.background = safe_style_fetch(:background)
 
       @style.background_canvas.background = @style.background
     end
 
-    def set_background_nine_slice
-      @style.background_nine_slice = safe_style_fetch(:background_nine_slice)
-
-      @style.background_nine_slice_mode = safe_style_fetch(:background_nine_slice_mode) || :stretch
-      @style.background_nine_slice_color = safe_style_fetch(:background_nine_slice_color) || Gosu::Color::WHITE
-      @style.background_nine_slice_canvas.color = @style.background_nine_slice_color
-
-      @style.background_nine_slice_from_edge = safe_style_fetch(:background_nine_slice_from_edge)
-
-      @style.background_nine_slice_left      = safe_style_fetch(:background_nine_slice_left, :background_nine_slice_from_edge)
-      @style.background_nine_slice_top       = safe_style_fetch(:background_nine_slice_top, :background_nine_slice_from_edge)
-      @style.background_nine_slice_right     = safe_style_fetch(:background_nine_slice_right, :background_nine_slice_from_edge)
-      @style.background_nine_slice_bottom    = safe_style_fetch(:background_nine_slice_bottom, :background_nine_slice_from_edge)
-    end
-
-    def set_background_image
-      @style.background_image = safe_style_fetch(:background_image)
-      @style.background_image_mode = safe_style_fetch(:background_image_mode) || :stretch
-      @style.background_image_color = safe_style_fetch(:background_image_color) || Gosu::Color::WHITE
-      @style.background_image_canvas.mode = @style.background_image_mode
-      @style.background_image_canvas.color = @style.background_image_color
-    end
-
     def set_border_thickness
       @style.border_thickness = safe_style_fetch(:border_thickness)
 
-      @style.border_thickness_left   = safe_style_fetch(:border_thickness_left, :border_thickness)
-      @style.border_thickness_right  = safe_style_fetch(:border_thickness_right, :border_thickness)
-      @style.border_thickness_top    = safe_style_fetch(:border_thickness_top, :border_thickness)
-      @style.border_thickness_bottom = safe_style_fetch(:border_thickness_bottom, :border_thickness)
+      @style.border_thickness_left   = safe_style_fetch(:border_thickness_left)   || @style.border_thickness
+      @style.border_thickness_right  = safe_style_fetch(:border_thickness_right)  || @style.border_thickness
+      @style.border_thickness_top    = safe_style_fetch(:border_thickness_top)    || @style.border_thickness
+      @style.border_thickness_bottom = safe_style_fetch(:border_thickness_bottom) || @style.border_thickness
     end
 
     def set_border_color
       @style.border_color = safe_style_fetch(:border_color)
 
-      @style.border_color_left   = safe_style_fetch(:border_color_left, :border_color)
-      @style.border_color_right  = safe_style_fetch(:border_color_right, :border_color)
-      @style.border_color_top    = safe_style_fetch(:border_color_top, :border_color)
-      @style.border_color_bottom = safe_style_fetch(:border_color_bottom, :border_color)
+      @style.border_color_left   = safe_style_fetch(:border_color_left)   || @style.border_color
+      @style.border_color_right  = safe_style_fetch(:border_color_right)  || @style.border_color
+      @style.border_color_top    = safe_style_fetch(:border_color_top)    || @style.border_color
+      @style.border_color_bottom = safe_style_fetch(:border_color_bottom) || @style.border_color
 
       @style.border_canvas.color = [
         @style.border_color_top,
@@ -157,32 +102,31 @@ module CyberarmEngine
     def set_padding
       @style.padding = safe_style_fetch(:padding)
 
-      @style.padding_left   = safe_style_fetch(:padding_left, :padding)
-      @style.padding_right  = safe_style_fetch(:padding_right, :padding)
-      @style.padding_top    = safe_style_fetch(:padding_top, :padding)
-      @style.padding_bottom = safe_style_fetch(:padding_bottom, :padding)
+      @style.padding_left   = safe_style_fetch(:padding_left)   || @style.padding
+      @style.padding_right  = safe_style_fetch(:padding_right)  || @style.padding
+      @style.padding_top    = safe_style_fetch(:padding_top)    || @style.padding
+      @style.padding_bottom = safe_style_fetch(:padding_bottom) || @style.padding
     end
 
     def set_margin
       @style.margin = safe_style_fetch(:margin)
 
-      @style.margin_left   = safe_style_fetch(:margin_left, :margin)
-      @style.margin_right  = safe_style_fetch(:margin_right, :margin)
-      @style.margin_top    = safe_style_fetch(:margin_top, :margin)
-      @style.margin_bottom = safe_style_fetch(:margin_bottom, :margin)
+      @style.margin_left   = safe_style_fetch(:margin_left)   || @style.margin
+      @style.margin_right  = safe_style_fetch(:margin_right)  || @style.margin
+      @style.margin_top    = safe_style_fetch(:margin_top)    || @style.margin
+      @style.margin_bottom = safe_style_fetch(:margin_bottom) || @style.margin
     end
 
     def update_styles(event = :default)
-      old_width = width
-      old_height = height
-
+      _style = @style.send(event)
       @style_event = event
 
-      return if self.is_a?(ToolTip)
+      if @text.is_a?(CyberarmEngine::Text)
+        @text.color = _style&.dig(:color) || @style.default[:color]
+        @text.swap_font(_style&.dig(:text_size) || @style.default[:text_size], _style&.dig(:font) || @style.default[:font])
+      end
 
-      root.gui_state.request_recalculate if old_width != width || old_height != height
-
-      stylize
+      (root&.gui_state || @gui_state).request_recalculate
     end
 
     def default_events
@@ -195,10 +139,6 @@ module CyberarmEngine
 
       event(:mouse_wheel_up)
       event(:mouse_wheel_down)
-      event(:scroll_jump_to_top)
-      event(:scroll_jump_to_end)
-      event(:scroll_page_up)
-      event(:scroll_page_down)
 
       event(:enter)
       event(:hover)
@@ -211,7 +151,7 @@ module CyberarmEngine
     end
 
     def enter(_sender)
-      @focus = false unless Gosu.button_down?(Gosu::MS_LEFT)
+      @focus = false unless window.button_down?(Gosu::MsLeft)
 
       if !@enabled
         update_styles(:disabled)
@@ -272,66 +212,44 @@ module CyberarmEngine
       :handled
     end
 
-    def enabled=(boolean)
-      root.gui_state.request_repaint if @enabled != boolean
-
-      @enabled = boolean
-
-      recalculate
-
-      @enabled
-    end
-
     def enabled?
       @enabled
     end
 
-    def focused?
-      @focus
-    end
-
     def visible?
       @visible
     end
 
-    def element_visible?
-      @element_visible
-    end
-
     def toggle
       @visible = !@visible
       root.gui_state.request_recalculate
-      root.gui_state.request_repaint
     end
 
     def show
       bool = visible?
       @visible = true
       root.gui_state.request_recalculate unless bool
-      root.gui_state.request_repaint unless bool
     end
 
     def hide
       bool = visible?
       @visible = false
       root.gui_state.request_recalculate if bool
-      root.gui_state.request_repaint if bool
     end
 
     def draw
       return unless visible?
-      return unless element_visible?
 
       @style.background_canvas.draw
-      @style.background_nine_slice_canvas.draw
-      @style.background_image_canvas.draw
       @style.border_canvas.draw
 
-      render
+      Gosu.clip_to(@x, @y, width, height) do
+        render
+      end
     end
 
     def debug_draw
-      return if CyberarmEngine.const_defined?("GUI_DEBUG_ONLY_ELEMENT") && self.class == GUI_DEBUG_ONLY_ELEMENT
+      return if defined?(GUI_DEBUG_ONLY_ELEMENT) && self.class == GUI_DEBUG_ONLY_ELEMENT
 
       Gosu.draw_line(
         x, y, @debug_color,
@@ -349,14 +267,13 @@ module CyberarmEngine
         Float::INFINITY
       )
       Gosu.draw_line(
-        x, y + outer_height, @debug_color,
+        x, outer_height, @debug_color,
         x, y, @debug_color,
         Float::INFINITY
       )
     end
 
     def update
-      recalculate_if_size_changed
     end
 
     def button_down(id)
@@ -426,90 +343,34 @@ module CyberarmEngine
     end
 
     def scroll_width
-      return @cached_scroll_width if @cached_scroll_width && is_a?(Container)
-
-      @cached_scroll_width = @children.sum(&:outer_width)
+      @children.sum { |c| c.width } + noncontent_width
     end
 
     def scroll_height
-      return @cached_scroll_height if @cached_scroll_height && is_a?(Container)
-
-      if is_a?(CyberarmEngine::Element::Flow)
-        return 0 if @children.size.zero?
-
-        pairs_ = []
-        sorted_children_ = @children.sort_by(&:y)
-        a_ = []
-        y_position_ = sorted_children_.first.y
-
-        sorted_children_.each do |child|
-          unless child.y == y_position_
-            y_position_ = child.y
-            pairs_ << a_
-            a_ = []
-          end
-
-          a_ << child
-        end
-
-        pairs_ << a_ unless pairs_.last == a_
-
-        @cached_scroll_height = pairs_.sum { |pair|  + @style.padding_top + @style.border_thickness_top + pair.map(&:outer_height).max } + @style.padding_bottom + @style.border_thickness_bottom
-      else
-        @cached_scroll_height = @style.padding_top + @style.border_thickness_top + @children.sum(&:outer_height) + @style.padding_bottom + @style.border_thickness_bottom
-      end
+      @children.sum { |c| c.height } + noncontent_height
     end
 
     def max_scroll_width
-      (scroll_width - outer_width).positive? ? scroll_width - outer_width : scroll_width
+      scroll_width - width
     end
 
     def max_scroll_height
-      (scroll_height - outer_height).positive? ? scroll_height - outer_height : scroll_height
+      scroll_height - height
     end
 
     def dimensional_size(size, dimension)
       raise "dimension must be either :width or :height" unless %i[width height].include?(dimension)
 
-      new_size = if size.is_a?(Float) && size.between?(0.0, 1.0)
-                   (@parent.send(:"content_#{dimension}") * size).floor - send(:"noncontent_#{dimension}").floor
-                 else
-                   size
-                 end
-
-      # Handle fill behavior
-      if @parent && @style.fill &&
-         (dimension == :width && @parent.is_a?(Flow) ||
-          dimension == :height && @parent.is_a?(Stack))
-        new_size = space_available_width - noncontent_width if dimension == :width && @parent.is_a?(Flow)
-        new_size = space_available_height - noncontent_height if dimension == :height && @parent.is_a?(Stack)
+      if size && size.is_a?(Numeric)
+        if size.between?(0.0, 1.0)
+          ((@parent.send(:"content_#{dimension}") - send(:"noncontent_#{dimension}")) * size).round
+        else
+          size
+        end
       end
-
-      return @style.send(:"min_#{dimension}") if @style.send(:"min_#{dimension}") && new_size.to_f < @style.send(:"min_#{dimension}")
-      return @style.send(:"max_#{dimension}") if @style.send(:"max_#{dimension}") && new_size.to_f > @style.send(:"max_#{dimension}")
-
-      new_size
-    end
-
-    def space_available_width
-      # TODO: This may get expensive if there are a lot of children, probably should cache it somehow
-      fill_siblings = @parent.children.select { |c| c.style.fill }.count.to_f # include self since we're dividing
-
-      available_space = ((@parent.content_width - (@parent.children.reject { |c| c.style.fill }).map(&:outer_width).sum) / fill_siblings)
-      (available_space.nan? || available_space.infinite?) ? 0 : available_space.floor # The parent element might not have its dimensions, yet.
-    end
-
-    def space_available_height
-      # TODO: This may get expensive if there are a lot of children, probably should cache it somehow
-      fill_siblings = @parent.children.select { |c| c.style.fill }.count.to_f # include self since we're dividing
-
-      available_space = ((@parent.content_height - (@parent.children.reject { |c| c.style.fill }).map(&:outer_height).sum) / fill_siblings)
-      (available_space.nan? || available_space.infinite?) ? 0 : available_space.floor # The parent element might not have its dimensions, yet.
     end
 
     def background=(_background)
-      root.gui_state.request_repaint
-
       @style.background_canvas.background = _background
       update_background
     end
@@ -522,66 +383,10 @@ module CyberarmEngine
       @style.background_canvas.height = height
 
       @style.background_canvas.update
-      update_background_nine_slice
-      update_background_image
+
       @style.border_canvas.update
     end
 
-    def background_nine_slice=(_image_path)
-      root.gui_state.request_repaint
-
-      @style.background_nine_slice_canvas.image = _image_path
-      update_background_nine_slice
-    end
-
-    def update_background_nine_slice
-      @style.background_nine_slice_canvas.x = @x
-      @style.background_nine_slice_canvas.y = @y
-      @style.background_nine_slice_canvas.z = @z
-      @style.background_nine_slice_canvas.width = width
-      @style.background_nine_slice_canvas.height = height
-
-      @style.background_nine_slice_canvas.mode = @style.background_nine_slice_mode
-
-      @style.background_nine_slice_canvas.color = @style.background_nine_slice_color
-
-      @style.background_nine_slice_canvas.left   = @style.background_nine_slice_left
-      @style.background_nine_slice_canvas.top    = @style.background_nine_slice_top
-      @style.background_nine_slice_canvas.right  = @style.background_nine_slice_right
-      @style.background_nine_slice_canvas.bottom = @style.background_nine_slice_bottom
-
-      @style.background_nine_slice_canvas.image = @style.background_nine_slice
-    end
-
-    def background_image=(image_path)
-      root.gui_state.request_repaint
-
-      @style.background_image = image_path.is_a?(Gosu::Image) ? image_path : get_image(image_path)
-      update_background_image
-    end
-
-    def update_background_image
-      @style.background_image_canvas.x = @x
-      @style.background_image_canvas.y = @y
-      @style.background_image_canvas.z = @z
-      @style.background_image_canvas.width = width
-      @style.background_image_canvas.height = height
-
-      @style.background_image_canvas.mode = @style.background_image_mode
-      @style.background_image_canvas.color = @style.background_image_color
-
-      @style.background_image_canvas.image = @style.background_image
-    end
-
-    def recalculate_if_size_changed
-      if @parent && !is_a?(ToolTip) && (@old_width != width || @old_height != height)
-        root.gui_state.request_recalculate
-
-        @old_width = width
-        @old_height = height
-      end
-    end
-
     def root
       return self if is_root?
 
@@ -602,22 +407,6 @@ module CyberarmEngine
       @gui_state != nil
     end
 
-    def child_of?(element)
-      return element == self if is_root?
-      return false unless element.is_a?(Container)
-      return true if element.children.find { |child| child == self }
-
-      element.children.find { |child| child.child_of?(element) if child.is_a?(Container) }
-    end
-
-    def parent_of?(element)
-      return false if element == self
-      return false unless is_a?(Container)
-      return true if @children.find { |child| child == element }
-
-      @children.find { |child| child.parent_of?(element) if child.is_a?(Container) }
-    end
-
     def focus(_)
       warn "#{self.class}#focus was not overridden!"
 
@@ -625,19 +414,7 @@ module CyberarmEngine
     end
 
     def recalculate
-      old_width = width
-      old_height = height
-
-      stylize
-      layout
-
-      root.gui_state.request_recalculate if @parent && !is_a?(ToolTip) && (width != old_width || height != old_height)
-      root.gui_state.request_repaint if width != old_width || height != old_height
-
-      root.gui_state.menu.recalculate if root.gui_state.menu && root.gui_state.menu.parent == self
-    end
-
-    def layout
+      raise "#{self.class}#recalculate was not overridden!"
     end
 
     def reposition

lib/cyberarm_engine/ui/elements/button.rb

@@ -34,7 +34,7 @@ module CyberarmEngine
         @text.draw
       end
 
-      def layout
+      def recalculate
         unless @enabled
           @style.background_canvas.background = @style.disabled[:background]
           @text.color = @style.disabled[:color]
@@ -64,8 +64,8 @@ module CyberarmEngine
             @scale_y = 1
           end
 
-          @width = _width || @image.width.floor * @scale_x
-          @height = _height || @image.height.floor * @scale_y
+          @width = _width || @image.width.round * @scale_x
+          @height = _height || @image.height.round * @scale_y
 
           update_background
         else
@@ -86,12 +86,9 @@ module CyberarmEngine
 
         old_width = width
         old_height = height
+        recalculate
 
-        if old_width != width || old_height != height
-          root.gui_state.request_recalculate
-        else
-          recalculate
-        end
+        root.gui_state.request_recalculate if old_width != width || old_height != height
 
         publish(:changed, self.value)
       end

lib/cyberarm_engine/ui/elements/container.rb

@@ -4,26 +4,13 @@ module CyberarmEngine
       include Common
 
       attr_accessor :stroke_color, :fill_color
-      attr_reader :children, :gui_state, :scroll_position, :scroll_target_position
-
-      def self.current_container
-        @@current_container
-      end
-
-      def self.current_container=(container)
-        raise ArgumentError, "Expected container to an an instance of CyberarmEngine::Element::Container, got #{container.class}" unless container.is_a?(CyberarmEngine::Element::Container)
-
-        @@current_container = container
-      end
+      attr_reader :children, :gui_state, :scroll_position
 
       def initialize(options = {}, block = nil)
         @gui_state = options.delete(:gui_state)
         super
 
-        @last_scroll_position = Vector.new(0, 0)
         @scroll_position = Vector.new(0, 0)
-        @scroll_target_position = Vector.new(0, 0)
-        @scroll_chunk = 120
         @scroll_speed = 40
 
         @text_color = options[:color]
@@ -36,53 +23,42 @@ module CyberarmEngine
       def build
         @block.call(self) if @block
 
-        root.gui_state.request_recalculate_for(self)
+        root.gui_state.request_recalculate
       end
 
       def add(element)
         @children << element
 
-        root.gui_state.request_recalculate_for(self)
-      end
-
-      def remove(element)
-        root.gui_state.request_recalculate_for(self) if @children.delete(element)
-      end
-
-      def append(&block)
-        old_container = CyberarmEngine::Element::Container.current_container
-
-        CyberarmEngine::Element::Container.current_container = self
-        block.call(self) if block
-
-        CyberarmEngine::Element::Container.current_container = old_container
-
-        root.gui_state.request_recalculate_for(self)
+        root.gui_state.request_recalculate
       end
 
       def clear(&block)
         @children.clear
 
-        old_container = CyberarmEngine::Element::Container.current_container
+        old_container = $__current_container__
 
-        CyberarmEngine::Element::Container.current_container = self
+        $__current_container__ = self
         block.call(self) if block
 
-        CyberarmEngine::Element::Container.current_container = old_container
+        $__current_container__ = old_container
 
-        root.gui_state.request_recalculate_for(self)
+        root.gui_state.request_recalculate
+      end
+
+      def apend(&block)
+        old_container = $__current_container__
+
+        $__current_container__ = self
+        block.call(self) if block
+
+        $__current_container__ = old_container
+
+        root.gui_state.request_recalculate
       end
 
       def render
-        Gosu.clip_to(
-          @x + @style.border_thickness_left + @style.padding_left,
-          @y + @style.border_thickness_top + @style.padding_top,
-          content_width + 1,
-          content_height + 1
-        ) do
-          Gosu.translate(@scroll_position.x, @scroll_position.y) do
-            @children.each(&:draw)
-          end
+        Gosu.clip_to(@x, @y, width, height) do
+          @children.each(&:draw)
         end
       end
 
@@ -95,80 +71,38 @@ module CyberarmEngine
       end
 
       def update
-        update_scroll if @style.scroll
         @children.each(&:update)
       end
 
       def hit_element?(x, y)
-        return unless hit?(x, y)
-
-        # Offset child hit point by scroll position/offset
-        child_x = x - @scroll_position.x
-        child_y = y - @scroll_position.y
-
         @children.reverse_each do |child|
           next unless child.visible?
 
           case child
           when Container
-            if element = child.hit_element?(child_x, child_y)
+            if element = child.hit_element?(x, y)
               return element
             end
           else
-            return child if child.hit?(child_x, child_y)
+            return child if child.hit?(x, y)
           end
         end
 
         self if hit?(x, y)
       end
 
-      def update_child_element_visibity(child)
-        child.element_visible = child.x >= (@x - @scroll_position.x) - child.width && child.x <= (@x - @scroll_position.x) + width &&
-                                child.y >= (@y - @scroll_position.y) - child.height && child.y <= (@y - @scroll_position.y) + height
-      end
-
-      def update_scroll
-        dt = window.dt.clamp(0.000001, 0.025)
-        @scroll_position.x += (((@scroll_target_position.x - @scroll_position.x) * (@scroll_speed / 4.0) * 0.98) * dt).round
-        @scroll_position.y += (((@scroll_target_position.y - @scroll_position.y) * (@scroll_speed / 4.0) * 0.98) * dt).round
-
-        # Scrolled PAST top
-        if @scroll_position.y > 0
-          @scroll_target_position.y = 0
-
-        # Scrolled PAST bottom
-        elsif @scroll_position.y < -max_scroll_height
-          @scroll_target_position.y = -max_scroll_height
-        end
-
-        if @last_scroll_position != @scroll_position
-          @children.each { |child| update_child_element_visibity(child) }
-          root.gui_state.request_repaint
-        end
-
-        @last_scroll_position.x = @scroll_position.x
-        @last_scroll_position.y = @scroll_position.y
-      end
-
       def recalculate
         @current_position = Vector.new(@style.margin_left + @style.padding_left, @style.margin_top + @style.padding_top)
+        @current_position += @scroll_position
 
         return unless visible?
 
-        Stats.frame&.increment(:gui_recalculations)
-
-        # s = Gosu.milliseconds
+        Stats.increment(:gui_recalculations_last_frame, 1)
 
         stylize
+
         layout
 
-        # Old sizes MUST be determined AFTER call to layout
-        old_width = width
-        old_height = height
-
-        @cached_scroll_width = nil
-        @cached_scroll_height = nil
-
         if is_root?
           @width  = @style.width  = window.width
           @height = @style.height = window.height
@@ -179,36 +113,11 @@ module CyberarmEngine
           _width = dimensional_size(@style.width, :width)
           _height = dimensional_size(@style.height, :height)
 
-          @width  = _width  || (@children.map { |c| c.x + c.outer_width }.max || 0).floor
-          @height = _height || (@children.map { |c| c.y + c.outer_height }.max || 0).floor
+          @width  = _width  || (@children.map { |c| c.x + c.outer_width }.max || 0).round
+          @height = _height || (@children.map { |c| c.y + c.outer_height }.max || 0).round
         end
 
-        # FIXME: Correctly handle alignment when element has siblings
-        # FIXME: Enable alignment for any element, not just containers
-        if @style.v_align
-          space = space_available_height
-
-          case @style.v_align
-          when :center
-            @y = parent.height / 2 - height / 2
-          when :bottom
-            @y = parent.height - height
-          end
-        end
-
-        if @style.h_align
-          space = space_available_width
-
-          case @style.h_align
-          when :center
-            @x = parent.width / 2 - width / 2
-          when :right
-            @x = parent.width - width
-          end
-        end
-
-        # t = Gosu.milliseconds
-        # Move children to parent after positioning
+        # Move child to parent after positioning
         @children.each do |child|
           child.x += (@x + @style.border_thickness_left) - style.margin_left
           child.y += (@y + @style.border_thickness_top) - style.margin_top
@@ -217,28 +126,10 @@ module CyberarmEngine
           child.recalculate
           child.reposition # TODO: Implement top,bottom,left,center, and right positioning
 
-          Stats.frame&.increment(:gui_recalculations)
-
-          update_child_element_visibity(child)
+          Stats.increment(:gui_recalculations_last_frame, 1)
         end
-        # puts "TOOK: #{Gosu.milliseconds - t}ms to recalculate #{self.class}:0x#{self.object_id.to_s(16)}'s #{@children.count} children"
 
         update_background
-
-        # Fixes resized container scrolled past bottom
-        if old_height != @height
-          self.scroll_top = -@scroll_position.y
-          @scroll_target_position.y = @scroll_position.y
-        end
-
-        # Fixes resized container that is scrolled down from being stuck overscrolled when resized
-        if scroll_height < height
-          @scroll_target_position.y = 0
-        end
-
-        recalculate_if_size_changed
-
-        # puts "TOOK: #{Gosu.milliseconds - s}ms to recalculate #{self.class}:0x#{self.object_id.to_s(16)}"
       end
 
       def layout
@@ -246,17 +137,16 @@ module CyberarmEngine
       end
 
       def max_width
-        # _width = dimensional_size(@style.width, :width)
-        # if _width
-        #   outer_width
-        # else
-        #   window.width - (@parent ? @parent.style.margin_right + @style.margin_right : @style.margin_right)
-        # end
-
-        outer_width
+        _width = dimensional_size(@style.width, :width)
+        if _width
+          outer_width
+        else
+          window.width - (@parent ? @parent.style.margin_right + @style.margin_right : @style.margin_right)
+        end
       end
 
       def fits_on_line?(element) # Flow
+        p [@options[:id], @width] if @options[:id]
         @current_position.x + element.outer_width <= max_width &&
           @current_position.x + element.outer_width <= window.width
       end
@@ -266,6 +156,7 @@ module CyberarmEngine
         element.y = element.style.margin_top  + @current_position.y
 
         @current_position.x += element.outer_width
+        @current_position.x = @style.margin_left if @current_position.x >= max_width
       end
 
       def tallest_neighbor(querier, _y_position) # Flow
@@ -278,14 +169,14 @@ module CyberarmEngine
         response
       end
 
-      def position_on_next_line(element) # Flow
-        @current_position.x = @style.margin_left + @style.padding_left
-        @current_position.y += tallest_neighbor(element, @current_position.y).outer_height
+      def position_on_next_line(child) # Flow
+        @current_position.x = @style.margin_left
+        @current_position.y += tallest_neighbor(child, @current_position.y).outer_height
 
-        element.x = element.style.margin_left + @current_position.x
-        element.y = element.style.margin_top  + @current_position.y
+        child.x = child.style.margin_left + @current_position.x
+        child.y = child.style.margin_top  + @current_position.y
 
-        @current_position.x += element.outer_width
+        @current_position.x += child.outer_width
       end
 
       def move_to_next_line(element) # Stack
@@ -298,13 +189,10 @@ module CyberarmEngine
       def mouse_wheel_up(sender, x, y)
         return unless @style.scroll
 
-        # Allow overscrolling UP, only if one can scroll DOWN
-        if height < scroll_height
-          if @scroll_target_position.y > 0
-            @scroll_target_position.y = @scroll_chunk
-          else
-            @scroll_target_position.y += @scroll_chunk
-          end
+        if @scroll_position.y < 0
+          @scroll_position.y += @scroll_speed
+          @scroll_position.y = 0 if @scroll_position.y > 0
+          recalculate
 
           return :handled
         end
@@ -315,51 +203,13 @@ module CyberarmEngine
 
         return unless height < scroll_height
 
-        if @scroll_target_position.y > 0
-          @scroll_target_position.y = -@scroll_chunk
-        else
-          @scroll_target_position.y -= @scroll_chunk
+        if @scroll_position.y.abs < max_scroll_height
+          @scroll_position.y -= @scroll_speed
+          @scroll_position.y = -max_scroll_height if @scroll_position.y.abs > max_scroll_height
+          recalculate
+
+          return :handled
         end
-
-        return :handled
-      end
-
-      def scroll_jump_to_top(sender, x, y)
-        return unless @style.scroll
-
-        @scroll_position.y = 0
-        @scroll_target_position.y = 0
-
-        return :handled
-      end
-
-      def scroll_jump_to_end(sender, x, y)
-        return unless @style.scroll
-
-        @scroll_position.y = -max_scroll_height
-        @scroll_target_position.y = -max_scroll_height
-
-        return :handled
-      end
-
-      def scroll_page_up(sender, x, y)
-        return unless @style.scroll
-
-        @scroll_position.y += height
-        @scroll_position.y = 0 if @scroll_position.y > 0
-        @scroll_target_position.y = @scroll_position.y
-
-        return :handled
-      end
-
-      def scroll_page_down(sender, x, y)
-        return unless @style.scroll
-
-        @scroll_position.y -= height
-        @scroll_position.y = -max_scroll_height if @scroll_position.y < -max_scroll_height
-        @scroll_target_position.y = @scroll_position.y
-
-        return :handled
       end
 
       def scroll_top
@@ -378,7 +228,7 @@ module CyberarmEngine
       end
 
       def value
-        @children.map(&:class).join(", ")
+        @children.map { |c| c.class }.join(", ")
       end
 
       def to_s

lib/cyberarm_engine/ui/elements/edit_box.rb

@@ -98,7 +98,7 @@ module CyberarmEngine
       end
 
       def row_at(y)
-        ((y - @text.y) / @text.textobject.height).floor
+        ((y - @text.y) / @text.textobject.height).round
       end
 
       def column_at(x, y)

lib/cyberarm_engine/ui/elements/edit_line.rb

@@ -1,20 +1,6 @@
 module CyberarmEngine
   class Element
     class EditLine < Button
-      class TextInput < Gosu::TextInput
-        def filter=(filter)
-          @filter = filter
-        end
-
-        def filter(text_in)
-          if @filter
-            @filter.call(text_in)
-          else
-            text_in
-          end
-        end
-      end
-
       def initialize(text, options = {}, block = nil)
         @filter = options.delete(:filter)
         super(text, options, block)
@@ -28,11 +14,17 @@ module CyberarmEngine
         @caret_last_interval = Gosu.milliseconds
         @show_caret = true
 
-        @text_input = TextInput.new
-        @text_input.filter = @filter
+        @text_input = Gosu::TextInput.new
         @text_input.text = text
         @last_text_value = text
-        @last_caret_position = @text_input.caret_pos
+
+        if @filter && @filter.respond_to?(:call)
+          @text_input.instance_variable_set(:@filter, @filter)
+
+          def @text_input.filter(text_in)
+            @filter.call(text_in)
+          end
+        end
 
         @offset_x = 0
         @offset_y = 0
@@ -80,22 +72,10 @@ module CyberarmEngine
           @show_caret = true
           @caret_last_interval = Gosu.milliseconds
 
-          root.gui_state.request_repaint
-
           publish(:changed, value)
         end
 
-        if @last_caret_position != @text_input.caret_pos
-          @last_caret_position = @text_input.caret_pos
-          root.gui_state.request_repaint
-
-          @show_caret = true
-          @caret_last_interval = Gosu.milliseconds
-        end
-
         if Gosu.milliseconds >= @caret_last_interval + @caret_interval
-          root.gui_state.request_repaint
-
           @caret_last_interval = Gosu.milliseconds
 
           @show_caret = !@show_caret
@@ -118,20 +98,20 @@ module CyberarmEngine
             @text_input.caret_pos = @text_input.text.length
 
           when Gosu::KB_C
-            Gosu.clipboard = if @text_input.selection_start < @text_input.caret_pos
-                               @text_input.text[@text_input.selection_start...@text_input.caret_pos]
-                             else
-                               @text_input.text[@text_input.caret_pos...@text_input.selection_start]
-                             end
+            if @text_input.selection_start < @text_input.caret_pos
+              Clipboard.copy(@text_input.text[@text_input.selection_start...@text_input.caret_pos])
+            else
+              Clipboard.copy(@text_input.text[@text_input.caret_pos...@text_input.selection_start])
+            end
 
           when Gosu::KB_X
             chars = @text_input.text.chars
 
             if @text_input.selection_start < @text_input.caret_pos
-              Gosu.clipboard = @text_input.text[@text_input.selection_start...@text_input.caret_pos]
+              Clipboard.copy(@text_input.text[@text_input.selection_start...@text_input.caret_pos])
               chars.slice!(@text_input.selection_start, @text_input.caret_pos)
             else
-              Gosu.clipboard = @text_input.text[@text_input.caret_pos...@text_input.selection_start]
+              Clipboard.copy(@text_input.text[@text_input.caret_pos...@text_input.selection_start])
               chars.slice!(@text_input.caret_pos, @text_input.selection_start)
             end
 
@@ -139,9 +119,10 @@ module CyberarmEngine
 
           when Gosu::KB_V
             if instance_of?(EditLine) # EditLine assumes a single line of text
-              @text_input.insert_text(Gosu.clipboard.gsub("\n", ""))
+              @text_input.text = @text_input.text.insert(@text_input.caret_pos,
+                                                         Clipboard.paste.encode("UTF-8").gsub("\n", ""))
             else
-              @text_input.insert_text(Gosu.clipboard)
+              @text_input.text = @text_input.text.insert(@text_input.caret_pos, Clipboard.paste.encode("UTF-8"))
             end
           end
         end
@@ -168,7 +149,7 @@ module CyberarmEngine
         @last_text = @text.text
         @last_pos = caret_pos
 
-        if caret_pos.between?(@offset_x + 1, @width + @offset_x)
+        if caret_pos.between?(@offset_x, @width + @offset_x)
           # Do nothing
 
         elsif caret_pos < @offset_x
@@ -197,9 +178,9 @@ module CyberarmEngine
 
       def text_input_position_for(method)
         if @type == :password
-          @text.x + @text.width(default(:password_character) * @text_input.text[0...@text_input.send(method)].length) - @style.border_thickness_left
+          @text.x + @text.width(default(:password_character) * @text_input.text[0...@text_input.send(method)].length)
         else
-          @text.x + @text.width(@text_input.text[0...@text_input.send(method)]) - @style.border_thickness_left
+          @text.x + @text.width(@text_input.text[0...@text_input.send(method)])
         end
       end
 
@@ -216,35 +197,20 @@ module CyberarmEngine
       end
 
       def focus(sender)
-        @focus = true
+        super
+
         window.text_input = @text_input
         @text_input.caret_pos = @text_input.selection_start = @text_input.text.length
 
-        update_styles(:active)
-
         :handled
       end
 
       def enter(sender)
-        if @enabled && @focus
-          update_styles(:active)
-        elsif @enabled && !@focus
-          update_styles(:hover)
-        else
-          update_styles(:disabled)
-        end
+        _has_focus = @focus
 
-        :handled
-      end
+        super
 
-      def leave(sender)
-        if @enabled && @focus
-          update_styles(:active)
-        elsif @enabled && !@focus
-          update_styles
-        else
-          update_styles(:disabled)
-        end
+        @focus = _has_focus
 
         :handled
       end
@@ -278,7 +244,7 @@ module CyberarmEngine
         :handled
       end
 
-      def layout
+      def recalculate
         super
 
         @width = dimensional_size(@style.width, :width) || default(:width)

lib/cyberarm_engine/ui/elements/image.rb

@@ -27,7 +27,7 @@ module CyberarmEngine
         :handled
       end
 
-      def layout
+      def recalculate
         _width = dimensional_size(@style.width, :width)
         _height = dimensional_size(@style.height, :height)
 
@@ -45,8 +45,8 @@ module CyberarmEngine
           @scale_y = 1
         end
 
-        @width = _width || (@image.width * @scale_x).floor
-        @height = _height || (@image.height * @scale_y).floor
+        @width = _width || @image.width.round * @scale_x
+        @height = _height || @image.height.round * @scale_y
 
         update_background
       end

lib/cyberarm_engine/ui/elements/list_box.rb

@@ -12,27 +12,26 @@ module CyberarmEngine
 
         @style.background_canvas.background = default(:background)
 
-        @menu = Menu.new(parent: self, theme: @options[:theme])
+        # TODO: "Clean Up" into own class?
+        @menu = Stack.new(parent: parent, width: @options[:width], theme: @options[:theme])
+        @menu.define_singleton_method(:recalculate_menu) do
+          @x = @__list_box.x
+          @y = @__list_box.y + @__list_box.height
+        end
+        @menu.instance_variable_set(:"@__list_box", self)
+
+        def @menu.recalculate
+          super
+
+          recalculate_menu
+        end
 
         self.choose = @choose
       end
 
-      def render
-        super
-
-        w = @text.textobject.text_width("▼")
-        @text.textobject.draw_text("▼", @x + content_width - w, @y + @style.padding_top, @z, 1, 1, @text.color)
-      end
-
       def choose=(item)
         valid = @items.detect { |i| i == item }
-
-        unless valid
-          warn "Invalid value '#{item}' for choose, valid options were: #{@items.map { |i| "#{i.inspect}" }.join(", ")}"
-          item = @items.first
-
-          raise "No items list" unless item
-        end
+        raise "Invalid value '#{item}' for choose, valid options were: #{@items.map { |i| "#{i.inspect}" }.join(", ")}" unless valid
 
         @choose = item
 
@@ -47,32 +46,36 @@ module CyberarmEngine
         :handled
       end
 
-      def clicked_left_mouse_button(_sender, _x, _y)
-        # @block&.call(self.value) if @enabled
-
-        :handled
-      end
-
       def show_menu
-        @menu.clear do
+        @menu.clear
 
-          @menu.style.width = width
-
-          @items.each do |item|
-            # prevent already selected item from appearing in list
-            # NOTE: Remove this? Might be kinda confusing...
-            next if item == self.value
-
-            root.gui_state.menu_item(item, width: 1.0, margin: 0, border_color: 0x00ffffff) do
+        @items.each do |item|
+          btn = Button.new(
+            item,
+            {
+              parent: @menu,
+              width: 1.0,
+              theme: @options[:theme],
+              margin: 0,
+              border_color: 0x00ffffff
+            },
+            proc do
               self.choose = item
-              @block&.call(self.value)
+              @block&.call(item)
             end
-          end
-        end
+          )
 
+          @menu.add(btn)
+        end
         recalculate
 
-        @menu.show
+        root.gui_state.show_menu(@menu)
+      end
+
+      def recalculate
+        super
+
+        @menu.recalculate
       end
     end
   end

lib/cyberarm_engine/ui/elements/menu.rb

@@ -1,27 +0,0 @@
-module CyberarmEngine
-  class Element
-    class Menu < Stack
-      def recalculate
-        super
-
-        recalculate_menu
-      end
-
-      def recalculate_menu
-        # FIXME: properly find scrollable parent, if any.
-        parent_scroll_top = parent&.parent ? parent.parent.scroll_top : 0
-
-        @x = @parent.x
-        @y = parent_scroll_top + @parent.y + @parent.height
-
-        @y = (parent_scroll_top + @parent.y) - height if @y + height > window.height
-      end
-
-      def show
-        recalculate
-
-        root.gui_state.show_menu(self)
-      end
-    end
-  end
-end

lib/cyberarm_engine/ui/elements/menu_item.rb

@@ -1,6 +0,0 @@
-module CyberarmEngine
-  class Element
-    class MenuItem < Button
-    end
-  end
-end

lib/cyberarm_engine/ui/elements/progress.rb

@@ -1,16 +1,9 @@
 module CyberarmEngine
   class Element
     class Progress < Element
-      attr_reader :type
-
       def initialize(options = {}, block = nil)
         super(options, block)
 
-        @animation_speed = options[:animation_speed] || 3_000
-        @marquee_width = options[:marquee_width] || 0.25
-        @marquee_offset = 0
-        @marquee_animation_time = Gosu.milliseconds
-        @type = options[:type] || :linear
         @fraction_background = Background.new(background: @style.fraction_background)
         self.value = options[:fraction] || 0.0
       end
@@ -19,7 +12,7 @@ module CyberarmEngine
         @fraction_background.draw
       end
 
-      def layout
+      def recalculate
         _width = dimensional_size(@style.width, :width)
         _height = dimensional_size(@style.height, :height)
         @width = _width
@@ -31,46 +24,15 @@ module CyberarmEngine
       def update_background
         super
 
-        @fraction_background.x = (@style.border_thickness_left + @style.padding_left + @x) + @marquee_offset
+        @fraction_background.x = @style.border_thickness_left + @style.padding_left + @x
         @fraction_background.y = @style.border_thickness_top + @style.padding_top + @y
         @fraction_background.z = @z
-        @fraction_background.width = @width * (@type == :marquee ? @marquee_width : @fraction)
+        @fraction_background.width = @width * @fraction
         @fraction_background.height = @height
 
         @fraction_background.background = @style.fraction_background
       end
 
-      def update
-        super
-
-        return unless @type == :marquee
-
-        marquee_width = @width * @marquee_width
-        range = @width + marquee_width
-
-        @marquee_offset = (@width * (Gosu.milliseconds - @marquee_animation_time) / @animation_speed) - marquee_width
-        @marquee_animation_time = Gosu.milliseconds if @marquee_offset > range
-
-        update_background
-        root.gui_state.request_repaint
-      end
-
-      def type=(type)
-        @type = type
-
-        case type
-        when :linear
-          @marquee_offset = 0
-        when :marquee
-          @marquee_offset = 0
-          @marquee_animation_time = Gosu.milliseconds
-        else
-          raise ArgumentError, "Only types :linear and :marquee are supported"
-        end
-
-        update_background
-      end
-
       def value
         @fraction
       end
@@ -78,13 +40,9 @@ module CyberarmEngine
       def value=(decimal)
         raise "value must be number" unless decimal.is_a?(Numeric)
 
-        old_value = @fraction
-
         @fraction = decimal.clamp(0.0, 1.0)
         update_background
 
-        root.gui_state.request_repaint if @fraction != old_value
-
         publish(:changed, @fraction)
         @fraction
       end

lib/cyberarm_engine/ui/elements/slider.rb

@@ -33,8 +33,7 @@ module CyberarmEngine
         end
       end
 
-      attr_reader :value
-      attr_accessor :range, :step_size
+      attr_reader :range, :step_size, :value
 
       def initialize(options = {}, block = nil)
         super(options, block)
@@ -43,7 +42,7 @@ module CyberarmEngine
         @step_size = @options[:step] || 0.1
         @value     = @options[:value] || (@range.first + @range.last) / 2
 
-        @handle = Handle.new("", parent: self, theme: options[:theme], width: 8, height: 1.0) { close }
+        @handle = Handle.new("", parent: self, width: 8, height: 1.0) { close }
         add(@handle)
       end
 
@@ -62,10 +61,10 @@ module CyberarmEngine
       end
 
       def position_handle
-        @handle.x = @x + @handle.style.margin_left + @style.padding_left + @style.border_thickness_left +
+        @handle.x = @x + @style.padding_left + @style.border_thickness_left +
                     ((content_width - @handle.outer_width) * (@value - @range.min) / (@range.max - @range.min).to_f)
 
-        @handle.y = @y + @handle.style.margin_top + @style.border_thickness_top + @style.padding_top
+        @handle.y = @y + @style.border_thickness_top + @style.padding_top
       end
 
       def draw
@@ -77,7 +76,7 @@ module CyberarmEngine
       def update
         super
 
-        @tip = format("%.2f", value.to_f)
+        @tip = value.to_s
         @handle.tip = @tip
       end
 
@@ -88,7 +87,7 @@ module CyberarmEngine
       end
 
       def handle_dragged_to(x, _y)
-        @ratio = ((x - @handle.width / 2.0) - @x) / (content_width - @handle.outer_width.to_f)
+        @ratio = ((x - @handle.width / 2) - @x) / (content_width - @handle.outer_width)
 
         self.value = @ratio.clamp(0.0, 1.0) * (@range.max - @range.min) + @range.min
       end
@@ -98,8 +97,6 @@ module CyberarmEngine
         position_handle
         @handle.recalculate
 
-        root.gui_state.request_repaint
-
         publish(:changed, @value)
       end
     end

lib/cyberarm_engine/ui/elements/text_block.rb

@@ -7,44 +7,18 @@ module CyberarmEngine
         @text = Text.new(
           text, font: @options[:font], z: @z, color: @options[:color],
                 size: @options[:text_size], shadow: @options[:text_shadow],
-                static: @options[:text_static],
                 shadow_size: @options[:text_shadow_size],
-                shadow_color: @options[:text_shadow_color],
-                border: @options[:text_border],
-                border_size: @options[:text_border_size],
-                border_color: @options[:text_border_color]
+                shadow_color: @options[:text_shadow_color]
         )
 
         @raw_text = text
       end
 
-      def update
-        super
-
-        if @text.textobject.name != safe_style_fetch(:font)
-          set_font
-          root.gui_state.request_recalculate
-        end
-      end
-
       def render
-        # Gosu.clip_to is too expensive to always use so check if we actually need it.
-        if @text.width > width || @text.height > height
-          Gosu.clip_to(@x, @y, width, height) do
-            @text.draw
-          end
-        else
-          @text.draw
-        end
+        @text.draw
       end
 
-      def layout
-        unless @enabled
-          @text.color = @style.disabled[:color]
-        else
-          @text.color = @style.color
-        end
-
+      def recalculate
         @width  = 0
         @height = 0
 
@@ -53,19 +27,19 @@ module CyberarmEngine
 
         handle_text_wrapping(_width)
 
-        @width  = _width  || @text.width.floor
-        @height = _height || @text.height.floor
+        @width  = _width  || @text.width.round
+        @height = _height || @text.height.round
 
         @text.y = @style.border_thickness_top + @style.padding_top + @y
         @text.z = @z + 3
 
-        if (text_alignment = @options[:text_align] || @options[:text_h_align])
+        if (text_alignment = @options[:text_align])
           case text_alignment
           when :left
             @text.x = @style.border_thickness_left + @style.padding_left + @x
           when :center
-            @text.x = if @text.width <= width
-                        @x + width / 2 - @text.width / 2
+            @text.x = if @text.width <= outer_width
+                        @x + outer_width / 2 - @text.width / 2
                       else # Act as left aligned
                         @style.border_thickness_left + @style.padding_left + @x
                       end
@@ -74,81 +48,50 @@ module CyberarmEngine
           end
         end
 
-        if (vertical_alignment = @options[:text_v_align])
-          case vertical_alignment
-          when :center
-            @text.y = if @text.height <= height
-                        @y + height / 2 - @text.height / 2
-                      else
-                        @style.border_thickness_top + @style.padding_top + @y
-                      end
-          when :bottom
-            @text.y = @y + outer_height - (@text.height + @style.border_thickness_bottom + @style.padding_bottom)
-          end
-        end
-
         update_background
       end
 
       def handle_text_wrapping(max_width)
-        max_width ||= @parent&.content_width
+        max_width ||= @parent&.width
         max_width ||= @x - (window.width + noncontent_width)
         wrap_behavior = style.text_wrap
         copy = @raw_text.to_s.dup
 
-        # Only perform text wrapping: if it is enabled, is possible to wrap, and text is too long to fit on one line
-        if wrap_behavior != :none && line_width(copy[0]) <= max_width && line_width(copy) > max_width
-          breaks = [] # list of indexes to insert a line break
+        if line_width(copy[0]) <= max_width && line_width(copy) > max_width && wrap_behavior != :none
+          breaks = []
           line_start = 0
-          line_end = copy.length
+          line_end   = copy.length
 
-          stalled = false
-          stalled_interations = 0
-          max_stalled_iterations = 10
-          checked_copy_length = line_width(copy[line_start..line_end])
+          while line_start != copy.length
+            if line_width(copy[line_start...line_end]) > max_width
+              line_end = ((line_end - line_start) / 2.0)
+              line_end = 1.0 if line_end <= 1
+            elsif line_end < copy.length && line_width(copy[line_start...line_end + 1]) < max_width
+              # To small, grow!
+              # TODO: find a more efficient way
+              line_end += 1
 
-          # find length of lines
-          while line_width(copy[line_start..line_end]) > max_width && stalled_interations < max_stalled_iterations
-            search_start = line_start
-            search_end = line_end
+            else # FOUND IT!
+              entering_line_end = line_end.floor
+              max_reach = line_end.floor - line_start < 63 ? line_end.floor - line_start : 63
+              reach = 0
 
-            # Perform a binary search to find length of line
-            while search_start < search_end
-              midpoint = ((search_start.to_f + search_end) / 2.0).floor
-
-              if line_width(copy[line_start..midpoint]) > max_width
-                search_end = midpoint
-              else
-                search_start = midpoint + 1
-              end
-            end
-
-            if wrap_behavior == :word_wrap
-              word_search_end = search_end
-              failed = false
-
-              until(copy[word_search_end].to_s.match(/[[:punct:]]| /))
-                word_search_end -= 1
-
-                if word_search_end <= 1 || word_search_end < line_start
-                  failed = true
-                  break
+              if wrap_behavior == :word_wrap
+                max_reach.times do |i|
+                  reach = i
+                  break if copy[line_end.floor - i].to_s.match(/[[:punct:]]| /)
                 end
+
+                # puts "Max width: #{max_width}/#{line_width(@raw_text)} Reach: {#{reach}/#{max_reach}} Line Start: #{line_start}/#{line_end.floor} (#{copy.length}|#{@raw_text.length}) [#{entering_line_end}] '#{copy}' {#{copy[line_start...line_end]}}"
+                line_end = line_end.floor - reach + 1 if reach != max_reach # Add +1 to walk in front of punctuation
               end
 
-              line_start = failed ? search_end : word_search_end + 1 # walk in front of punctuation
-            else
-              line_start = search_end
+              breaks << line_end.floor
+              line_start = line_end.floor
+              line_end = copy.length
+
+              break if entering_line_end == copy.length || reach == max_reach
             end
-
-            breaks << line_start
-
-            # Prevent locking up due to outer while loop text width < max_width check not being satisfied.
-            stalled = checked_copy_length == line_width(copy[line_start..line_end])
-            checked_copy_length = line_width(copy[line_start..line_end])
-
-            stalled_interations += 1 if stalled
-            stalled_interations = 0 unless stalled
           end
 
           breaks.each_with_index do |pos, index|
@@ -160,7 +103,7 @@ module CyberarmEngine
       end
 
       def line_width(text)
-        (@text.textobject.markup_width(text.to_s) + noncontent_width)
+        (@text.textobject.markup_width(text) + noncontent_width)
       end
 
       def value
@@ -168,19 +111,13 @@ module CyberarmEngine
       end
 
       def value=(value)
-        old_value = @raw_text
         @raw_text = value.to_s.chomp
 
         old_width = width
         old_height = height
+        recalculate
 
-        if old_width != width || old_height != height
-          root.gui_state.request_recalculate
-        else
-          recalculate
-        end
-
-        root.gui_state.request_repaint if old_value != @raw_text
+        root.gui_state.request_recalculate if old_width != width || old_height != height
 
         publish(:changed, self.value)
       end

lib/cyberarm_engine/ui/elements/toggle_button.rb

@@ -5,8 +5,10 @@ module CyberarmEngine
 
       def initialize(options, block = nil)
         if options.dig(:theme, :ToggleButton, :checkmark_image)
-          options[:theme][:ToggleButton][:image_width] ||= options[:theme][:TextBlock][:text_size]
+          options[:theme][:ToggleButton][:image_width] ||= options[:theme][:Label][:text_size]
           super(get_image(options.dig(:theme, :ToggleButton, :checkmark_image)), options, block)
+
+          @_image = @image
         else
           super(options[:checkmark], options, block)
         end
@@ -14,8 +16,10 @@ module CyberarmEngine
         @value = options[:checked] || false
 
         if @value
+          @image = @_image if @_image
           @raw_text = @options[:checkmark]
         else
+          @image = nil
           @raw_text = ""
         end
       end
@@ -28,14 +32,6 @@ module CyberarmEngine
         :handled
       end
 
-      def render
-        if @image
-          draw_image if @value
-        else
-          draw_text
-        end
-      end
-
       def recalculate
         super
         return if @image
@@ -53,8 +49,10 @@ module CyberarmEngine
         @value = boolean
 
         if boolean
+          @image = @_image if @_image
           @raw_text = @options[:checkmark]
         else
+          @image = nil
           @raw_text = ""
         end
 

lib/cyberarm_engine/ui/event.rb

@@ -15,19 +15,12 @@ module CyberarmEngine
 
       return unless enabled?
 
-      was_handled = false
-
-      was_handled = true if respond_to?(event) && (send(event, self, *args) == :handled)
+      return :handled if respond_to?(event) && (send(event, self, *args) == :handled)
 
       @event_handler[event].reverse_each do |handler|
-        if handler.call(self, *args) == :handled
-          was_handled = true
-          break
-        end
+        return :handled if handler.call(self, *args) == :handled
       end
 
-      return :handled if was_handled
-
       parent.publish(event, *args) if parent
       nil
     end

lib/cyberarm_engine/ui/gui_state.rb

@@ -12,7 +12,7 @@ module CyberarmEngine
 
       @root_container = Element::Stack.new(gui_state: self)
       @game_objects << @root_container
-      CyberarmEngine::Element::Container.current_container = @root_container
+      $__current_container__ = @root_container
 
       @active_width  = window.width
       @active_height = window.height
@@ -25,9 +25,6 @@ module CyberarmEngine
       @last_mouse_pos = nil
       @dragging_element = nil
       @pending_recalculate_request = false
-      @pending_element_recalculate_requests = []
-
-      @needs_repaint = false
 
       @menu = nil
       @min_drag_distance = 0
@@ -38,10 +35,6 @@ module CyberarmEngine
       @tip = Element::ToolTip.new("", parent: @root_container, z: Float::INFINITY, theme: current_theme)
     end
 
-    def menu
-      @menu
-    end
-
     # throws :blur event to focused element and sets GuiState focused element
     # Does NOT throw :focus event at element or set element as focused
     def focus=(element)
@@ -54,24 +47,6 @@ module CyberarmEngine
     end
 
     def draw
-      Stats.frame.start_timing(:gui_element_recalculate_requests)
-
-      # puts "PENDING REQUESTS: #{@pending_element_recalculate_requests.size}" if @pending_element_recalculate_requests.size.positive?
-      @pending_element_recalculate_requests.each(&:recalculate)
-      @pending_element_recalculate_requests.clear
-
-      Stats.frame.end_timing(:gui_element_recalculate_requests)
-
-      if @pending_recalculate_request
-        Stats.frame.start_timing(:gui_recalculate)
-
-        @root_container.recalculate
-
-        @pending_recalculate_request = false
-
-        Stats.frame.end_timing(:gui_recalculate)
-      end
-
       super
 
       if @menu
@@ -79,26 +54,27 @@ module CyberarmEngine
         @menu.draw
       end
 
-      if @tip && @tip.value.length.positive?
+      if @tip.value.length.positive?
         Gosu.flush
-
         @tip.draw
       end
 
-      if CyberarmEngine.const_defined?("GUI_DEBUG")
+      if defined?(GUI_DEBUG)
         Gosu.flush
 
         @root_container.debug_draw
       end
-
-      @needs_repaint = false
-    end
-
-    def needs_repaint?
-      @needs_repaint
     end
 
     def update
+      if @pending_recalculate_request
+        @root_container.recalculate
+        @root_container.recalculate
+        @root_container.recalculate
+
+        @pending_recalculate_request = false
+      end
+
       if @pending_focus_request
         @pending_focus_request = false
 
@@ -107,20 +83,8 @@ module CyberarmEngine
       end
 
       @menu&.update
-
       super
 
-      if @active_width != window.width || @active_height != window.height
-        request_recalculate
-        @root_container.publish(:window_size_changed)
-      end
-
-      @active_width  = window.width
-      @active_height = window.height
-
-      return unless window.has_focus?
-      return unless window.current_state == self
-
       new_mouse_over = @menu.hit_element?(window.mouse_x, window.mouse_y) if @menu
       new_mouse_over ||= @root_container.hit_element?(window.mouse_x, window.mouse_y)
 
@@ -132,14 +96,14 @@ module CyberarmEngine
       @mouse_over.publish(:leave) if @mouse_over && new_mouse_over != @mouse_over
       @mouse_over = new_mouse_over
 
-      redirect_holding_mouse_button(:left) if @mouse_over && Gosu.button_down?(Gosu::MS_LEFT)
-      redirect_holding_mouse_button(:middle) if @mouse_over && Gosu.button_down?(Gosu::MS_MIDDLE)
-      redirect_holding_mouse_button(:right) if @mouse_over && Gosu.button_down?(Gosu::MS_RIGHT)
+      redirect_holding_mouse_button(:left) if @mouse_over && Gosu.button_down?(Gosu::MsLeft)
+      redirect_holding_mouse_button(:middle) if @mouse_over && Gosu.button_down?(Gosu::MsMiddle)
+      redirect_holding_mouse_button(:right) if @mouse_over && Gosu.button_down?(Gosu::MsRight)
 
       if Vector.new(window.mouse_x, window.mouse_y) == @last_mouse_pos
         if @mouse_over && (Gosu.milliseconds - @mouse_moved_at) > tool_tip_delay
           @tip.value = @mouse_over.tip if @mouse_over
-          @tip.x = window.mouse_x
+          @tip.x = window.mouse_x - @tip.width / 2
           @tip.x = 0 if @tip.x < 0
           @tip.x = window.width - @tip.width if @tip.x + @tip.width > window.width
           @tip.y = window.mouse_y - (@tip.height + 5)
@@ -156,19 +120,31 @@ module CyberarmEngine
 
       @last_mouse_pos = Vector.new(window.mouse_x, window.mouse_y)
       @mouse_pos = @last_mouse_pos.clone
+
+      if @active_width != window.width || @active_height != window.height
+        request_recalculate
+        @root_container.publish(:window_size_changed)
+      end
+
+      @active_width  = window.width
+      @active_height = window.height
+    end
+
+    def tool_tip_delay
+      250 # ms
     end
 
     def button_down(id)
       super
 
       case id
-      when Gosu::MS_LEFT
+      when Gosu::MsLeft
         redirect_mouse_button(:left)
-      when Gosu::MS_MIDDLE
+      when Gosu::MsMiddle
         redirect_mouse_button(:middle)
-      when Gosu::MS_RIGHT
+      when Gosu::MsRight
         redirect_mouse_button(:right)
-      when Gosu::KB_F5
+      when Gosu::KbF5
         request_recalculate
       end
 
@@ -179,34 +155,19 @@ module CyberarmEngine
       super
 
       case id
-      when Gosu::MS_LEFT
+      when Gosu::MsLeft
         redirect_released_mouse_button(:left)
-      when Gosu::MS_MIDDLE
+      when Gosu::MsMiddle
         redirect_released_mouse_button(:middle)
-      when Gosu::MS_RIGHT
+      when Gosu::MsRight
         redirect_released_mouse_button(:right)
-      when Gosu::MS_WHEEL_UP
+      when Gosu::MsWheelUp
         redirect_mouse_wheel(:up)
-      when Gosu::MS_WHEEL_DOWN
+      when Gosu::MsWheelDown
         redirect_mouse_wheel(:down)
-      when Gosu::KB_HOME
-        redirect_scroll_jump_to(:top)
-      when Gosu::KB_END
-        redirect_scroll_jump_to(:end)
-      when Gosu::KB_PAGE_UP
-        redirect_scroll_page(:up)
-      when Gosu::KB_PAGE_DOWN
-        redirect_scroll_page(:down)
       end
 
       @focus.button_up(id) if @focus.respond_to?(:button_up)
-
-      # Prevents menu from popping back up if the listbox is clicked to hide it.
-      @hid_menu_for = nil
-    end
-
-    def tool_tip_delay
-      @tip.style.delay || 250 # ms
     end
 
     def redirect_mouse_button(button)
@@ -217,7 +178,7 @@ module CyberarmEngine
         @focus = nil
       end
 
-      if @mouse_over && @hid_menu_for != @mouse_over
+      if @mouse_over
         @mouse_down_position[button] = Vector.new(window.mouse_x, window.mouse_y)
         @mouse_down_on[button]       = @mouse_over
 
@@ -231,7 +192,7 @@ module CyberarmEngine
     def redirect_released_mouse_button(button)
       hide_menu if @menu && (@menu == @mouse_over) || (@mouse_over&.parent == @menu)
 
-      if @mouse_over && @hid_menu_for != @mouse_over
+      if @mouse_over
         @mouse_over.publish(:"released_#{button}_mouse_button", window.mouse_x, window.mouse_y)
         if @mouse_over == @mouse_down_on[button]
           @mouse_over.publish(:"clicked_#{button}_mouse_button", window.mouse_x,
@@ -262,15 +223,7 @@ module CyberarmEngine
     end
 
     def redirect_mouse_wheel(button)
-      @mouse_over.publish(:"mouse_wheel_#{button}", window.mouse_x, window.mouse_y) if (@mouse_over && !@menu) || (@mouse_over && @mouse_over == @menu)
-    end
-
-    def redirect_scroll_jump_to(edge)
-      @mouse_over.publish(:"scroll_jump_to_#{edge}", window.mouse_x, window.mouse_y) if (@mouse_over && !@menu) || (@mouse_over && @mouse_over == @menu)
-    end
-
-    def redirect_scroll_page(edge)
-      @mouse_over.publish(:"scroll_page_#{edge}", window.mouse_x, window.mouse_y) if (@mouse_over && !@menu) || (@mouse_over && @mouse_over == @menu)
+      @mouse_over.publish(:"mouse_wheel_#{button}", window.mouse_x, window.mouse_y) if @mouse_over
     end
 
     # Schedule a full GUI recalculation on next update
@@ -278,34 +231,16 @@ module CyberarmEngine
       @pending_recalculate_request = true
     end
 
-    def request_recalculate_for(element)
-      # element is already queued
-      return if @pending_element_recalculate_requests.detect { |e| e == element }
-
-      @pending_element_recalculate_requests << element
-    end
-
     def request_focus(element)
       @pending_focus_request = true
       @pending_focus_element = element
     end
 
-    def request_repaint
-      # puts caller[0..4]
-      # puts
-      @needs_repaint = true
-    end
-
     def show_menu(list_box)
       @menu = list_box
     end
 
     def hide_menu
-      return unless @menu
-
-      request_repaint
-
-      @hid_menu_for = @menu.parent
       @menu = nil
     end
 

lib/cyberarm_engine/ui/style.rb

@@ -20,8 +20,7 @@ module CyberarmEngine
     attr_reader :hash
 
     def initialize(hash = {})
-      h = hash
-      # h = Marshal.load(Marshal.dump(hash))
+      h = Marshal.load(Marshal.dump(hash))
 
       h[:default] = {}
 

lib/cyberarm_engine/ui/theme.rb

@@ -76,7 +76,6 @@ module CyberarmEngine
         border_radius: 0,
         background: ["ffc75e61".to_i(16), "ffe26623".to_i(16)],
         text_align: :center,
-        text_v_align: :center,
         text_wrap: :none,
 
         hover: {
@@ -103,12 +102,7 @@ module CyberarmEngine
         caret_color: Gosu::Color::WHITE,
         caret_interval: 500,
         selection_color: Gosu::Color.rgba(255, 128, 50, 200),
-        text_align: :left,
-        text_static: false # static text causes issues correctly displaying caret position
-      },
-
-      EditBox: { # < EditLine
-        text_v_align: :top
+        text_align: :left
       },
 
       Image: { # < Element
@@ -121,14 +115,10 @@ module CyberarmEngine
         text_size: 28,
         text_wrap: :word_wrap, # :word_wrap, :break_word, :none
         text_shadow: false,
-        text_border: false,
         text_align: :left,
         font: "Arial",
         margin: 0,
-        padding: 2,
-        disabled: {
-          color: Gosu::Color.rgb(175, 175, 175),
-        }
+        padding: 2
       },
 
       Banner: { # < TextBlock
@@ -160,7 +150,6 @@ module CyberarmEngine
       },
 
       ToolTip: { # < TextBlock
-        delay: 100, # ms
         color: Gosu::Color::WHITE,
         padding_top: 4,
         padding_bottom: 4,
@@ -208,17 +197,6 @@ module CyberarmEngine
         fraction_background: [0xffc75e61, 0xffe26623],
         border_thickness: 1,
         border_color: [0xffd59674, 0xffff8746]
-      },
-      Menu: { # < Stack
-        width: 200,
-        border_color: 0xaa_efefef,
-        border_thickness: 1
-      },
-
-      MenuItem: { # < Button
-        width: 1.0,
-        text_left: :left,
-        margin: 0
       }
     }.freeze
   end

lib/cyberarm_engine/vector.rb

@@ -95,58 +95,39 @@ module CyberarmEngine
       Vector.new(@x, @y)
     end
 
-    # Adds Vector and Numeric or Vector and Vector, excluding {weight}
-    # @return [CyberarmEngine::Vector]
-    def +(other)
+    # Performs math operation, excluding {weight}
+    private def operator(function, other)
       if other.is_a?(Numeric)
         Vector.new(
-          @x + other,
-          @y + other,
-          @z + other
+          @x.send(:"#{function}", other),
+          @y.send(:"#{function}", other),
+          @z.send(:"#{function}", other)
         )
       else
         Vector.new(
-          @x + other.x,
-          @y + other.y,
-          @z + other.z
+          @x.send(:"#{function}", other.x),
+          @y.send(:"#{function}", other.y),
+          @z.send(:"#{function}", other.z)
         )
       end
     end
 
+    # Adds Vector and Numeric or Vector and Vector, excluding {weight}
+    # @return [CyberarmEngine::Vector]
+    def +(other)
+      operator("+", other)
+    end
+
     # Subtracts Vector and Numeric or Vector and Vector, excluding {weight}
     # @return [CyberarmEngine::Vector]
     def -(other)
-      if other.is_a?(Numeric)
-        Vector.new(
-          @x - other,
-          @y - other,
-          @z - other
-        )
-      else
-        Vector.new(
-          @x - other.x,
-          @y - other.y,
-          @z - other.z
-        )
-      end
+      operator("-", other)
     end
 
     # Multiplies Vector and Numeric or Vector and Vector, excluding {weight}
     # @return [CyberarmEngine::Vector]
     def *(other)
-      if other.is_a?(Numeric)
-        Vector.new(
-          @x * other,
-          @y * other,
-          @z * other
-        )
-      else
-        Vector.new(
-          @x * other.x,
-          @y * other.y,
-          @z * other.z
-        )
-      end
+      operator("*", other)
     end
 
     def multiply_transform(transform)

lib/cyberarm_engine/version.rb

@@ -1,4 +1,4 @@
 module CyberarmEngine
   NAME    = "InDev".freeze
-  VERSION = "0.24.5".freeze
+  VERSION = "0.18.0".freeze
 end

lib/cyberarm_engine/window.rb

@@ -6,130 +6,49 @@ module CyberarmEngine
     SAMPLES = {}
     SONGS = {}
 
-    attr_accessor :show_cursor, :show_stats_plotter
+    attr_accessor :show_cursor
     attr_writer :exit_on_opengl_error
-    attr_reader :last_frame_time, :delta_time, :states
+    attr_reader :last_frame_time
 
     def self.now
       Gosu.milliseconds
     end
 
     def self.dt
-      instance.dt
-    end
-
-    def self.instance=(window)
-      raise ArgumentError, "Expected window to be a subclass of CyberarmEngine::Window, got: #{window.class}" unless window.is_a?(CyberarmEngine::Window)
-
-      @@instance = window
-    end
-
-    def self.instance
-      @@instance
+      $window.last_frame_time / 1000.0
     end
 
     def initialize(width: 800, height: 600, fullscreen: false, update_interval: 1000.0 / 60, resizable: false, borderless: false)
       @show_cursor = false
-      @has_focus = false
-      @show_stats_plotter = false
 
       super(width, height, fullscreen: fullscreen, update_interval: update_interval, resizable: resizable, borderless: borderless)
-      Window.instance = self
-
+      $window = self
       @last_frame_time = Gosu.milliseconds - 1
       @current_frame_time = Gosu.milliseconds
-      @delta_time = @last_frame_time
-      self.caption = "CyberarmEngine #{CyberarmEngine::VERSION} #{Gosu.user_languages.join(', ')}"
+      self.caption = "CyberarmEngine #{CyberarmEngine::VERSION} #{Gosu.language}"
 
       @states = []
       @exit_on_opengl_error = false
-      preload_default_shaders if respond_to?(:preload_default_shaders)
-      @stats_plotter = Stats::StatsPlotter.new(2, 28) # FIXME: Make positioning easy
 
-      setup
-    end
-
-    def setup
+      setup if defined?(setup)
     end
 
     def draw
-      Stats.frame.start_timing(:draw)
-
-      current_state&.draw
-      Stats.frame.start_timing(:engine_stats_renderer)
-      @stats_plotter&.draw if @show_stats_plotter
-      Stats.frame.end_timing(:engine_stats_renderer)
-
-      Stats.frame.end_timing(:draw)
-      Stats.frame.start_timing(:interframe_sleep)
+      current_state.draw if current_state
     end
 
     def update
-      # Gosu calls update() then (optionally) draw(),
-      # so always end last frame and start next frame when update() is called.
-      Stats.frame&.end_timing(:interframe_sleep)
-      Stats.end_frame
-
-      Stats.new_frame
-
-      @delta_time = (Gosu.milliseconds - @current_frame_time) * 0.001
+      Stats.clear
 
+      current_state.update if current_state
       @last_frame_time = Gosu.milliseconds - @current_frame_time
       @current_frame_time = Gosu.milliseconds
-
-      Stats.frame.start_timing(:update)
-      current_state&.update
-      Stats.frame.end_timing(:update)
-
-      Stats.frame.start_timing(:interframe_sleep) unless needs_redraw?
     end
 
     def needs_cursor?
       @show_cursor
     end
 
-    def needs_redraw?
-      current_state ? current_state.needs_redraw? : true
-    end
-
-    def drop(filename)
-      current_state&.drop(filename)
-    end
-
-    def gamepad_connected(index)
-      current_state&.gamepad_connected(index)
-    end
-
-    def gamepad_disconnected(index)
-      current_state&.gamepad_disconnected(index)
-    end
-
-    def gain_focus
-      @has_focus = true
-
-      current_state&.gain_focus
-    end
-
-    def lose_focus
-      @has_focus = false
-
-      current_state&.lose_focus
-    end
-
-    def button_down(id)
-      super
-      current_state&.button_down(id)
-    end
-
-    def button_up(id)
-      super
-      current_state&.button_up(id)
-    end
-
-    def close
-      current_state ? current_state.close : super
-    end
-
     def dt
       @last_frame_time / 1000.0
     end
@@ -142,10 +61,20 @@ module CyberarmEngine
       @exit_on_opengl_error
     end
 
+    def button_down(id)
+      super
+      current_state.button_down(id) if current_state
+    end
+
+    def button_up(id)
+      super
+      current_state.button_up(id) if current_state
+    end
+
     def push_state(klass, options = {})
       options = { setup: true }.merge(options)
 
-      if klass.instance_of?(klass.class) && klass.respond_to?(:options)
+      if klass.instance_of?(klass.class) && defined?(klass.options)
         @states << klass
         klass.setup if options[:setup]
         klass.post_setup if options[:setup]
@@ -158,8 +87,6 @@ module CyberarmEngine
     end
 
     private def child_of?(input, klass)
-      return false unless input
-
       input.ancestors.detect { |c| c == klass }
     end
 
@@ -167,20 +94,18 @@ module CyberarmEngine
       @states.last
     end
 
+    def previous_state
+      if @states.size > 1 && (state = @states[@states.size - 2])
+        state
+      end
+    end
+
     def pop_state
       @states.pop
-
-      current_state.request_repaint if current_state&.is_a?(GuiState)
     end
 
     def shift_state
       @states.shift
-
-      current_state.request_repaint if current_state&.is_a?(GuiState)
-    end
-
-    def has_focus?
-      @has_focus
     end
 
     # Sourced from https://gist.github.com/ippa/662583

mrbgem.rake

@@ -1,29 +0,0 @@
-MRuby::Gem::Specification.new("mruby-cyberarm_engine") do |spec|
-  spec.license = "MIT"
-  spec.authors = "cyberarm"
-  spec.summary = " Yet another framework for building games with Gosu"
-
-  lib_rbfiles = []
-  # Dir.glob("#{File.expand_path("..", __FILE__)}/lib/**/*.rb").reject do |f|
-    # File.basename(f.downcase, ".rb") == "cyberarm_engine" ||
-    # File.basename(f.downcase, ".rb") == "opengl" ||
-    # f.downcase.include?("/opengl/")
-  # end.reverse!
-
-  local_path = File.expand_path("..", __FILE__)
-  File.read("#{local_path}/lib/cyberarm_engine.rb").each_line do |line|
-    line = line.strip
-
-    next unless line.start_with?("require_relative")
-
-    file = line.split("require_relative").last.strip.gsub("\"", "")
-
-    next if file.include?(" if ")
-
-    lib_rbfiles << "#{local_path}/lib/#{file}.rb"
-  end
-
-  pp lib_rbfiles
-
-  spec.rbfiles = lib_rbfiles
-end