Bump version

assets/shaders/fragment/g_buffer.glsl

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,69 @@
+#version 330 core
+out vec4 frag_color;
+
+@include "light_struct"
+const int DIRECTIONAL = 0;
+const int POINT = 1;
+const int SPOT = 2;
+
+flat in Light out_lights[7];
+in vec2 out_tex_coords;
+flat in int out_light_count;
+
+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

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

assets/shaders/include/material_struct.glsl

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,24 @@
+#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,6 @@ 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"
   spec.add_dependency "excon", "~> 0.88"
   spec.add_dependency "gosu", "~> 1.1"
   spec.add_dependency "gosu_more_drawables", "~> 0.3"

lib/cyberarm_engine.rb

@@ -7,14 +7,19 @@ else
 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"
 
@@ -24,6 +29,7 @@ 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"
@@ -66,6 +72,6 @@ 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/model/parsers/collada_parser" if RUBY_ENGINE != "mruby" && defined?(Nokogiri)
 
 require_relative "cyberarm_engine/builtin/intro_state"

lib/cyberarm_engine/background_image.rb

@@ -0,0 +1,93 @@
+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/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)
-      @caption = CyberarmEngine::Text.new("", size: @caption_size, shadow_color: 0xaa_222222)
+      @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)
 
       @spacer_width = 256
       @spacer_height = 6
@@ -18,7 +18,7 @@ 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 defined?(OpenGL)
+      @opengl_logo = generate_proxy("OpenGL", "Graphics API",         0xff_5586a4) if RUBY_ENGINE != "mruby" && defined?(OpenGL)
 
       base_time = Gosu.milliseconds
 

lib/cyberarm_engine/common.rb

@@ -8,8 +8,11 @@ module CyberarmEngine
       window.current_state
     end
 
-    def previous_state
-      window.previous_state
+    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?
     end
 
     def pop_state
@@ -28,6 +31,18 @@ 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)
     end
@@ -37,7 +52,7 @@ module CyberarmEngine
     end
 
     def lighten(color, amount = 25)
-      if defined?(color.alpha)
+      if color.respond_to?(: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)
@@ -45,7 +60,7 @@ module CyberarmEngine
     end
 
     def darken(color, amount = 25)
-      if defined?(color.alpha)
+      if color.respond_to?(: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)
@@ -95,7 +110,7 @@ module CyberarmEngine
     end
 
     def window
-      $window
+      CyberarmEngine::Window.instance
     end
 
     def control_down?

lib/cyberarm_engine/console.rb

@@ -103,7 +103,7 @@ module CyberarmEngine
 
     def button_down(id)
       case id
-      when Gosu::KbEnter, Gosu::KbReturn
+      when Gosu::KB_ENTER, Gosu::KB_RETURN
         return unless @text_input.text.length.positive?
 
         @history.text += "\n<c=999999>> #{@text_input.text}</c>"
@@ -113,12 +113,12 @@ module CyberarmEngine
         handle_command
         @text_input.text = ""
 
-      when Gosu::KbUp
+      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::KbDown
+      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
@@ -127,7 +127,7 @@ module CyberarmEngine
           @text_input.text = @command_history[@command_history_index]
         end
 
-      when Gosu::KbTab
+      when Gosu::KB_TAB
         split = @text_input.text.split(" ")
 
         if !@text_input.text.end_with?(" ") && split.size == 1
@@ -142,7 +142,7 @@ module CyberarmEngine
           cmd.autocomplete(self)
         end
 
-      when Gosu::KbBacktick
+      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]
@@ -151,7 +151,7 @@ module CyberarmEngine
                            end
 
       # Copy
-      when Gosu::KbC
+      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
@@ -160,7 +160,7 @@ module CyberarmEngine
         end
 
       # Paste
-      when Gosu::KbV
+      when Gosu::KB_V
         if control_down? && shift_down?
           string = @text_input.text.chars.insert(caret_pos, @memory).join
           _caret_pos = caret_pos
@@ -170,7 +170,7 @@ module CyberarmEngine
         end
 
       # Cut
-      when Gosu::KbX
+      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
@@ -182,7 +182,7 @@ module CyberarmEngine
         end
 
       # Delete word to left of caret
-      when Gosu::KbW
+      when Gosu::KB_W
         if control_down?
           split = @text_input.text.split(" ")
           split.delete(split.last)
@@ -190,7 +190,7 @@ module CyberarmEngine
         end
 
       # Clear history
-      when Gosu::KbL
+      when Gosu::KB_L
         @history.text = "" if control_down?
       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
-                    defined?(@image.width) ? ((@image.width + @image.height) / 4) * scale : 1
+                    @image.respond_to?(:width) ? ((@image.width + @image.height) / 4) * scale : 1
                   end
       end
     end
@@ -55,9 +55,9 @@ module CyberarmEngine
 
       if $debug
         show_debug_heading
-        $window.draw_circle(@position.x, @position.y, radius, 9999, @debug_color)
+        Gosu.draw_circle(@position.x, @position.y, radius, 9999, @debug_color)
         if @debug_text.text != ""
-          $window.draw_rect(@debug_text.x - 10, (@debug_text.y - 10), @debug_text.width + 20, @debug_text.height + 20,
+          Gosu.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,10 +153,6 @@ 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
 
@@ -190,12 +186,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
 
@@ -206,9 +202,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
@@ -220,13 +216,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
 
@@ -238,9 +234,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,48 +30,27 @@ module CyberarmEngine
       @game_objects.each(&:update)
     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
-      $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
-      )
+    def needs_redraw?
+      true
     end
 
-    def destroy
-      @options.clear
-      @game_objects.clear
+    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
     end
 
     def button_down(id)
@@ -90,6 +69,54 @@ 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

@@ -0,0 +1,98 @@
+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)
+    segments = 360.0 / segments
+
+    return if percentage == 0.0
+
+    0.step((359 * percentage), percentage > 0 ? segments : -segments) do |angle|
+      angle2 = angle + segments
+
+      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
+    end
+  end
+end

lib/cyberarm_engine/gosu_ext/draw_circle.rb

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -49,8 +49,9 @@ module CyberarmEngine
 
       @objects.each { |o| @vertex_count += o.vertices.size }
 
-      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      # 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"
     end
 
     def parse(parser)
@@ -150,24 +151,24 @@ module CyberarmEngine
       glBindBuffer(GL_ARRAY_BUFFER, @positions_buffer_id)
       gl_error?
 
-      #                     inPosition
+      #                     in_position
       glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nil)
       gl_error?
       # colors
       glBindBuffer(GL_ARRAY_BUFFER, @colors_buffer_id)
-      #                     inColor
+      #                     in_color
       glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nil)
       gl_error?
       # normals
       glBindBuffer(GL_ARRAY_BUFFER, @normals_buffer_id)
-      #                     inNormal
+      #                     in_normal
       glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, nil)
       gl_error?
 
       if has_texture?
         # uvs
         glBindBuffer(GL_ARRAY_BUFFER, @uvs_buffer_id)
-        #                     inUV
+        #                     in_uv
         glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, nil)
         gl_error?
       end
@@ -177,7 +178,7 @@ module CyberarmEngine
     end
 
     def build_collision_tree
-      @aabb_tree = AABBTree.new
+      @aabb_tree = IMICFPS::AABBTree.new
 
       @faces.each do |face|
         box = BoundingBox.new

lib/cyberarm_engine/notification.rb

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,242 @@
+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

@@ -11,7 +11,19 @@ module CyberarmEngine
     if e != GL_NO_ERROR
       warn "OpenGL error detected by handler at: #{caller[0]}"
       warn "    #{gluErrorString(e)} (#{e})\n"
-      exit if window.exit_on_opengl_error?
+      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"
+      )
     end
   end
 end

lib/cyberarm_engine/opengl/renderer/g_buffer.rb

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

lib/cyberarm_engine/opengl/renderer/opengl_renderer.rb

@@ -44,7 +44,7 @@ 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_vec3("cameraPosition", camera.position)
+            shader.uniform_vector3("camera_position", camera.position)
 
             gl_error?
             draw_model(entity.model, shader)
@@ -154,15 +154,21 @@ module CyberarmEngine
         glBindTexture(GL_TEXTURE_2D, @g_buffer.texture(:depth))
         shader.uniform_integer("depth", 4)
 
-        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)
+        # 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)
 
-          glDrawArrays(GL_TRIANGLES, 0, @g_buffer.vertices.size)
+            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
         end
 
         glBindVertexArray(0)
@@ -215,7 +221,7 @@ module CyberarmEngine
 
       offset = 0
       model.objects.each do |object|
-        shader.uniform_boolean("hasTexture", object.has_texture?)
+        shader.uniform_boolean("has_texture", 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,12 +4,23 @@ module CyberarmEngine
 
     def initialize
       @bounding_box_renderer = BoundingBoxRenderer.new
-      @opengl_renderer = OpenGLRenderer.new(width: $window.width, height: $window.height)
+      @opengl_renderer = OpenGLRenderer.new(width: CyberarmEngine::Window.instance.width, height: CyberarmEngine::Window.instance.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)
-      @bounding_box_renderer.render(entities) if @show_bounding_boxes
+      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)
     end
 
     def canvas_size_changed

lib/cyberarm_engine/opengl/shader.rb

@@ -385,7 +385,7 @@ module CyberarmEngine
     # @param value [Vector]
     # @param location [Integer]
     # @return [void]
-    def uniform_vec3(variable, value, location = nil)
+    def uniform_vector3(variable, value, location = nil)
       attr_loc = location || attribute_location(variable)
 
       glUniform3f(attr_loc, *value.to_a[0..2])
@@ -397,7 +397,7 @@ module CyberarmEngine
     # @param value [Vector]
     # @param location [Integer]
     # @return [void]
-    def uniform_vec4(variable, value, location = nil)
+    def uniform_vector4(variable, value, location = nil)
       attr_loc = location || attribute_location(variable)
 
       glUniform4f(attr_loc, *value.to_a)

lib/cyberarm_engine/stats.rb

@@ -1,20 +1,191 @@
 module CyberarmEngine
   class Stats
-    @@hash = {
-      gui_recalculations_last_frame: 0
-    }
+    @frames = []
+    @frame_index = -1
+    @max_frame_history = 1024
 
-    def self.get(key)
-      @@hash.dig(key)
+    def self.new_frame
+      if @frames.size < @max_frame_history
+        @frames << Frame.new
+      else
+        @frames[@frame_index] = Frame.new
+      end
     end
 
-    def self.increment(key, n)
-      @@hash[key] += n
+    def self.frame
+      @frames[@frame_index]
     end
 
-    def self.clear
-      @@hash.each do |key, _value|
-        @@hash[key] = 0
+    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)
+        @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)
+        @min_timing_label = CyberarmEngine::Text.new("", x: x + @padding + 1, y: y + @height - (@text_size + @padding / 2), z: z, size: @text_size, border: true)
+
+        @timings_label = CyberarmEngine::Text.new("", x: x + @padding + @width + @padding, y: y + @padding, z: z, size: @text_size, border: 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
+
+        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)
+        end
+      end
+
+      def draw
+        @frame_stats = CyberarmEngine::Stats.frames.select(&:complete?)
+        return if @frame_stats.empty?
+
+        calculate_graphs
+
+        @max_timing_label.text = "Max: #{@frame_stats.map { |f| f.frame_timing.duration }.max.to_s.rjust(3, " ")}ms"
+        @avg_timing_label.text = "Avg: #{(@frame_stats.map { |f| f.frame_timing.duration }.sum / @frame_stats.size).to_s.rjust(3, " ")}ms"
+        @min_timing_label.text = "Min: #{@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
+      end
+
+      def draw_graphs
+        Gosu.draw_path(@graphs[:frame_timings], Gosu::Color::WHITE, Float::INFINITY)
+      end
+
+      def draw_timings
+        frame = @frame_stats.last
+
+        @timings_label.text = "#{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(@timings_label.x - @padding, @timings_label.y - @padding, @timings_label.width + @padding * 2, @timings_label.height + @padding * 2, 0xdd_222222, @position.z)
+        @timings_label.draw
       end
     end
   end

lib/cyberarm_engine/text.rb

@@ -22,19 +22,21 @@ module CyberarmEngine
       else
         @color = Gosu::Color::WHITE
       end
-      @mode     = options[:mode]      || :default
+      @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]
+      @border_color = options[:border_color] || Gosu::Color::BLACK
 
       @shadow = options[:shadow]
       @shadow_size = options[:shadow_size] || 2
       @shadow_alpha = options[:shadow_alpha] || 30
-      @shadow_color = options[:shadow_color]
+      @shadow_color = options[:shadow_color] || Gosu::Color::BLACK
+
+      @static = options[:static] || (options[:static].nil? || options[:static] == false ? false : true)
 
       @textobject = check_cache(@size, @font)
 
@@ -43,9 +45,9 @@ module CyberarmEngine
         when :left
           @x = 0 + BUTTON_PADDING
         when :center
-          @x = ($window.width / 2) - (@textobject.text_width(@text) / 2)
+          @x = (CyberarmEngine::Window.instance.width / 2) - (@textobject.text_width(@text) / 2)
         when :right
-          @x = $window.width - BUTTON_PADDING - @textobject.text_width(@text)
+          @x = CyberarmEngine::Window.instance.width - BUTTON_PADDING - @textobject.text_width(@text)
         end
       end
     end
@@ -79,51 +81,55 @@ module CyberarmEngine
         @size = size
         @font = font_name
 
+        invalidate_cache!
         @textobject = check_cache(size, font_name)
       end
     end
 
     def text=(string)
-      @rendered_border = nil
+      invalidate_cache! if @text != string
       @text = string
     end
 
     def factor_x=(n)
-      @rendered_border = nil
+      invalidate_cache! if @factor_x != n
       @factor_x = n
     end
 
     def factor_y=(n)
-      @rendered_border = nil
+      invalidate_cache! if @factor_y != n
       @factor_y = n
     end
 
     def color=(color)
-      @rendered_border = nil
+      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
     end
 
     def border=(boolean)
-      @rendered_border = nil
+      invalidate_cache! if @border != boolean
       @border = boolean
     end
 
     def border_size=(n)
-      @rendered_border = nil
+      invalidate_cache! if @border_size != n
       @border_size = n
     end
 
     def border_alpha=(n)
-      @rendered_border = nil
+      invalidate_cache! if @border_alpha != n
       @border_alpha = n
     end
 
     def border_color=(n)
-      @rendered_border = nil
+      invalidate_cache! if @border_color != n
       @border_color = n
     end
 
@@ -132,11 +138,29 @@ module CyberarmEngine
     end
 
     def text_width(text = @text)
-      textobject.text_width(text) + @border_size + @shadow_size
+      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
     end
 
     def markup_width(text = @text)
-      textobject.markup_width(text) + @border_size + @shadow_size
+      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
     end
 
     def height(text = @text)
@@ -148,39 +172,72 @@ module CyberarmEngine
     end
 
     def draw(method = :draw_markup)
-      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
+      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)
 
-        _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
+            img.draw(-_x, 0, @z, @factor_x, @factor_y, @border_color, @mode)
+            img.draw(-_x, -_y, @z, @factor_x, @factor_y, @border_color, @mode)
 
-        @rendered_border ||= 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)
+            img.draw(0, -_y, @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 - @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)
+            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 + @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)
+            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
         end
 
-        @rendered_border.draw(@x - @border_size, @y - @border_size, @z, @factor_x, @factor_y, border_color)
-      end
+        @cached_text_shadow_image ||= Gosu::Image.send(:"from_#{method.to_s.split("_").last}", @text, @size, font: @font) if @shadow
 
-      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
+        @gosu_cached_text_image ||= Gosu::Image.send(:"from_#{method.to_s.split("_").last}", @text, @size, font: @font)
 
-      @textobject.send(method, @text, @x, @y, @z, @factor_x, @factor_y, @color, @mode)
+        @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)
+      end
     end
 
     def alpha=(n)
@@ -193,5 +250,11 @@ 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/ui/border_canvas.rb

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

lib/cyberarm_engine/ui/dsl.rb

@@ -116,7 +116,7 @@ module CyberarmEngine
     end
 
     private def element_parent
-      $__current_container__
+      CyberarmEngine::Element::Container.current_container
     end
 
     private def container(klass, options = {}, &block)
@@ -126,12 +126,12 @@ module CyberarmEngine
       _container = klass.new(options, block)
 
       old_parent = element_parent
-      $__current_container__ = _container
+      CyberarmEngine::Element::Container.current_container = _container
 
       _container.build
       _container.parent.add(_container)
 
-      $__current_container__ = old_parent
+      CyberarmEngine::Element::Container.current_container = old_parent
 
       _container
     end

lib/cyberarm_engine/ui/element.rb

@@ -30,6 +30,8 @@ module CyberarmEngine
       @y = @style.y
       @z = @style.z
 
+      @old_width  = 0
+      @old_height = 0
       @width  = 0
       @height = 0
 
@@ -38,6 +40,7 @@ module CyberarmEngine
 
       @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_event = :default
@@ -60,9 +63,12 @@ module CyberarmEngine
 
       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(*args)
@@ -104,6 +110,14 @@ module CyberarmEngine
       @style.background_nine_slice_bottom    = safe_style_fetch(:background_nine_slice_bottom) || @style.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)
 
@@ -156,10 +170,10 @@ module CyberarmEngine
       return if self.is_a?(ToolTip)
 
       if old_width != width || old_height != height
-        (root&.gui_state || @gui_state).request_recalculate
-      else
-        stylize
+        root.gui_state.request_recalculate
       end
+
+      stylize
     end
 
     def default_events
@@ -184,7 +198,7 @@ module CyberarmEngine
     end
 
     def enter(_sender)
-      @focus = false unless window.button_down?(Gosu::MsLeft)
+      @focus = false unless Gosu.button_down?(Gosu::MS_LEFT)
 
       if !@enabled
         update_styles(:disabled)
@@ -246,6 +260,8 @@ module CyberarmEngine
     end
 
     def enabled=(boolean)
+      root.gui_state.request_repaint if @enabled != boolean
+
       @enabled = boolean
 
       recalculate
@@ -257,6 +273,10 @@ module CyberarmEngine
       @enabled
     end
 
+    def focused?
+      @focus
+    end
+
     def visible?
       @visible
     end
@@ -268,18 +288,21 @@ module CyberarmEngine
     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
@@ -288,13 +311,15 @@ module CyberarmEngine
 
       @style.background_canvas.draw
       @style.background_nine_slice_canvas.draw
+      @style.background_image_canvas.draw
       @style.border_canvas.draw
 
       render
     end
 
     def debug_draw
-      return if defined?(GUI_DEBUG_ONLY_ELEMENT) && self.class == GUI_DEBUG_ONLY_ELEMENT
+      # FIXME
+      return# if const_defined?(GUI_DEBUG_ONLY_ELEMENT) && self.class == GUI_DEBUG_ONLY_ELEMENT
 
       Gosu.draw_line(
         x, y, @debug_color,
@@ -319,6 +344,7 @@ module CyberarmEngine
     end
 
     def update
+      recalculate_if_size_changed
     end
 
     def button_down(id)
@@ -388,10 +414,14 @@ module CyberarmEngine
     end
 
     def scroll_width
-      @children.sum(&:outer_width)
+      return @cached_scroll_width if @cached_scroll_width && is_a?(Container)
+
+      @cached_scroll_width = @children.sum(&:outer_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?
 
@@ -412,31 +442,62 @@ module CyberarmEngine
 
         pairs_ << a_ unless pairs_.last == a_
 
-        pairs_.sum { |pair| pair.map(&:outer_height).max } + @style.padding_bottom + @style.border_thickness_bottom
+        @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
-        @children.sum(&:outer_height) + @style.padding_bottom + @style.border_thickness_bottom
+        @cached_scroll_height = @style.padding_top + @style.border_thickness_top + @children.sum(&:outer_height) + @style.padding_bottom + @style.border_thickness_bottom
       end
     end
 
     def max_scroll_width
-      scroll_width - outer_width
+      (scroll_width - outer_width).positive? ? scroll_width - outer_width : scroll_width
     end
 
     def max_scroll_height
-      scroll_height - outer_height
+      (scroll_height - outer_height).positive? ? scroll_height - outer_height : scroll_height
     end
 
     def dimensional_size(size, dimension)
       raise "dimension must be either :width or :height" unless %i[width height].include?(dimension)
 
-      if size.is_a?(Numeric) && size.between?(0.0, 1.0)
-        (@parent.send(:"content_#{dimension}") * size).round - send(:"noncontent_#{dimension}").round
-      else
-        size
+      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)
       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
@@ -450,10 +511,13 @@ module CyberarmEngine
 
       @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
@@ -477,6 +541,35 @@ module CyberarmEngine
       @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 !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?
 
@@ -497,6 +590,22 @@ 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!"
 

lib/cyberarm_engine/ui/elements/button.rb

@@ -64,8 +64,8 @@ module CyberarmEngine
             @scale_y = 1
           end
 
-          @width = _width || @image.width.round * @scale_x
-          @height = _height || @image.height.round * @scale_y
+          @width = _width || @image.width.floor * @scale_x
+          @height = _height || @image.height.floor * @scale_y
 
           update_background
         else

lib/cyberarm_engine/ui/elements/container.rb

@@ -6,11 +6,24 @@ module CyberarmEngine
       attr_accessor :stroke_color, :fill_color
       attr_reader :children, :gui_state, :scroll_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
+
       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]
@@ -23,37 +36,41 @@ module CyberarmEngine
       def build
         @block.call(self) if @block
 
-        root.gui_state.request_recalculate
+        root.gui_state.request_recalculate_for(self)
       end
 
       def add(element)
         @children << element
 
-        root.gui_state.request_recalculate
+        root.gui_state.request_recalculate_for(self)
+      end
+
+      def remove(element)
+        root.gui_state.request_recalculate_for(self) if @children.delete(element)
       end
 
       def clear(&block)
         @children.clear
 
-        old_container = $__current_container__
+        old_container = CyberarmEngine::Element::Container.current_container
 
-        $__current_container__ = self
+        CyberarmEngine::Element::Container.current_container = self
         block.call(self) if block
 
-        $__current_container__ = old_container
+        CyberarmEngine::Element::Container.current_container = old_container
 
-        root.gui_state.request_recalculate
+        root.gui_state.request_recalculate_for(self)
       end
 
       def append(&block)
-        old_container = $__current_container__
+        old_container = CyberarmEngine::Element::Container.current_container
 
-        $__current_container__ = self
+        CyberarmEngine::Element::Container.current_container = self
         block.call(self) if block
 
-        $__current_container__ = old_container
+        CyberarmEngine::Element::Container.current_container = old_container
 
-        root.gui_state.request_recalculate
+        root.gui_state.request_recalculate_for(self)
       end
 
       def render
@@ -63,7 +80,9 @@ module CyberarmEngine
           content_width + 1,
           content_height + 1
         ) do
-          @children.each(&:draw)
+          Gosu.translate(@scroll_position.x, @scroll_position.y) do
+            @children.each(&:draw)
+          end
         end
       end
 
@@ -76,35 +95,74 @@ module CyberarmEngine
       end
 
       def update
+        update_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?(x, y)
+            if element = child.hit_element?(child_x, child_y)
               return element
             end
           else
-            return child if child.hit?(x, y)
+            return child if child.hit?(child_x, child_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 > 1 ? 1.0 : window.dt
+
+        scroll_x_diff = (@scroll_target_position.x - @scroll_position.x)
+        scroll_y_diff = (@scroll_target_position.y - @scroll_position.y)
+
+        @scroll_position.x += (scroll_x_diff * @scroll_speed * 0.25 * dt).round
+        @scroll_position.y += (scroll_y_diff * @scroll_speed * 0.25 * dt).round
+
+        @scroll_position.x = @scroll_target_position.x if scroll_x_diff.abs < 1.0
+        @scroll_position.y = @scroll_target_position.y if scroll_y_diff.abs < 1.0
+
+        # Scrolled PAST top
+        if @scroll_position.y > 0
+          @scroll_target_position.y = 0
+
+        # Scrolled PAST bottom
+        elsif @scroll_position.y.abs > 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.increment(:gui_recalculations_last_frame, 1)
+        Stats.frame.increment(:gui_recalculations)
 
         stylize
 
@@ -112,6 +170,12 @@ module CyberarmEngine
 
         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
@@ -122,11 +186,35 @@ 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).round
-          @height = _height || (@children.map { |c| c.y + c.outer_height }.max || 0).round
+          @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
         end
 
-        # Move child to parent after positioning
+        # 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
+
+        # Move children 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
@@ -135,15 +223,30 @@ module CyberarmEngine
           child.recalculate
           child.reposition # TODO: Implement top,bottom,left,center, and right positioning
 
-          Stats.increment(:gui_recalculations_last_frame, 1)
+          Stats.frame.increment(:gui_recalculations)
 
-          child.element_visible = child.x >= @x - child.width && child.x <= @x + width &&
-                                  child.y >= @y - child.height && child.y <= @y + height
+          update_child_element_visibity(child)
         end
 
         # puts "TOOK: #{Gosu.milliseconds - s}ms to recalculate #{self.class}:0x#{self.object_id.to_s(16)}"
 
         update_background
+
+        # Fixes resized container scrolled past bottom
+        self.scroll_top = -@scroll_position.y
+        @scroll_target_position.y = @scroll_position.y
+
+        # NOTE: Experiment for removing need to explicitly call gui_state#recalculate at least 3 times for layout to layout...
+        if old_width != @width || old_height != @height
+          if @parent
+            root.gui_state.request_recalculate_for(@parent)
+          else
+            root.gui_state.request_recalculate
+          end
+        end
+
+        root.gui_state.request_repaint if @width != old_width || @height != old_height
+        recalculate_if_size_changed
       end
 
       def layout
@@ -151,16 +254,17 @@ 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
+        # _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
       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
@@ -170,7 +274,6 @@ 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
@@ -183,14 +286,14 @@ module CyberarmEngine
         response
       end
 
-      def position_on_next_line(child) # Flow
-        @current_position.x = @style.margin_left
-        @current_position.y += tallest_neighbor(child, @current_position.y).outer_height
+      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
 
-        child.x = child.style.margin_left + @current_position.x
-        child.y = child.style.margin_top  + @current_position.y
+        element.x = element.style.margin_left + @current_position.x
+        element.y = element.style.margin_top  + @current_position.y
 
-        @current_position.x += child.outer_width
+        @current_position.x += element.outer_width
       end
 
       def move_to_next_line(element) # Stack
@@ -203,11 +306,13 @@ module CyberarmEngine
       def mouse_wheel_up(sender, x, y)
         return unless @style.scroll
 
-        if @scroll_position.y < 0
-          @scroll_position.y += @scroll_speed
-          @scroll_position.y = 0 if @scroll_position.y > 0
-
-          root.gui_state.request_recalculate_for(self)
+        # 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
 
           return :handled
         end
@@ -218,14 +323,13 @@ module CyberarmEngine
 
         return unless height < scroll_height
 
-        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
-
-          root.gui_state.request_recalculate_for(self)
-
-          return :handled
+        if @scroll_target_position.y > 0
+          @scroll_target_position.y = -@scroll_chunk
+        else
+          @scroll_target_position.y -= @scroll_chunk
         end
+
+        return :handled
       end
 
       def scroll_top
@@ -244,7 +348,7 @@ module CyberarmEngine
       end
 
       def value
-        @children.map { |c| c.class }.join(", ")
+        @children.map(&: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).round
+        ((y - @text.y) / @text.textobject.height).floor
       end
 
       def column_at(x, y)

lib/cyberarm_engine/ui/elements/edit_line.rb

@@ -1,6 +1,20 @@
 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)
@@ -14,17 +28,11 @@ module CyberarmEngine
         @caret_last_interval = Gosu.milliseconds
         @show_caret = true
 
-        @text_input = Gosu::TextInput.new
+        @text_input = TextInput.new
+        @text_input.filter = @filter
         @text_input.text = text
         @last_text_value = text
-
-        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
+        @last_caret_position = @text_input.caret_pos
 
         @offset_x = 0
         @offset_y = 0
@@ -72,10 +80,22 @@ 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
@@ -98,20 +118,20 @@ module CyberarmEngine
             @text_input.caret_pos = @text_input.text.length
 
           when Gosu::KB_C
-            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
+            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
 
           when Gosu::KB_X
             chars = @text_input.text.chars
 
             if @text_input.selection_start < @text_input.caret_pos
-              Clipboard.copy(@text_input.text[@text_input.selection_start...@text_input.caret_pos])
+              Gosu.clipboard = @text_input.text[@text_input.selection_start...@text_input.caret_pos]
               chars.slice!(@text_input.selection_start, @text_input.caret_pos)
             else
-              Clipboard.copy(@text_input.text[@text_input.caret_pos...@text_input.selection_start])
+              Gosu.clipboard = @text_input.text[@text_input.caret_pos...@text_input.selection_start]
               chars.slice!(@text_input.caret_pos, @text_input.selection_start)
             end
 
@@ -119,10 +139,9 @@ module CyberarmEngine
 
           when Gosu::KB_V
             if instance_of?(EditLine) # EditLine assumes a single line of text
-              @text_input.text = @text_input.text.insert(@text_input.caret_pos,
-                                                         Clipboard.paste.encode("UTF-8").gsub("\n", ""))
+              @text_input.insert_text(Gosu.clipboard.gsub("\n", ""))
             else
-              @text_input.text = @text_input.text.insert(@text_input.caret_pos, Clipboard.paste.encode("UTF-8"))
+              @text_input.insert_text(Gosu.clipboard)
             end
           end
         end
@@ -180,7 +199,7 @@ module CyberarmEngine
         if @type == :password
           @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)])
+          @text.x + @text.width(@text_input.text[0...@text_input.send(method)]) - @style.border_thickness_left
         end
       end
 
@@ -197,20 +216,35 @@ module CyberarmEngine
       end
 
       def focus(sender)
-        super
-
+        @focus = true
         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)
-        _has_focus = @focus
+        if @enabled && @focus
+          update_styles(:active)
+        elsif @enabled && !@focus
+          update_styles(:hover)
+        else
+          update_styles(:disabled)
+        end
 
-        super
+        :handled
+      end
 
-        @focus = _has_focus
+      def leave(sender)
+        if @enabled && @focus
+          update_styles(:active)
+        elsif @enabled && !@focus
+          update_styles
+        else
+          update_styles(:disabled)
+        end
 
         :handled
       end

lib/cyberarm_engine/ui/elements/image.rb

@@ -45,8 +45,8 @@ module CyberarmEngine
           @scale_y = 1
         end
 
-        @width = _width || @image.width.round * @scale_x
-        @height = _height || @image.height.round * @scale_y
+        @width = _width || (@image.width * @scale_x).floor
+        @height = _height || (@image.height * @scale_y).floor
 
         update_background
       end

lib/cyberarm_engine/ui/elements/list_box.rb

@@ -13,10 +13,12 @@ module CyberarmEngine
         @style.background_canvas.background = default(:background)
 
         # TODO: "Clean Up" into own class?
-        @menu = Stack.new(parent: parent, width: @options[:width], theme: @options[:theme])
+        @menu = Stack.new(parent: self, theme: @options[:theme])
         @menu.define_singleton_method(:recalculate_menu) do
           @x = @__list_box.x
           @y = @__list_box.y + @__list_box.height
+
+          @y = @__list_box.y - height if @y + height > window.height
         end
         @menu.instance_variable_set(:"@__list_box", self)
 
@@ -29,6 +31,13 @@ module CyberarmEngine
         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 }
         raise "Invalid value '#{item}' for choose, valid options were: #{@items.map { |i| "#{i.inspect}" }.join(", ")}" unless valid
@@ -55,6 +64,8 @@ module CyberarmEngine
       def show_menu
         @menu.clear
 
+        @menu.style.width = width
+
         @items.each do |item|
           next if item == self.value
 

lib/cyberarm_engine/ui/elements/progress.rb

@@ -52,6 +52,7 @@ module CyberarmEngine
         @marquee_animation_time = Gosu.milliseconds if @marquee_offset > range
 
         update_background
+        root.gui_state.request_repaint
       end
 
       def type=(type)
@@ -77,9 +78,13 @@ 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,7 +33,8 @@ module CyberarmEngine
         end
       end
 
-      attr_reader :range, :step_size, :value
+      attr_reader :step_size, :value
+      attr_accessor :range, :step_size
 
       def initialize(options = {}, block = nil)
         super(options, block)
@@ -42,7 +43,7 @@ module CyberarmEngine
         @step_size = @options[:step] || 0.1
         @value     = @options[:value] || (@range.first + @range.last) / 2
 
-        @handle = Handle.new("", parent: self, width: 8, height: 1.0) { close }
+        @handle = Handle.new("", parent: self, theme: options[:theme], width: 8, height: 1.0) { close }
         add(@handle)
       end
 
@@ -61,10 +62,10 @@ module CyberarmEngine
       end
 
       def position_handle
-        @handle.x = @x + @style.padding_left + @style.border_thickness_left +
+        @handle.x = @x + @handle.style.margin_left + @style.padding_left + @style.border_thickness_left +
                     ((content_width - @handle.outer_width) * (@value - @range.min) / (@range.max - @range.min).to_f)
 
-        @handle.y = @y + @style.border_thickness_top + @style.padding_top
+        @handle.y = @y + @handle.style.margin_top + @style.border_thickness_top + @style.padding_top
       end
 
       def draw
@@ -76,7 +77,7 @@ module CyberarmEngine
       def update
         super
 
-        @tip = value.to_s
+        @tip = format("%.2f", value.to_f)
         @handle.tip = @tip
       end
 
@@ -87,7 +88,7 @@ module CyberarmEngine
       end
 
       def handle_dragged_to(x, _y)
-        @ratio = ((x - @handle.width / 2) - @x) / (content_width - @handle.outer_width)
+        @ratio = ((x - @handle.width / 2.0) - @x) / (content_width - @handle.outer_width.to_f)
 
         self.value = @ratio.clamp(0.0, 1.0) * (@range.max - @range.min) + @range.min
       end
@@ -97,6 +98,8 @@ 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,6 +7,7 @@ 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],
@@ -17,8 +18,24 @@ module CyberarmEngine
         @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
-        @text.draw
+        # 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
       end
 
       def recalculate
@@ -28,6 +45,9 @@ module CyberarmEngine
           @text.color = @style.color
         end
 
+        old_width  = @width
+        old_height = @height
+
         @width  = 0
         @height = 0
 
@@ -36,13 +56,13 @@ module CyberarmEngine
 
         handle_text_wrapping(_width)
 
-        @width  = _width  || @text.width.round
-        @height = _height || @text.height.round
+        @width  = _width  || @text.width.floor
+        @height = _height || @text.height.floor
 
         @text.y = @style.border_thickness_top + @style.padding_top + @y
         @text.z = @z + 3
 
-        if (text_alignment = @options[:text_align])
+        if (text_alignment = @options[:text_align] || @options[:text_h_align])
           case text_alignment
           when :left
             @text.x = @style.border_thickness_left + @style.padding_left + @x
@@ -57,7 +77,23 @@ 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
+
+        root.gui_state.request_repaint if @width != old_width || @height != old_height
+        recalculate_if_size_changed
       end
 
       def handle_text_wrapping(max_width)
@@ -130,7 +166,7 @@ module CyberarmEngine
       end
 
       def line_width(text)
-        (@text.textobject.markup_width(text) + noncontent_width)
+        (@text.textobject.markup_width(text.to_s) + noncontent_width)
       end
 
       def value
@@ -138,6 +174,7 @@ module CyberarmEngine
       end
 
       def value=(value)
+        old_value = @raw_text
         @raw_text = value.to_s.chomp
 
         old_width = width
@@ -149,6 +186,8 @@ module CyberarmEngine
           recalculate
         end
 
+        root.gui_state.request_repaint if old_value != @raw_text
+
         publish(:changed, self.value)
       end
     end

lib/cyberarm_engine/ui/elements/toggle_button.rb

@@ -5,7 +5,7 @@ module CyberarmEngine
 
       def initialize(options, block = nil)
         if options.dig(:theme, :ToggleButton, :checkmark_image)
-          options[:theme][:ToggleButton][:image_width] ||= options[:theme][:Label][:text_size]
+          options[:theme][:ToggleButton][:image_width] ||= options[:theme][:TextBlock][:text_size]
           super(get_image(options.dig(:theme, :ToggleButton, :checkmark_image)), options, block)
 
           @_image = @image

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
-      $__current_container__ = @root_container
+      CyberarmEngine::Element::Container.current_container = @root_container
 
       @active_width  = window.width
       @active_height = window.height
@@ -27,6 +27,8 @@ module CyberarmEngine
       @pending_recalculate_request = false
       @pending_element_recalculate_requests = []
 
+      @needs_repaint = false
+
       @menu = nil
       @min_drag_distance = 0
       @mouse_pos = Vector.new
@@ -55,30 +57,44 @@ module CyberarmEngine
         @menu.draw
       end
 
-      if @tip.value.length.positive?
+      if @tip && @tip.value.length.positive?
         Gosu.flush
 
         @tip.draw
       end
 
-      if defined?(GUI_DEBUG)
+      # FIXME
+      if false# defined?(GUI_DEBUG)
         Gosu.flush
 
         @root_container.debug_draw
       end
+
+      @needs_repaint = false
+    end
+
+    def needs_repaint?
+      @needs_repaint
     end
 
     def update
+      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
-        @root_container.recalculate
-        @root_container.recalculate
+        Stats.frame.start_timing(:gui_recalculate)
+
         @root_container.recalculate
 
         @pending_recalculate_request = false
-      end
 
-      @pending_element_recalculate_requests.each(&:recalculate)
-      @pending_element_recalculate_requests.clear
+        Stats.frame.end_timing(:gui_recalculate)
+      end
 
       if @pending_focus_request
         @pending_focus_request = false
@@ -88,8 +104,20 @@ 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)
 
@@ -101,9 +129,9 @@ 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::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)
+      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)
 
       if Vector.new(window.mouse_x, window.mouse_y) == @last_mouse_pos
         if @mouse_over && (Gosu.milliseconds - @mouse_moved_at) > tool_tip_delay
@@ -125,31 +153,19 @@ 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::MsLeft
+      when Gosu::MS_LEFT
         redirect_mouse_button(:left)
-      when Gosu::MsMiddle
+      when Gosu::MS_MIDDLE
         redirect_mouse_button(:middle)
-      when Gosu::MsRight
+      when Gosu::MS_RIGHT
         redirect_mouse_button(:right)
-      when Gosu::KbF5
+      when Gosu::KB_F5
         request_recalculate
       end
 
@@ -160,19 +176,26 @@ module CyberarmEngine
       super
 
       case id
-      when Gosu::MsLeft
+      when Gosu::MS_LEFT
         redirect_released_mouse_button(:left)
-      when Gosu::MsMiddle
+      when Gosu::MS_MIDDLE
         redirect_released_mouse_button(:middle)
-      when Gosu::MsRight
+      when Gosu::MS_RIGHT
         redirect_released_mouse_button(:right)
-      when Gosu::MsWheelUp
+      when Gosu::MS_WHEEL_UP
         redirect_mouse_wheel(:up)
-      when Gosu::MsWheelDown
+      when Gosu::MS_WHEEL_DOWN
         redirect_mouse_wheel(: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)
@@ -183,7 +206,7 @@ module CyberarmEngine
         @focus = nil
       end
 
-      if @mouse_over
+      if @mouse_over && @hid_menu_for != @mouse_over
         @mouse_down_position[button] = Vector.new(window.mouse_x, window.mouse_y)
         @mouse_down_on[button]       = @mouse_over
 
@@ -197,7 +220,7 @@ module CyberarmEngine
     def redirect_released_mouse_button(button)
       hide_menu if @menu && (@menu == @mouse_over) || (@mouse_over&.parent == @menu)
 
-      if @mouse_over
+      if @mouse_over && @hid_menu_for != @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,
@@ -248,11 +271,22 @@ module CyberarmEngine
       @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,7 +20,8 @@ module CyberarmEngine
     attr_reader :hash
 
     def initialize(hash = {})
-      h = Marshal.load(Marshal.dump(hash))
+      h = hash
+      # h = Marshal.load(Marshal.dump(hash))
 
       h[:default] = {}
 

lib/cyberarm_engine/ui/theme.rb

@@ -76,6 +76,7 @@ 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: {
@@ -102,7 +103,12 @@ module CyberarmEngine
         caret_color: Gosu::Color::WHITE,
         caret_interval: 500,
         selection_color: Gosu::Color.rgba(255, 128, 50, 200),
-        text_align: :left
+        text_align: :left,
+        text_static: false # static text causes issues correctly displaying caret position
+      },
+
+      EditBox: { # < EditLine
+        text_v_align: :top
       },
 
       Image: { # < Element
@@ -154,6 +160,7 @@ module CyberarmEngine
       },
 
       ToolTip: { # < TextBlock
+        delay: 100, # ms
         color: Gosu::Color::WHITE,
         padding_top: 4,
         padding_bottom: 4,

lib/cyberarm_engine/vector.rb

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

lib/cyberarm_engine/version.rb

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

lib/cyberarm_engine/window.rb

@@ -6,49 +6,130 @@ module CyberarmEngine
     SAMPLES = {}
     SONGS = {}
 
-    attr_accessor :show_cursor
+    attr_accessor :show_cursor, :show_stats_plotter
     attr_writer :exit_on_opengl_error
-    attr_reader :last_frame_time
+    attr_reader :last_frame_time, :delta_time, :states
 
     def self.now
       Gosu.milliseconds
     end
 
     def self.dt
-      $window.last_frame_time / 1000.0
+      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
     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 = self
+      Window.instance = self
+
       @last_frame_time = Gosu.milliseconds - 1
       @current_frame_time = Gosu.milliseconds
-      self.caption = "CyberarmEngine #{CyberarmEngine::VERSION} #{Gosu.language}"
+      @delta_time = @last_frame_time
+      self.caption = "CyberarmEngine #{CyberarmEngine::VERSION} #{Gosu.user_languages.join(', ')}"
 
       @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 if defined?(setup)
+      setup
+    end
+
+    def setup
     end
 
     def draw
-      current_state.draw if current_state
+      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)
     end
 
     def update
-      Stats.clear
+      # 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
 
-      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
@@ -61,20 +142,10 @@ 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) && defined?(klass.options)
+      if klass.instance_of?(klass.class) && klass.respond_to?(:options)
         @states << klass
         klass.setup if options[:setup]
         klass.post_setup if options[:setup]
@@ -87,6 +158,8 @@ module CyberarmEngine
     end
 
     private def child_of?(input, klass)
+      return false unless input
+
       input.ancestors.detect { |c| c == klass }
     end
 
@@ -94,18 +167,20 @@ 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

@@ -0,0 +1,29 @@
+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