Bump version

Fixed ListBox sometimes returning self in callback instead of self.value
Bump version
2025-12-16 13:12:34 +00:00 · 2021-09-23 14:36:19 -05:00 · 2021-09-23 14:35:46 -05:00 · 2021-09-22 09:23:24 -05:00 · 2021-06-26 13:12:44 +00:00 · 2021-06-18 02:57:49 +00:00
33 changed files with 1486 additions and 440 deletions
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# CyberarmEngine
+![CyberarmEngine](https://raw.githubusercontent.com/cyberarm/cyberarm_engine/master/assets/textures/logo.png)

 Yet Another Game Engine On Top Of Gosu

@@ -32,6 +32,8 @@ require "cyberarm_engine"

 class Hello < CyberarmEngine::GuiState
  def setup
+    background Gosu::Color::GRAY
+
    stack do
      label "Hello World!"

@@ -43,15 +45,14 @@ class Hello < CyberarmEngine::GuiState
 end

 class Window < CyberarmEngine::Window
-  def initialize
-    super
+  def setup
    self.show_cursor = true

    push_state(Hello)
  end
 end

-Window.new.show
+Window.new(width: 800, height: 600, fullscreen: false, resizable: true).show
 ```

 ## Development
--- a/assets/textures/logo.png
+++ b/assets/textures/logo.png
--- a/cyberarm_engine.gemspec
+++ b/cyberarm_engine.gemspec
@@ -29,11 +29,11 @@ Gem::Specification.new do |spec|

  spec.add_dependency "clipboard", "~> 1.3.5"
  spec.add_dependency "excon", "~> 0.78.0"
-  spec.add_dependency "gosu", "~> 1.0.0"
+  spec.add_dependency "gosu", "~> 1.1"
  spec.add_dependency "gosu_more_drawables", "~> 0.3"
  # spec.add_dependency "ffi", :platforms => [:mswin, :mingw] # Required by Clipboard on Windows

-  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "bundler", "~> 2.2"
  spec.add_development_dependency "minitest", "~> 5.0"
  spec.add_development_dependency "rake", "~> 13.0"
 end
--- a/lib/cyberarm_engine.rb
+++ b/lib/cyberarm_engine.rb
@@ -1,9 +1,8 @@
 CYBERARM_ENGINE_ROOT_PATH = File.expand_path("..", __dir__)

-begin
-  require File.expand_path("../../ffi-gosu/lib/gosu", File.dirname(__FILE__))
-rescue LoadError => e
-  pp e
+if ARGV.join.include?("--ffi-gosu")
+  require File.expand_path("../../ffi-gosu/lib/gosu", __dir__)
+else
  require "gosu"
 end
 require "json"
@@ -24,12 +23,18 @@ require_relative "cyberarm_engine/vector"
 require_relative "cyberarm_engine/transform"
 require_relative "cyberarm_engine/ray"
 require_relative "cyberarm_engine/background"
+require_relative "cyberarm_engine/background_nine_slice"
 require_relative "cyberarm_engine/animator"

 require_relative "cyberarm_engine/text"
 require_relative "cyberarm_engine/timer"
 require_relative "cyberarm_engine/config_file"

+require_relative "cyberarm_engine/console"
+require_relative "cyberarm_engine/console/command"
+require_relative "cyberarm_engine/console/subcommand"
+require_relative "cyberarm_engine/console/commands/help_command"
+
 require_relative "cyberarm_engine/ui/dsl"

 require_relative "cyberarm_engine/ui/theme"
@@ -62,3 +67,5 @@ require_relative "cyberarm_engine/model/model_object"
 require_relative "cyberarm_engine/model/parser"
 require_relative "cyberarm_engine/model/parsers/wavefront_parser"
 require_relative "cyberarm_engine/model/parsers/collada_parser" if defined?(Nokogiri)
+
+require_relative "cyberarm_engine/builtin/intro_state"
--- a/lib/cyberarm_engine/animator.rb
+++ b/lib/cyberarm_engine/animator.rb
@@ -1,11 +1,11 @@
 module CyberarmEngine
  class Animator
-    DEFAULT_TWEEN = :linear
-    def initialize(start_time:, duration:, from:, to:, &block)
+    def initialize(start_time:, duration:, from:, to:, tween: :linear, &block)
      @start_time = start_time
      @duration = duration
      @from = from.dup
      @to = to.dup
+      @tween = tween
      @block = block
    end

@@ -14,18 +14,18 @@ module CyberarmEngine
    end

    def progress
-      (@start_time.to_f + (Gosu.milliseconds - @start_time)) / (@start_time + @duration.to_f)
+      ((Gosu.milliseconds - @start_time) / @duration.to_f).clamp(0.0, 1.0)
    end

    def complete?
      progress >= 1.0
    end

-    def transition(from, to, tween = DEFAULT_TWEEN)
+    def transition(from = @from, to = @to, tween = @tween)
      from + (to - from) * send("tween_#{tween}", progress)
    end

-    def color_transition(from, to, _tween = DEFAULT_TWEEN)
+    def color_transition(from = @from, to = @to, _tween = @tween)
      r = transition(from.red, to.red)
      g = transition(from.green, to.green)
      b = transition(from.blue, to.blue)
@@ -34,7 +34,7 @@ module CyberarmEngine
      Gosu::Color.rgba(r, g, b, a)
    end

-    def color_hsv_transition(from, to, tween = DEFAULT_TWEEN)
+    def color_hsv_transition(from = @from, to = @to, tween = @tween)
      hue = transition(from.hue, to.hue, tween)
      saturation = transition(from.saturation, to.saturation, tween)
      value = transition(from.value, to.value, tween)
@@ -43,14 +43,177 @@ module CyberarmEngine
      Gosu::Color.from_ahsv(alpha, hue, saturation, value)
    end

-    # NOTE: Use this for future reference? https://github.com/danro/easing-js/blob/master/easing.js
+    # Tween functions based on those provided here: https://github.com/danro/easing-js/blob/master/easing.js
+    # Under MIT / BSD

    def tween_linear(t)
      t
    end

-    def tween_sine(t)
-      Math.sin(t) * t
+    def tween_ease_in_quad(t)
+      t ** 2
+    end
+
+    def tween_ease_out_quad(t)
+      -((t - 1) ** 2) -1
+    end
+
+    def tween_ease_in_out_quad(t)
+      return 0.5 * (t ** 2) if (t /= 0.5) < 1
+      return -0.5 * ((t -= 2) * t - 2)
+    end
+
+    def tween_ease_in_cubic(t)
+      t ** 3
+    end
+
+    def tween_ease_out_cubic(t)
+      ((t - 1) ** 3) + 1
+    end
+
+    def tween_ease_in_out_cubic(t)
+      return 0.5 * (t ** 3) if ((t /= 0.5) < 1)
+      return 0.5 * ((t - 2) ** 3) + 2
+    end
+
+    def tween_ease_in_quart(t)
+      t ** 4
+    end
+
+    def tween_ease_out_quart(t)
+      -((t - 1) ** 4) - 1
+    end
+
+    def tween_ease_in_out_quart(t)
+      return 0.5 * (t ** 4) if ((t /= 0.5) < 1)
+      return -0.5 * ((t -= 2) * (t ** 3) - 2)
+    end
+
+    def tween_ease_in_quint(t)
+      t ** 5
+    end
+
+    def tween_ease_out_quint(t)
+      ((t - 1) ** 5) + 1
+    end
+
+    def tween_ease_in_out_quint(t)
+      return 0.5 * (t ** 5) if ((t /= 0.5) < 1)
+      return 0.5 * ((t - 2) ** 5) + 2
+    end
+
+    def tween_ease_in(t) # sine
+      -Math.cos(t * (Math::PI / 2)) + 1
+    end
+
+    def tween_ease_out(t) # sine
+      Math.sin(t * (Math::PI / 2))
+    end
+
+    def tween_ease_in_out(t) # sine
+      (-0.5 * (Math.cos(Math::PI * t) - 1))
+    end
+
+    def tween_ease_in_expo(t)
+      (t == 0) ? 0 : 2 ** 10 * (t - 1)
+    end
+
+    def tween_ease_out_expo(t)
+      (t == 1) ? 1 : -(2 ** -10 * t) + 1
+    end
+
+    def tween_ease_in_out_expo(t)
+      return 0 if (t == 0)
+      return 1 if (t == 1)
+      return 0.5 * (2 ** 10 * (t - 1)) if ((t /= 0.5) < 1)
+      return 0.5 * (-(2 ** -10 * (t -= 1)) + 2)
+    end
+
+    def tween_ease_in_circ(t)
+      -(Math.sqrt(1 - (t * t)) - 1)
+    end
+
+    def tween_ease_out_circ(t)
+      Math.sqrt(1 - ((t - 1) ** 2))
+    end
+
+    def tween_ease_in_out_circ(t)
+      return -0.5 * (Math.sqrt(1 - t * t) - 1) if ((t /= 0.5) < 1)
+      return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1)
+    end
+
+    def tween_ease_in_back(t)
+      s = 1.70158
+      t * t * ((s + 1) * t - s)
+    end
+
+    def tween_ease_out_back(t)
+      s = 1.70158
+      (t = t - 1) * t * ((s + 1) * t + s) + 1
+    end
+
+    def tween_ease_in_out_back(t)
+      s = 1.70158
+      return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s)) if ((t /= 0.5) < 1)
+      return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2)
+    end
+
+    def tween_elastic(t)
+      -1 * (4 ** (-8 * t)) * Math.sin((t * 6 - 1) * (2 * Math::PI) / 2) + 1
+    end
+
+    def tween_swing_from_to(t)
+      s = 1.70158
+      return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s)) if (t /= 0.5) < 1
+      return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2)
+    end
+
+    def tween_swing_from(t)
+      s = 1.70158;
+      t * t * ((s + 1) * t - s)
+    end
+
+    def tween_swing_to(t)
+      s = 1.70158
+      (t -= 1) * t * ((s + 1) * t + s) + 1
+    end
+
+    def tween_bounce(t)
+      if (t < (1 / 2.75))
+        (7.5625 * t * t)
+      elsif (t < (2 / 2.75))
+        (7.5625 * (t -= (1.5 / 2.75)) * t + 0.75)
+      elsif (t < (2.5 / 2.75))
+        (7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375)
+      else
+        (7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375)
+      end
+    end
+
+    def tween_bounce_past(t)
+      if (t < (1 / 2.75))
+        # missing "2 -"?
+        (7.5625 * t * t)
+      elsif (t < (2 / 2.75))
+        2 - (7.5625 * (t -= (1.5 / 2.75)) * t + 0.75)
+      elsif (t < (2.5 / 2.75))
+        2 - (7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375)
+      else
+        2 - (7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375)
+      end
+    end
+
+    def tween_ease_from_to(t)
+      return 0.5 * (t ** 4) if ((t /= 0.5) < 1)
+      return -0.5 * ((t -= 2) * (t ** 3) - 2)
+    end
+
+    def tween_ease_from(t)
+      t ** 4
+    end
+
+    def tween_ease_to(t)
+      t ** 0.25
    end
  end
 end
--- a/lib/cyberarm_engine/background_nine_slice.rb
+++ b/lib/cyberarm_engine/background_nine_slice.rb
@@ -1,10 +1,11 @@
 module CyberarmEngine
  class BackgroundNineSlice
    include CyberarmEngine::Common
-    attr_accessor :x, :y, :z, :width, :height
+    attr_accessor :x, :y, :z, :width, :height, :left, :top, :right, :bottom, :mode, :color
+    attr_reader :image

-    def initialize(image_path:, x: 0, y: 0, z: 0, width: 64, height: 64, mode: :tiled, left: 4, top: 4, right: 56, bottom: 56)
-      @image = get_image(image_path)
+    def initialize(image_path: nil, x: 0, y: 0, z: 0, width: 0, height: 0, mode: :tiled, left: 1, top: 1, right: 1, bottom: 1, color: Gosu::Color::WHITE)
+      @image = get_image(image_path) if image_path

      @x = x
      @y = y
@@ -20,23 +21,33 @@ module CyberarmEngine
      @right = right
      @bottom = bottom

-      nine_slice
+      @color = color
+
+      nine_slice if @image
+    end
+
+    def image=(image_path)
+      old_image = @image
+      @image = image_path ? get_image(image_path) : image_path
+      nine_slice if @image && old_image != @image
    end

    def nine_slice
-      @segment_top_left = Gosu.render(@left, @top) { @image.draw(0, 0, 0) }
-      @segment_top_right = Gosu.render(@image.width - @right, @top) { @image.draw(-@right, 0, 0) }
+      # pp [@left, @top, @right, @bottom, @image.width]

-      @segment_left = Gosu.render(@left, @bottom - @top) { @image.draw(0, -@top, 0) }
-      @segment_right = Gosu.render(@image.width - @right, @bottom - @top) { @image.draw(-@right, -@top, 0) }
+      @segment_top_left = @image.subimage(0, 0, @left, @top)
+      @segment_top_right = @image.subimage(@image.width - @right, 0, @right, @top)

-      @segment_bottom_left = Gosu.render(@left, @image.height - @bottom) { @image.draw(0, -@bottom, 0) }
-      @segment_bottom_right = Gosu.render(@image.width - @right, @image.height - @bottom) { @image.draw(-@right, -@bottom, 0) }
+      @segment_left = @image.subimage(0, @top, @left, @image.height - (@top + @bottom))
+      @segment_right = @image.subimage(@image.width - @right, @top, @left, @image.height - (@top + @bottom))

-      @segment_top = Gosu.render(@right - @left, @top) { @image.draw(-@left, 0, 0) }
-      @segment_bottom = Gosu.render(@right - @left, @image.height - @bottom) { @image.draw(-@left, -@bottom, 0) }
+      @segment_bottom_left = @image.subimage(0, @image.height - @bottom, @left, @bottom)
+      @segment_bottom_right = @image.subimage(@image.width - @right, @image.height - @bottom, @right, @bottom)

-      @segment_middle = Gosu.render(@right - @left, @bottom - @top) { @image.draw(-@left, -@top, 0) }
+      @segment_top = @image.subimage(@left, 0, @image.width - (@left + @right), @top)
+      @segment_bottom = @image.subimage(@left, @image.height - @bottom, @image.width - (@left + @right), @bottom)
+
+      @segment_middle = @image.subimage(@left, @top, @image.width - (@left + @right), @image.height - (@top + @bottom))
    end

    def cx
@@ -56,67 +67,73 @@ module CyberarmEngine
    end

    def width_scale
-      width_scale = (@width - (@left + (@image.width - @right))).to_f / (@right - @left)
+      scale = (@width.to_f - (@left + @right)) / (@image.width - (@left + @right))
+      scale.abs
    end

    def height_scale
-      height_scale = (@height - (@top + (@image.height - @bottom))).to_f / (@bottom - @top)
+      scale = (@height - (@top + @bottom)).to_f / (@image.height - (@top + @bottom))
+      scale.abs
    end

    def draw
+      return unless @image && @segment_top_left
+
      @mode == :tiled ? draw_tiled : draw_stretched
    end

    def draw_stretched
-      @segment_top_left.draw(@x, @y, @z)
-      @segment_top.draw(@x + @segment_top_left.width, @y, @z, width_scale) # SCALE X
-      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z)
+      @segment_top_left.draw(@x, @y, @z, 1, 1, @color)
+      @segment_top.draw(@x + @segment_top_left.width, @y, @z, width_scale, 1, @color) # SCALE X
+      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z, 1, 1, @color)

-      @segment_right.draw((@x + @width) - @segment_right.width, @y + @top, @z, 1, height_scale) # SCALE Y
-      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z)
-      @segment_bottom.draw(@x + @segment_bottom_left.width, (@y + @height) - @segment_bottom.height, @z, width_scale) # SCALE X
-      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z)
-      @segment_left.draw(@x, @y + @top, @z, 1, height_scale) # SCALE Y
-      @segment_middle.draw(@x + @segment_top_left.width, @y + @segment_top.height, @z, width_scale, height_scale) # SCALE X and SCALE Y
+      @segment_right.draw((@x + @width) - @segment_right.width, @y + @top, @z, 1, height_scale, @color) # SCALE Y
+      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z, 1, 1, @color)
+      @segment_bottom.draw(@x + @segment_bottom_left.width, (@y + @height) - @segment_bottom.height, @z, width_scale, 1, @color) # SCALE X
+      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z, 1, 1, @color)
+      @segment_left.draw(@x, @y + @top, @z, 1, height_scale, @color) # SCALE Y
+      @segment_middle.draw(@x + @segment_top_left.width, @y + @segment_top.height, @z, width_scale, height_scale, @color) # SCALE X and SCALE Y
    end

    def draw_tiled
-      @segment_top_left.draw(@x, @y, @z)
+      @segment_top_left.draw(@x, @y, @z, 1, 1, @color)
+
+      # p [width_scale, height_scale]

      Gosu.clip_to(@x + @segment_top_left.width, @y, @segment_top.width * width_scale, @segment_top.height) do
        width_scale.ceil.times do |i|
-          @segment_top.draw(@x + @segment_top_left.width + (@segment_top.width * i), @y, @z) # SCALE X
+          @segment_top.draw(@x + @segment_top_left.width + (@segment_top.width * i), @y, @z, 1, 1, @color) # SCALE X
        end
      end

-      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z)
+      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z, 1, 1, @color)

      Gosu.clip_to(@x + @width - @segment_top_right.width, @y + @top, @segment_right.width, @segment_right.height * height_scale) do
        height_scale.ceil.times do |i|
-          @segment_right.draw((@x + @width) - @segment_right.width, @y + @top + (@segment_right.height * i), @z) # SCALE Y
+          @segment_right.draw((@x + @width) - @segment_right.width, @y + @top + (@segment_right.height * i), @z, 1, 1, @color) # SCALE Y
        end
      end

-      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z)
+      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z, 1, 1, @color)

      Gosu.clip_to(@x + @segment_top_left.width, @y + @height - @segment_bottom.height, @segment_top.width * width_scale, @segment_bottom.height) do
        width_scale.ceil.times do |i|
-          @segment_bottom.draw(@x + @segment_bottom_left.width + (@segment_bottom.width * i), (@y + @height) - @segment_bottom.height, @z) # SCALE X
+          @segment_bottom.draw(@x + @segment_bottom_left.width + (@segment_bottom.width * i), (@y + @height) - @segment_bottom.height, @z, 1, 1, @color) # SCALE X
        end
      end

-      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z)
+      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z, 1, 1, @color)

      Gosu.clip_to(@x, @y + @top, @segment_left.width, @segment_left.height * height_scale) do
        height_scale.ceil.times do |i|
-          @segment_left.draw(@x, @y + @top + (@segment_left.height * i), @z) # SCALE Y
+          @segment_left.draw(@x, @y + @top + (@segment_left.height * i), @z, 1, 1, @color) # SCALE Y
        end
      end

      Gosu.clip_to(@x + @segment_top_left.width, @y + @segment_top.height, @width - (@segment_left.width + @segment_right.width), @height - (@segment_top.height + @segment_bottom.height)) do
        height_scale.ceil.times do |y|
          width_scale.ceil.times do |x|
-            @segment_middle.draw(@x + @segment_top_left.width + (@segment_middle.width * x), @y + @segment_top.height + (@segment_middle.height * y), @z) # SCALE X and SCALE Y
+            @segment_middle.draw(@x + @segment_top_left.width + (@segment_middle.width * x), @y + @segment_top.height + (@segment_middle.height * y), @z, 1, 1, @color) # SCALE X and SCALE Y
          end
        end
      end
--- a/lib/cyberarm_engine/builtin/intro_state.rb
+++ b/lib/cyberarm_engine/builtin/intro_state.rb
@@ -0,0 +1,131 @@
+module CyberarmEngine
+  class IntroState < CyberarmEngine::GameState
+    def setup
+      @display_width  = 800
+      @display_height = 600
+
+      @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)
+
+      @spacer_width = 256
+      @spacer_height = 6
+      @padding = 6
+
+      @cyberarm_engine_logo = get_image "#{CYBERARM_ENGINE_ROOT_PATH}/assets/textures/logo.png"
+
+      @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)
+
+      base_time = Gosu.milliseconds
+
+      @born_time = Gosu.milliseconds
+      @continue_after = 5_000
+
+      @animators = [
+        Animator.new(start_time: base_time += 1000, duration: 100,   from: 0.0, to: 1.0, tween: :ease_in_out),
+        Animator.new(start_time: base_time += -500, duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
+        Animator.new(start_time: base_time += 500,  duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
+        Animator.new(start_time: base_time += 500,  duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
+        Animator.new(start_time: base_time +  500,  duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
+        Animator.new(start_time: Gosu.milliseconds + @continue_after - 1_000,  duration: 1_000, from: 0.0, to: 1.0, tween: :ease_in_out),
+
+        Animator.new(start_time: Gosu.milliseconds + 250, duration: 500, from: 0.0, to: 1.0, tween: :swing_to) # CyberarmEngine LOGO
+      ]
+    end
+
+    def draw
+      Gosu.draw_rect(0, 0, window.width, window.height, 0xff_222222)
+
+      scale = (@display_width - @padding * 2).to_f / @cyberarm_engine_logo.width * @animators.last.transition
+
+      @cyberarm_engine_logo.draw_rot(
+        window.width / 2,
+        (window.height) / 2 - @cyberarm_engine_logo.height / 2 - @padding * 2,
+        2,
+        0,
+        0.5,
+        0.5,
+        scale,
+        scale
+      )
+
+      Gosu.draw_rect(
+        window.width / 2 - (@display_width / 2 + @padding),
+        window.height / 2 - @spacer_height / 2,
+        @display_width + @padding,
+        @spacer_height * @animators[0].transition,
+        Gosu::Color::WHITE
+      )
+
+      @title.x = window.width / 2 - @title.text_width / 2
+      @title.y = (window.height / 2 + (@spacer_height / 2) + @padding) * @animators[1].transition
+      @title.text = "Powered By"
+
+      Gosu.clip_to(0, window.height / 2 + (@spacer_height / 2), window.width, @title.height) do
+        @title.draw
+      end
+
+      y = @title.y + @title.height * 2
+
+      Gosu.clip_to(0, y, window.width, @gosu_logo.height) do
+        Gosu.translate(@opengl_logo.nil? ? @ruby_logo.width / 2 : 0, 0) do
+          @gosu_logo.draw(
+            window.width.to_f / 2 - @ruby_logo.width / 2 - (@ruby_logo.width - @padding),
+            y * @animators[2].transition,
+            2
+          )
+          @ruby_logo.draw(
+            window.width.to_f / 2 - @ruby_logo.width / 2,
+            y * @animators[3].transition,
+            2
+          )
+          @opengl_logo&.draw(
+            window.width.to_f / 2 - @ruby_logo.width / 2 + (@ruby_logo.width - @padding),
+            y * @animators[4].transition,
+            2
+          )
+        end
+      end
+
+      Gosu.draw_rect(0, 0, window.width, window.height, Gosu::Color.rgba(0, 0, 0, 255 * @animators[5].transition), 10_000)
+    end
+
+    def update
+      @animators.each(&:update)
+
+      return unless Gosu.milliseconds - @born_time >= @continue_after
+
+      pop_state
+      push_state(@options[:forward], @options[:forward_options] || {}) if @options[:forward]
+    end
+
+    def button_down(_id)
+      @continue_after = 0
+    end
+
+    def generate_proxy(title, caption, color_hint)
+      @title.text = title
+      @caption.text = caption
+
+      width = @spacer_width + 2 * @padding
+      height = @title_size + @caption_size + @spacer_height + 2 * @padding + @spacer_height
+
+      Gosu.record(width.ceil, height.ceil) do
+        @title.x = (width - @padding * 2) / 2 - @title.text_width / 2
+        @title.y = @padding
+        @title.draw
+
+        Gosu.draw_rect(0, @padding + @title_size + @padding, @spacer_width, @spacer_height, Gosu::Color::WHITE)
+        Gosu.draw_rect(1, @padding + @title_size + @padding + 1, @spacer_width - 2, @spacer_height - 2, color_hint)
+
+        @caption.x =  (width - @padding * 2) / 2 - @caption.text_width / 2
+        @caption.y = @padding + @title_size + @padding + @spacer_height + @padding
+        @caption.draw
+      end
+    end
+  end
+end
--- a/lib/cyberarm_engine/common.rb
+++ b/lib/cyberarm_engine/common.rb
@@ -16,6 +16,10 @@ module CyberarmEngine
      window.pop_state
    end

+    def shift_state
+      window.shift_state
+    end
+
    def show_cursor
      window.show_cursor
    end
@@ -24,8 +28,8 @@ module CyberarmEngine
      window.show_cursor = boolean
    end

-    def draw_rect(x, y, width, height, color, z = 0)
-      Gosu.draw_rect(x, y, width, height, color, z)
+    def draw_rect(x, y, width, height, color, z = 0, mode = :default)
+      Gosu.draw_rect(x, y, width, height, color, z, mode)
    end

    def fill(color, z = 0)
@@ -70,6 +74,7 @@ module CyberarmEngine
                   else
                     klass.new(path)
                   end
+
        hash[path] = instance
        asset = instance
      end
@@ -92,5 +97,17 @@ module CyberarmEngine
    def window
      $window
    end
+
+    def control_down?
+      Gosu.button_down?(Gosu::KB_LEFT_CONTROL) || Gosu.button_down?(Gosu::KB_RIGHT_CONTROL)
+    end
+
+    def shift_down?
+      Gosu.button_down?(Gosu::KB_LEFT_SHIFT) || Gosu.button_down?(Gosu::KB_RIGHT_SHIFT)
+    end
+
+    def alt_down?
+      Gosu.button_down?(Gosu::KB_LEFT_ALT) || Gosu.button_down?(Gosu::KB_RIGHT_ALT)
+    end
  end
 end
--- a/lib/cyberarm_engine/console.rb
+++ b/lib/cyberarm_engine/console.rb
@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module CyberarmEngine
+  class Console
+    Z = 100_000
+    PADDING = 2
+    include Common
+
+    attr_reader :text_input
+
+    def initialize(font: Gosu.default_font_name)
+      @text_input = Gosu::TextInput.new
+      @width  = window.width  / 4 * 3
+      @height = window.height / 4 * 3
+
+      @input = Text.new("", x: 4, y: @height - (PADDING * 2), z: Console::Z + 1, font: font)
+      @input.y -= @input.height
+
+      @history = Text.new("", x: 4, z: Console::Z + 1, font: font, border: true, border_color: Gosu::Color::BLACK)
+      update_history_y
+
+      @command_history       = []
+      @command_history_index = 0
+
+      @memory = ""
+
+      @background_color = Gosu::Color.rgba(0, 0, 0, 200)
+      @foreground_color = Gosu::Color.rgba(100, 100, 100, 100)
+      @input_color      = Gosu::Color.rgba(100, 100, 100, 200)
+
+      @showing_cursor = false
+      @active_text_input = nil
+
+      @show_caret = true
+      @caret_last_change = Gosu.milliseconds
+      @caret_interval = 250
+      @caret_color = Gosu::Color::WHITE
+      @selection_color = Gosu::Color.new(0x5522ff22)
+    end
+
+    def draw
+      # Background/Border
+      draw_rect(0, 0, @width, @height, @background_color, Console::Z)
+      # Foregound/History
+      draw_rect(PADDING, PADDING, @width - (PADDING * 2), @height - (PADDING * 2), @foreground_color, Console::Z)
+      # Text bar
+      draw_rect(2, @input.y, @width - (PADDING * 2), @input.height, @input_color, Console::Z)
+
+      @history.draw
+      @input.draw
+      # Caret
+      if @show_caret
+        draw_rect(@input.x + caret_from_left, @input.y, Console::PADDING, @input.height, @caret_color, Console::Z + 2)
+      end
+      # Caret selection
+      if caret_start != caret_end
+        if caret_start < @text_input.selection_start
+          draw_rect(@input.x + caret_from_left, @input.y, caret_selection_width, @input.height, @selection_color, Console::Z)
+        else
+          draw_rect((@input.x + caret_from_left) - caret_selection_width, @input.y, caret_selection_width, @input.height, @selection_color, Console::Z)
+        end
+      end
+    end
+
+    def caret_from_left
+      return 0 if @text_input.caret_pos.zero?
+
+      @input.textobject.text_width(@text_input.text[0..@text_input.caret_pos - 1])
+    end
+
+    def caret_selection_width
+      @input.textobject.text_width(@text_input.text[caret_start..(caret_end - 1)])
+    end
+
+    def caret_pos
+      @text_input.caret_pos
+    end
+
+    def caret_start
+      @text_input.selection_start < @text_input.caret_pos ? @text_input.selection_start : @text_input.caret_pos
+    end
+
+    def caret_end
+      @text_input.selection_start > @text_input.caret_pos ? @text_input.selection_start : @text_input.caret_pos
+    end
+
+    def update
+      if Gosu.milliseconds - @caret_last_change >= @caret_interval
+        @caret_last_change = Gosu.milliseconds
+        @show_caret = !@show_caret
+      end
+
+      if @width != window.width || @height != @height
+        @width  = window.width  / 4 * 3
+        @height = window.height / 4 * 3
+
+        @input.y = @height - (PADDING * 2 + @input.height)
+        update_history_y
+      end
+
+      @input.text = @text_input.text
+    end
+
+    def button_down(id)
+      case id
+      when Gosu::KbEnter, Gosu::KbReturn
+        return unless @text_input.text.length.positive?
+
+        @history.text += "\n<c=999999>> #{@text_input.text}</c>"
+        @command_history << @text_input.text
+        @command_history_index = @command_history.size
+        update_history_y
+        handle_command
+        @text_input.text = ""
+
+      when Gosu::KbUp
+        @command_history_index -= 1
+        @command_history_index = 0 if @command_history_index.negative?
+        @text_input.text = @command_history[@command_history_index]
+
+      when Gosu::KbDown
+        @command_history_index += 1
+        if @command_history_index > @command_history.size - 1
+          @text_input.text = "" unless @command_history_index > @command_history.size
+          @command_history_index = @command_history.size
+        else
+          @text_input.text = @command_history[@command_history_index]
+        end
+
+      when Gosu::KbTab
+        split = @text_input.text.split(" ")
+
+        if !@text_input.text.end_with?(" ") && split.size == 1
+          list = abbrev_search(Console::Command.list_commands.map { |cmd| cmd.command.to_s }, @text_input.text)
+
+          if list.size == 1
+            @text_input.text = "#{list.first} "
+          elsif list.size.positive?
+            stdin("\n#{list.map { |cmd| Console::Style.highlight(cmd) }.join(', ')}")
+          end
+        elsif split.size.positive? && cmd = Console::Command.find(split.first)
+          cmd.autocomplete(self)
+        end
+
+      when Gosu::KbBacktick
+        # Remove backtick character from input
+        @text_input.text = if @text_input.text.size > 1
+                             @text_input.text[0..@text_input.text.size - 2]
+                           else
+                             ""
+                           end
+
+      # Copy
+      when Gosu::KbC
+        if control_down? && shift_down?
+          @memory = @text_input.text[caret_start..caret_end - 1] if caret_start != caret_end
+          p @memory
+        elsif control_down?
+          @text_input.text = ""
+        end
+
+      # Paste
+      when Gosu::KbV
+        if control_down? && shift_down?
+          string = @text_input.text.chars.insert(caret_pos, @memory).join
+          _caret_pos = caret_pos
+          @text_input.text = string
+          @text_input.caret_pos = _caret_pos + @memory.length
+          @text_input.selection_start = _caret_pos + @memory.length
+        end
+
+      # Cut
+      when Gosu::KbX
+        if control_down? && shift_down?
+          @memory = @text_input.text[caret_start..caret_end - 1] if caret_start != caret_end
+          string  = @text_input.text.chars
+          Array(caret_start..caret_end - 1).each_with_index do |i, j|
+            string.delete_at(i - j)
+          end
+
+          @text_input.text = string.join
+        end
+
+      # Delete word to left of caret
+      when Gosu::KbW
+        if control_down?
+          split = @text_input.text.split(" ")
+          split.delete(split.last)
+          @text_input.text = split.join(" ")
+        end
+
+      # Clear history
+      when Gosu::KbL
+        @history.text = "" if control_down?
+      end
+    end
+
+    def button_up(id)
+    end
+
+    def update_history_y
+      @history.y = @height - (PADDING * 2) - @input.height - (@history.text.lines.count * @history.textobject.height)
+    end
+
+    def handle_command
+      string = @text_input.text
+      split  = string.split(" ")
+      command = split.first
+      arguments = split.length.positive? ? split[1..split.length - 1] : []
+
+      CyberarmEngine::Console::Command.use(command, arguments, self)
+    end
+
+    def abbrev_search(array, text)
+      return [] unless text.length.positive?
+
+      list = []
+      Abbrev.abbrev(array).each do |abbrev, value|
+        next unless abbrev&.start_with?(text)
+
+        list << value
+      end
+
+      list.uniq
+    end
+
+    def stdin(string)
+      @history.text += "\n#{string}"
+      update_history_y
+    end
+
+    def focus
+      @active_text_input = window.text_input
+      window.text_input = @text_input
+
+      @showing_cursor = window.needs_cursor
+      window.needs_cursor = true
+
+      @show_caret = true
+      @caret_last_change = Gosu.milliseconds
+    end
+
+    def blur
+      window.text_input  = @active_text_input
+      window.needs_cursor = @showing_cursor
+    end
+  end
+end
--- a/lib/cyberarm_engine/console/command.rb
+++ b/lib/cyberarm_engine/console/command.rb
@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module CyberarmEngine
+  class Console
+    module Style
+      def self.error(string)
+        "<c=ff5555>#{string}</c>"
+      end
+
+      def self.warn(string)
+        "<c=ff7700>#{string}</c>"
+      end
+
+      def self.notice(string)
+        "<c=55ff55>#{string}</c>"
+      end
+
+      def self.highlight(string, color = "5555ff")
+        "<c=#{color}>#{string}</c>"
+      end
+    end
+
+    class Command
+      def self.inherited(subclass)
+        @list ||= []
+        @commands ||= []
+        @list << subclass
+      end
+
+      def self.setup
+        @list ||= []
+        @commands = []
+        @list.each do |subclass|
+          cmd = subclass.new
+          if @commands.detect { |c| c.command == cmd.command }
+            raise "Command '#{cmd.command}' from '#{cmd.class}' already exists!"
+          end
+
+          @commands << cmd
+        end
+      end
+
+      def self.use(command, arguments, console)
+        found_command = @commands.detect { |cmd| cmd.command == command.to_sym }
+
+        if found_command
+          found_command.handle(arguments, console)
+        else
+          console.stdin("Command #{Style.error(command)} not found.")
+        end
+      end
+
+      def self.find(command)
+        @commands.detect { |cmd| cmd.command == command.to_sym }
+      end
+
+      def self.list_commands
+        @commands
+      end
+
+      def initialize
+        @store = {}
+        @subcommands = []
+
+        setup
+      end
+
+      def setup
+      end
+
+      def subcommand(command, type)
+        if @subcommands.detect { |subcmd| subcmd.command == command.to_sym }
+          raise "Subcommand '#{command}' for '#{self.command}' already exists!"
+        end
+
+        @subcommands << SubCommand.new(self, command, type)
+      end
+
+      def get(key)
+        @store[key]
+      end
+
+      def set(key, value)
+        @store[key] = value
+      end
+
+      def group
+        raise NotImplementedError
+      end
+
+      def command
+        raise NotImplementedError
+      end
+
+      def handle(arguments, console)
+        raise NotImplementedError
+      end
+
+      def autocomplete(console)
+        split = console.text_input.text.split(" ")
+
+        if @subcommands.size.positive?
+          if !console.text_input.text.end_with?(" ") && split.size == 2
+            list = console.abbrev_search(@subcommands.map { |cmd| cmd.command.to_s }, split.last)
+
+            if list.size == 1
+              console.text_input.text = "#{split.first} #{list.first} "
+            else
+              return unless list.size.positive?
+
+              console.stdin(list.map { |cmd| Console::Style.highlight(cmd) }.join(", ").to_s)
+            end
+
+          # List available options on subcommand
+          elsif (console.text_input.text.end_with?(" ") && split.size == 2) || !console.text_input.text.end_with?(" ") && split.size == 3
+            subcommand = @subcommands.detect { |cmd| cmd.command.to_s == (split[1]) }
+
+            if subcommand
+              if split.size == 2
+                console.stdin("Available options: #{subcommand.values.map { |value| Console::Style.highlight(value) }.join(',')}")
+              else
+                list = console.abbrev_search(subcommand.values, split.last)
+                if list.size == 1
+                  console.text_input.text = "#{split.first} #{split[1]} #{list.first} "
+                elsif list.size.positive?
+                  console.stdin("Available options: #{list.map { |value| Console::Style.highlight(value) }.join(',')}")
+                end
+              end
+            end
+
+          # List available subcommands if command was entered and has only a space after it
+          elsif console.text_input.text.end_with?(" ") && split.size == 1
+            console.stdin("Available subcommands: #{@subcommands.map { |cmd| Console::Style.highlight(cmd.command) }.join(', ')}")
+          end
+        end
+      end
+
+      def handle_subcommand(arguments, console)
+        if arguments.size.zero?
+          console.stdin(usage)
+          return
+        end
+        subcommand = arguments.delete_at(0)
+
+        found_command = @subcommands.detect { |cmd| cmd.command == subcommand.to_sym }
+        if found_command
+          found_command.handle(arguments, console)
+        else
+          console.stdin("Unknown subcommand #{Style.error(subcommand)} for #{Style.highlight(command)}")
+        end
+      end
+
+      def usage
+        raise NotImplementedError
+      end
+    end
+  end
+end
--- a/lib/cyberarm_engine/console/commands/help_command.rb
+++ b/lib/cyberarm_engine/console/commands/help_command.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module CyberarmEngine
+  class Console
+    class HelpCommand < CyberarmEngine::Console::Command
+      def group
+        :global
+      end
+
+      def command
+        :help
+      end
+
+      def handle(arguments, console)
+        console.stdin(usage(arguments.first))
+      end
+
+      def autocomplete(console)
+        split = console.text_input.text.split(" ")
+        if !console.text_input.text.start_with?(" ") && split.size == 2
+          list = console.abbrev_search(Command.list_commands.map { |cmd| cmd.command.to_s }, split.last)
+          if list.size == 1
+            console.text_input.text = "#{split.first} #{list.first} "
+          elsif list.size > 1
+            console.stdin(list.map { |cmd| Style.highlight(cmd) }.join(", "))
+          end
+        end
+      end
+
+      def usage(command = nil)
+        if command
+          if cmd = Command.find(command)
+            cmd.usage
+          else
+            "#{Style.error(command)} is not a command"
+          end
+        else
+          "Available commands:\n#{Command.list_commands.map { |cmd| Style.highlight(cmd.command).to_s }.join(', ')}"
+        end
+      end
+    end
+  end
+end
--- a/lib/cyberarm_engine/console/subcommand.rb
+++ b/lib/cyberarm_engine/console/subcommand.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module CyberarmEngine
+  class Console
+    class Command
+      class SubCommand
+        def initialize(parent, command, type)
+          @parent = parent
+          @command = command
+          @type = type
+        end
+
+        attr_reader :command
+
+        def handle(arguments, console)
+          if arguments.size > 1
+            console.stdin("to many arguments for #{Style.highlight(command.to_s)}, got #{Style.error(arguments.size)} expected #{Style.notice(1)}.")
+            return
+          end
+
+          case @type
+          when :boolean
+            case arguments.last
+            when "", nil
+              var = @parent.get(command.to_sym) || false
+              console.stdin("#{command}: #{Style.highlight(var)}")
+            when "on"
+              var = @parent.set(command.to_sym, true)
+              console.stdin("#{command} => #{Style.highlight(var)}")
+            when "off"
+              var = @parent.set(command.to_sym, false)
+              console.stdin("#{command} => #{Style.highlight(var)}")
+            else
+              console.stdin("Invalid argument for #{Style.highlight(command.to_s)}, got #{Style.error(arguments.last)} expected #{Style.notice('on')}, or #{Style.notice('off')}.")
+            end
+          when :string
+            case arguments.last
+            when "", nil
+              var = @parent.get(command.to_sym) || "\"\""
+              console.stdin("#{command}: #{Style.highlight(var)}")
+            else
+              var = @parent.set(command.to_sym, arguments.last)
+              console.stdin("#{command} => #{Style.highlight(var)}")
+            end
+          when :integer
+            case arguments.last
+            when "", nil
+              var = @parent.get(command.to_sym) || "nil"
+              console.stdin("#{command}: #{Style.highlight(var)}")
+            else
+              begin
+                var = @parent.set(command.to_sym, Integer(arguments.last))
+                console.stdin("#{command} => #{Style.highlight(var)}")
+              rescue ArgumentError
+                console.stdin("Error: #{Style.error("Expected an integer, got '#{arguments.last}'")}")
+              end
+            end
+          when :decimal
+            case arguments.last
+            when "", nil
+              var = @parent.get(command.to_sym) || "nil"
+              console.stdin("#{command}: #{Style.highlight(var)}")
+            else
+              begin
+                var = @parent.set(command.to_sym, Float(arguments.last))
+                console.stdin("#{command} => #{Style.highlight(var)}")
+              rescue ArgumentError
+                console.stdin("Error: #{Style.error("Expected a decimal or integer, got '#{arguments.last}'")}")
+              end
+            end
+          else
+            raise RuntimeError
+          end
+        end
+
+        def values
+          case @type
+          when :boolean
+            %w[on off]
+          else
+            []
+          end
+        end
+
+        def usage
+          case @type
+          when :boolean
+            "#{Style.highlight(command)} #{Style.notice('[on|off]')}"
+          when :string
+            "#{Style.highlight(command)} #{Style.notice('[string]')}"
+          when :integer
+            "#{Style.highlight(command)} #{Style.notice('[0]')}"
+          when :decimal
+            "#{Style.highlight(command)} #{Style.notice('[0.0]')}"
+          end
+        end
+      end
+    end
+  end
+end
--- a/lib/cyberarm_engine/game_state.rb
+++ b/lib/cyberarm_engine/game_state.rb
@@ -17,6 +17,11 @@ module CyberarmEngine
    def setup
    end

+    # Called immediately after setup returns.
+    # GuiState uses this to set current_theme for ToolTip
+    def post_setup
+    end
+
    def draw
      @game_objects.each(&:draw)
    end
--- a/lib/cyberarm_engine/model.rb
+++ b/lib/cyberarm_engine/model.rb
@@ -3,7 +3,8 @@ module CyberarmEngine
    attr_accessor :objects, :materials, :vertices, :uvs, :texures, :normals, :faces, :colors, :bones, :material_file,
                  :current_material, :current_object, :vertex_count, :smoothing
    attr_reader :position, :bounding_box, :textured_material, :file_path, :positions_buffer_id, :colors_buffer_id,
-                :normals_buffer_id, :uvs_buffer_id, :textures_buffer_id, :vertex_array_id, :aabb_tree
+                :normals_buffer_id, :uvs_buffer_id, :textures_buffer_id, :vertex_array_id, :aabb_tree,
+                :vertices_count

    def initialize(file_path:)
      @file_path = file_path
@@ -23,6 +24,8 @@ module CyberarmEngine
      @bones    = []
      @smoothing = 0

+      @vertices_count = 0
+
      @bounding_box = BoundingBox.new
      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)

@@ -32,6 +35,8 @@ module CyberarmEngine

      parse(parser)

+      @vertices_count = @vertices.size
+
      @has_texture = false

      @materials.each do |_key, material|
--- a/lib/cyberarm_engine/opengl/perspective_camera.rb
+++ b/lib/cyberarm_engine/opengl/perspective_camera.rb
@@ -3,8 +3,8 @@ module CyberarmEngine
    attr_accessor :position, :orientation, :aspect_ratio, :field_of_view,
                  :min_view_distance, :max_view_distance

-    def initialize(position:, aspect_ratio:, orientation: Vector.new(0, 0,
-                                                                     0), field_of_view: 70.0, min_view_distance: 0.1, max_view_distance: 155.0)
+    def initialize(position:, aspect_ratio:, orientation: Vector.new(0, 0, 0),
+                   field_of_view: 70.0, min_view_distance: 0.1, max_view_distance: 1024.0)
      @position = position
      @orientation = orientation

--- a/lib/cyberarm_engine/opengl/renderer/opengl_renderer.rb
+++ b/lib/cyberarm_engine/opengl/renderer/opengl_renderer.rb
@@ -3,12 +3,15 @@ module CyberarmEngine
    @@immediate_mode_warning = false

    attr_accessor :show_wireframe
+    attr_reader :number_of_vertices

    def initialize(width:, height:, show_wireframe: false)
      @width = width
      @height = height
      @show_wireframe = show_wireframe

+      @number_of_vertices = 0
+
      @g_buffer = GBuffer.new(width: @width, height: @height)
    end

@@ -20,6 +23,8 @@ module CyberarmEngine
    end

    def render(camera, lights, entities)
+      @number_of_vertices = 0
+
      glViewport(0, 0, @width, @height)
      glEnable(GL_DEPTH_TEST)

@@ -44,6 +49,8 @@ module CyberarmEngine
            gl_error?
            draw_model(entity.model, shader)
            entity.draw
+
+            @number_of_vertices += entity.model.vertices_count
          end
        end

@@ -90,6 +97,8 @@ module CyberarmEngine
          draw_mesh(entity.model)
          entity.draw
          glPopMatrix
+
+          @number_of_vertices += entity.model.vertices_count
        end
      end

--- a/lib/cyberarm_engine/opengl/texture.rb
+++ b/lib/cyberarm_engine/opengl/texture.rb
@@ -54,7 +54,7 @@ module CyberarmEngine
      texture_id = tex_names_buf.unpack1("L2")

      glBindTexture(GL_TEXTURE_2D, texture_id)
-      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, array_of_pixels)
+      glTexImage2D(GL_TEXTURE_2D, 0, GL_SRGB_ALPHA, image.width, image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, array_of_pixels)
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) if @retro
--- a/lib/cyberarm_engine/text.rb
+++ b/lib/cyberarm_engine/text.rb
@@ -3,7 +3,9 @@ module CyberarmEngine
    CACHE = {}

    attr_accessor :x, :y, :z, :size, :options
-    attr_reader :text, :textobject, :factor_x, :factor_y, :color, :shadow, :shadow_size, :shadow_alpha, :shadow_color
+    attr_reader :text, :textobject, :factor_x, :factor_y, :color,
+                :border, :border_size, :border_alpha, :border_color,
+                :shadow, :shadow_size, :shadow_alpha, :shadow_color

    def initialize(text, options = {})
      @text = text.to_s || ""
@@ -15,16 +17,25 @@ module CyberarmEngine
      @z = options[:z] || 1025
      @factor_x = options[:factor_x]  || 1
      @factor_y = options[:factor_y]  || 1
-      @color    = options[:color]     || Gosu::Color::WHITE
+      if options[:color]
+        @color = options[:color].is_a?(Gosu::Color) ? options[:color] : Gosu::Color.new(options[:color])
+      else
+        @color = Gosu::Color::WHITE
+      end
      @mode     = options[:mode]      || :default
      @alignment = options[:alignment] || nil
-      @shadow   = true  if options[:shadow] == true
-      @shadow   = false if options[:shadow] == false
-      @shadow   = true if options[:shadow].nil?
-      @shadow_size = options[:shadow_size] || 1
-      @shadow_alpha = options[:shadow_alpha] || 30
+
+      @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]
+
+      @shadow = options[:shadow]
+      @shadow_size = options[:shadow_size] || 2
      @shadow_alpha = options[:shadow_alpha] || 30
      @shadow_color = options[:shadow_color]
+
      @textobject = check_cache(@size, @font)

      if @alignment
@@ -37,8 +48,6 @@ module CyberarmEngine
          @x = $window.width - BUTTON_PADDING - @textobject.text_width(@text)
        end
      end
-
-      self
    end

    def check_cache(size, font_name)
@@ -65,82 +74,110 @@ module CyberarmEngine
      font
    end

+    def swap_font(size, font_name = @font)
+      if @size != size || @font != font_name
+        @size = size
+        @font = font_name
+
+        @textobject = check_cache(size, font_name)
+      end
+    end
+
    def text=(string)
-      @rendered_shadow = nil
+      @rendered_border = nil
      @text = string
    end

    def factor_x=(n)
-      @rendered_shadow = nil
+      @rendered_border = nil
      @factor_x = n
    end

    def factor_y=(n)
-      @rendered_shadow = nil
+      @rendered_border = nil
      @factor_y = n
    end

    def color=(color)
-      @rendered_shadow = nil
-      @color = color
+      @rendered_border = nil
+      if color
+        @color = color.is_a?(Gosu::Color) ? color : Gosu::Color.new(color)
+      else
+        raise "color cannot be nil"
+      end
    end

-    def shadow=(boolean)
-      @rendered_shadow = nil
-      @shadow = boolean
+    def border=(boolean)
+      @rendered_border = nil
+      @border = boolean
    end

-    def shadow_size=(n)
-      @rendered_shadow = nil
-      @shadow_size = n
+    def border_size=(n)
+      @rendered_border = nil
+      @border_size = n
    end

-    def shadow_alpha=(n)
-      @rendered_shadow = nil
-      @shadow_alpha = n
+    def border_alpha=(n)
+      @rendered_border = nil
+      @border_alpha = n
    end

-    def shadow_color=(n)
-      @rendered_shadow = nil
-      @shadow_color = n
+    def border_color=(n)
+      @rendered_border = nil
+      @border_color = n
    end

    def width(text = @text)
-      textobject.text_width(text)
+      markup_width(text)
+    end
+
+    def text_width(text = @text)
+      textobject.text_width(text) + @border_size + @shadow_size
    end

    def markup_width(text = @text)
-      textobject.markup_width(text)
+      textobject.markup_width(text) + @border_size + @shadow_size
    end

    def height(text = @text)
-      text.lines.count > 0 ? text.lines.count * textobject.height : @textobject.height
+      if text.lines.count > 0
+        text.lines.count * textobject.height + @border_size + @shadow_size
+      else
+        @textobject.height + @border_size + @shadow_size
+      end
    end

    def draw(method = :draw_markup)
-      if @shadow && !ARGV.join.include?("--no-shadow")
-        shadow_alpha = @color.alpha <= 30 ? @color.alpha : @shadow_alpha
-        shadow_color = @shadow_color || Gosu::Color.rgba(@color.red, @color.green, @color.blue,
-                                                         shadow_alpha)
+      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 = @shadow_size
-        _y = @shadow_size
+        _x = @border_size
+        _y = @border_size
+        _width = method == :draw_markup ? text_width : markup_width

-        @rendered_shadow ||= Gosu.render((width + (shadow_size * 2)).ceil, (height + (@shadow_size * 2)).ceil) do
-          @textobject.send(method, @text, _x - @shadow_size, _y, @z, @factor_x, @factor_y, white, :add)
-          @textobject.send(method, @text, _x - @shadow_size, _y - @shadow_size, @z, @factor_x, @factor_y, white, :add)
+        @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)

-          @textobject.send(method, @text, _x, _y - @shadow_size, @z, @factor_x, @factor_y, white, :add)
-          @textobject.send(method, @text, _x + @shadow_size, _y - @shadow_size, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x, _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 + @shadow_size, @z, @factor_x, @factor_y, white, :add)
-          @textobject.send(method, @text, _x - @shadow_size, _y + @shadow_size, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x, _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 + @shadow_size, _y, @z, @factor_x, @factor_y, white, :add)
-          @textobject.send(method, @text, _x + @shadow_size, _y + @shadow_size, @z, @factor_x, @factor_y, white, :add)
+          @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
-        @rendered_shadow.draw(@x - @shadow_size, @y - @shadow_size, @z, @factor_x, @factor_y, shadow_color)
+
+        @rendered_border.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)
--- a/lib/cyberarm_engine/ui/dsl.rb
+++ b/lib/cyberarm_engine/ui/dsl.rb
@@ -23,7 +23,8 @@ module CyberarmEngine
      "Tagline",
      "Caption",
      "Para",
-      "Inscription"
+      "Inscription",
+      "Link"
    ].each do |const|
      define_method(:"#{const.downcase}") do |text, options = {}, &block|
        options[:parent] = element_parent
@@ -97,7 +98,7 @@ module CyberarmEngine
    end

    def background(color = Gosu::Color::NONE)
-      element_parent.style.background = color
+      element_parent.style.default[:background] = color
    end

    def theme(theme)
--- a/lib/cyberarm_engine/ui/element.rb
+++ b/lib/cyberarm_engine/ui/element.rb
@@ -18,6 +18,8 @@ module CyberarmEngine
      @visible = @options[:visible].nil? ? true  : @options[:visible]
      @tip     = @options[:tip] || ""

+      @debug_color = @options[:debug_color].nil? ? Gosu::Color::RED : @options[:debug_color]
+
      @style = Style.new(options)

      @root ||= nil
@@ -34,23 +36,33 @@ module CyberarmEngine
      @style.height = default(:height) || nil

      @style.background_canvas = Background.new
-      @style.border_canvas     = BorderCanvas.new(element: self)
+      @style.background_nine_slice_canvas = BackgroundNineSlice.new
+      @style.border_canvas = BorderCanvas.new(element: self)
+
+      @style_event = :default

      stylize

      default_events
+
+      root.gui_state.request_focus(self) if @options[:autofocus]
    end

    def stylize
      set_static_position
-      set_border_thickness(@style.border_thickness)

-      set_padding(@style.padding)
+      set_padding
+      set_margin

-      set_margin(@style.margin)
+      set_background
+      set_background_nine_slice

-      set_background(@style.background)
-      set_border_color(@style.border_color)
+      set_border_thickness
+      set_border_color
+    end
+
+    def safe_style_fetch(*args)
+      @style.hash.dig(@style_event, *args) || @style.hash.dig(:default, *args) || default(*args)
    end

    def set_static_position
@@ -58,47 +70,89 @@ module CyberarmEngine
      @y = @style.y if @style.y != 0
    end

-    def set_background(background)
-      @style.background = background
-      @style.background_canvas.background = background
+    def set_background
+      @style.background = safe_style_fetch(:background)
+
+      @style.background_canvas.background = @style.background
    end

-    def set_border_thickness(border_thickness)
-      @style.border_thickness = border_thickness
+    def set_background_nine_slice
+      @style.background_nine_slice = safe_style_fetch(:background_nine_slice)

-      @style.border_thickness_left   = default(:border_thickness_left)   || @style.border_thickness
-      @style.border_thickness_right  = default(:border_thickness_right)  || @style.border_thickness
-      @style.border_thickness_top    = default(:border_thickness_top)    || @style.border_thickness
-      @style.border_thickness_bottom = default(:border_thickness_bottom) || @style.border_thickness
+      @style.background_nine_slice_mode = safe_style_fetch(:background_nine_slice_mode) || :stretch
+      @style.background_nine_slice_color = safe_style_fetch(:background_nine_slice_color) || Gosu::Color::WHITE
+      @style.background_nine_slice_canvas.color = @style.background_nine_slice_color
+
+      @style.background_nine_slice_from_edge = safe_style_fetch(:background_nine_slice_from_edge)
+
+      @style.background_nine_slice_left      = safe_style_fetch(:background_nine_slice_left)   || @style.background_nine_slice_from_edge
+      @style.background_nine_slice_top       = safe_style_fetch(:background_nine_slice_top)    || @style.background_nine_slice_from_edge
+      @style.background_nine_slice_right     = safe_style_fetch(:background_nine_slice_right)  || @style.background_nine_slice_from_edge
+      @style.background_nine_slice_bottom    = safe_style_fetch(:background_nine_slice_bottom) || @style.background_nine_slice_from_edge
    end

-    def set_border_color(color)
-      @style.border_color = color
+    def set_border_thickness
+      @style.border_thickness = safe_style_fetch(:border_thickness)

-      @style.border_color_left   = default(:border_color_left)   || @style.border_color
-      @style.border_color_right  = default(:border_color_right)  || @style.border_color
-      @style.border_color_top    = default(:border_color_top)    || @style.border_color
-      @style.border_color_bottom = default(:border_color_bottom) || @style.border_color
-
-      @style.border_canvas.color = color
+      @style.border_thickness_left   = safe_style_fetch(:border_thickness_left)   || @style.border_thickness
+      @style.border_thickness_right  = safe_style_fetch(:border_thickness_right)  || @style.border_thickness
+      @style.border_thickness_top    = safe_style_fetch(:border_thickness_top)    || @style.border_thickness
+      @style.border_thickness_bottom = safe_style_fetch(:border_thickness_bottom) || @style.border_thickness
    end

-    def set_padding(padding)
-      @style.padding = padding
+    def set_border_color
+      @style.border_color = safe_style_fetch(:border_color)

-      @style.padding_left   = default(:padding_left)   || @style.padding
-      @style.padding_right  = default(:padding_right)  || @style.padding
-      @style.padding_top    = default(:padding_top)    || @style.padding
-      @style.padding_bottom = default(:padding_bottom) || @style.padding
+      @style.border_color_left   = safe_style_fetch(:border_color_left)   || @style.border_color
+      @style.border_color_right  = safe_style_fetch(:border_color_right)  || @style.border_color
+      @style.border_color_top    = safe_style_fetch(:border_color_top)    || @style.border_color
+      @style.border_color_bottom = safe_style_fetch(:border_color_bottom) || @style.border_color
+
+      @style.border_canvas.color = [
+        @style.border_color_top,
+        @style.border_color_right,
+        @style.border_color_bottom,
+        @style.border_color_left
+      ]
    end

-    def set_margin(margin)
-      @style.margin = margin
+    def set_padding
+      @style.padding = safe_style_fetch(:padding)

-      @style.margin_left   = default(:margin_left)   || @style.margin
-      @style.margin_right  = default(:margin_right)  || @style.margin
-      @style.margin_top    = default(:margin_top)    || @style.margin
-      @style.margin_bottom = default(:margin_bottom) || @style.margin
+      @style.padding_left   = safe_style_fetch(:padding_left)   || @style.padding
+      @style.padding_right  = safe_style_fetch(:padding_right)  || @style.padding
+      @style.padding_top    = safe_style_fetch(:padding_top)    || @style.padding
+      @style.padding_bottom = safe_style_fetch(:padding_bottom) || @style.padding
+    end
+
+    def set_margin
+      @style.margin = safe_style_fetch(:margin)
+
+      @style.margin_left   = safe_style_fetch(:margin_left)   || @style.margin
+      @style.margin_right  = safe_style_fetch(:margin_right)  || @style.margin
+      @style.margin_top    = safe_style_fetch(:margin_top)    || @style.margin
+      @style.margin_bottom = safe_style_fetch(:margin_bottom) || @style.margin
+    end
+
+    def update_styles(event = :default)
+      old_width = width
+      old_height = height
+
+      _style = @style.send(event)
+      @style_event = event
+
+      if @text.is_a?(CyberarmEngine::Text)
+        @text.color = _style&.dig(:color) || @style.default[:color]
+        @text.swap_font(_style&.dig(:text_size) || @style.default[:text_size], _style&.dig(:font) || @style.default[:font])
+      end
+
+      return if self.is_a?(ToolTip)
+
+      if old_width != width || old_height != height
+        (root&.gui_state || @gui_state).request_recalculate
+      else
+        stylize
+      end
    end

    def default_events
@@ -116,11 +170,74 @@ module CyberarmEngine
      event(:hover)
      event(:leave)

+      event(:focus)
      event(:blur)

      event(:changed)
    end

+    def enter(_sender)
+      @focus = false unless window.button_down?(Gosu::MsLeft)
+
+      if !@enabled
+        update_styles(:disabled)
+      elsif @focus
+        update_styles(:active)
+      else
+        update_styles(:hover)
+      end
+
+      :handled
+    end
+
+    def left_mouse_button(_sender, _x, _y)
+      @focus = true
+
+      unless @enabled
+        update_styles(:disabled)
+      else
+        update_styles(:active)
+      end
+
+      window.current_state.focus = self
+
+      :handled
+    end
+
+    def released_left_mouse_button(sender, _x, _y)
+      enter(sender)
+
+      :handled
+    end
+
+    def clicked_left_mouse_button(_sender, _x, _y)
+      @block&.call(self) if @enabled && !self.is_a?(Container)
+
+      :handled
+    end
+
+    def leave(_sender)
+      if @enabled
+        update_styles
+      else
+        update_styles(:disabled)
+      end
+
+      :handled
+    end
+
+    def blur(_sender)
+      @focus = false
+
+      if @enabled
+        update_styles
+      else
+        update_styles(:disabled)
+      end
+
+      :handled
+    end
+
    def enabled?
      @enabled
    end
@@ -150,6 +267,7 @@ module CyberarmEngine
      return unless visible?

      @style.background_canvas.draw
+      @style.background_nine_slice_canvas.draw
      @style.border_canvas.draw

      Gosu.clip_to(@x, @y, width, height) do
@@ -157,6 +275,31 @@ module CyberarmEngine
      end
    end

+    def debug_draw
+      return if defined?(GUI_DEBUG_ONLY_ELEMENT) && self.class == GUI_DEBUG_ONLY_ELEMENT
+
+      Gosu.draw_line(
+        x, y, @debug_color,
+        x + outer_width, y, @debug_color,
+        Float::INFINITY
+      )
+      Gosu.draw_line(
+        x + outer_width, y, @debug_color,
+        x + outer_width, y + outer_height, @debug_color,
+        Float::INFINITY
+      )
+      Gosu.draw_line(
+        x + outer_width, y + outer_height, @debug_color,
+        x, y + outer_height, @debug_color,
+        Float::INFINITY
+      )
+      Gosu.draw_line(
+        x, outer_height, @debug_color,
+        x, y, @debug_color,
+        Float::INFINITY
+      )
+    end
+
    def update
    end

@@ -226,20 +369,34 @@ module CyberarmEngine
      (@style.border_thickness_top + @style.padding_top) + (@style.padding_bottom + @style.border_thickness_bottom)
    end

+    def scroll_width
+      @children.sum(&:width) + noncontent_width
+    end
+
+    def scroll_height
+      @children.sum(&:height) + noncontent_height
+    end
+
+    def max_scroll_width
+      scroll_width - width
+    end
+
+    def max_scroll_height
+      scroll_height - height
+    end
+
    def dimensional_size(size, dimension)
      raise "dimension must be either :width or :height" unless %i[width height].include?(dimension)

-      if size && size.is_a?(Numeric)
-        if size.between?(0.0, 1.0)
-          ((@parent.send(:"content_#{dimension}") - send(:"noncontent_#{dimension}")) * size).round
-        else
-          size
-        end
+      if size.is_a?(Numeric) && size.between?(0.0, 1.0)
+        (@parent.send(:"content_#{dimension}") * size).round - send(:"noncontent_#{dimension}").round
+      else
+        size
      end
    end

    def background=(_background)
-      @style.background_canvas.background = (_background)
+      @style.background_canvas.background = _background
      update_background
    end

@@ -251,10 +408,34 @@ module CyberarmEngine
      @style.background_canvas.height = height

      @style.background_canvas.update
-
+      update_background_nine_slice
      @style.border_canvas.update
    end

+    def background_nine_slice=(_image_path)
+      @style.background_nine_slice_canvas.image = _image_path
+      update_background_nine_slice
+    end
+
+    def update_background_nine_slice
+      @style.background_nine_slice_canvas.x = @x
+      @style.background_nine_slice_canvas.y = @y
+      @style.background_nine_slice_canvas.z = @z
+      @style.background_nine_slice_canvas.width = width
+      @style.background_nine_slice_canvas.height = height
+
+      @style.background_nine_slice_canvas.mode = @style.background_nine_slice_mode
+
+      @style.background_nine_slice_canvas.color = @style.background_nine_slice_color
+
+      @style.background_nine_slice_canvas.left   = @style.background_nine_slice_left
+      @style.background_nine_slice_canvas.top    = @style.background_nine_slice_top
+      @style.background_nine_slice_canvas.right  = @style.background_nine_slice_right
+      @style.background_nine_slice_canvas.bottom = @style.background_nine_slice_bottom
+
+      @style.background_nine_slice_canvas.image = @style.background_nine_slice
+    end
+
    def root
      return self if is_root?

@@ -262,11 +443,9 @@ module CyberarmEngine
        @root = parent

        loop do
-          if @root.parent.nil?
-            break
-          else
-            @root = @root.parent
-          end
+          break unless @root&.parent
+
+          @root = @root.parent
        end
      end

@@ -277,6 +456,12 @@ module CyberarmEngine
      @gui_state != nil
    end

+    def focus(_)
+      warn "#{self.class}#focus was not overridden!"
+
+      :handled
+    end
+
    def recalculate
      raise "#{self.class}#recalculate was not overridden!"
    end
@@ -295,5 +480,9 @@ module CyberarmEngine
    def to_s
      "#{self.class} x=#{x} y=#{y} width=#{width} height=#{height} value=#{value.is_a?(String) ? "\"#{value}\"" : value}"
    end
+
+    def inspect
+      to_s
+    end
  end
 end
--- a/lib/cyberarm_engine/ui/elements/button.rb
+++ b/lib/cyberarm_engine/ui/elements/button.rb
@@ -34,69 +34,6 @@ module CyberarmEngine
        @text.draw
      end

-      def enter(_sender)
-        @focus = false unless window.button_down?(Gosu::MsLeft)
-
-        if !@enabled
-          @style.background_canvas.background = @style.disabled[:background]
-          @text.color = @style.disabled[:color]
-        elsif @focus
-          @style.background_canvas.background = @style.active[:background]
-          @text.color = @style.active[:color]
-        else
-          @style.background_canvas.background = @style.hover[:background]
-          @text.color = @style.hover[:color]
-        end
-
-        :handled
-      end
-
-      def left_mouse_button(_sender, _x, _y)
-        @focus = true
-
-        unless @enabled
-          @style.background_canvas.background = @style.disabled[:background]
-          @text.color = @style.disabled[:color]
-        else
-          @style.background_canvas.background = @style.active[:background]
-          @text.color = @style.active[:color]
-        end
-
-        window.current_state.focus = self
-
-        :handled
-      end
-
-      def released_left_mouse_button(sender, _x, _y)
-        enter(sender)
-
-        :handled
-      end
-
-      def clicked_left_mouse_button(_sender, _x, _y)
-        @block.call(self) if @enabled && @block
-
-        :handled
-      end
-
-      def leave(_sender)
-        unless @enabled
-          @style.background_canvas.background = @style.disabled[:background]
-          @text.color = @style.disabled[:color]
-        else
-          @style.background_canvas.background = @style.background
-          @text.color = @style.color
-        end
-
-        :handled
-      end
-
-      def blur(_sender)
-        @focus = false
-
-        :handled
-      end
-
      def recalculate
        unless @enabled
          @style.background_canvas.background = @style.disabled[:background]
--- a/lib/cyberarm_engine/ui/elements/check_box.rb
+++ b/lib/cyberarm_engine/ui/elements/check_box.rb
@@ -5,8 +5,11 @@ module CyberarmEngine
        super(options, block)
        options[:toggled] = options[:checked]

+        options[:parent] = self
        @toggle_button = ToggleButton.new(options)
-        @label         = TextBlock.new(text, options)
+
+        options[:parent] = self
+        @label = TextBlock.new(text, options)

        @label.subscribe(:holding_left_mouse_button) do |sender, x, y|
          @toggle_button.left_mouse_button(sender, x, y)
--- a/lib/cyberarm_engine/ui/elements/container.rb
+++ b/lib/cyberarm_engine/ui/elements/container.rb
@@ -4,19 +4,20 @@ module CyberarmEngine
      include Common

      attr_accessor :stroke_color, :fill_color
-      attr_reader :children, :gui_state, :scroll_x, :scroll_y
+      attr_reader :children, :gui_state, :scroll_position

      def initialize(options = {}, block = nil)
        @gui_state = options.delete(:gui_state)
        super

-        @scroll_x = 0
-        @scroll_y = 0
-        @scroll_speed = 10
+        @scroll_position = Vector.new(0, 0)
+        @scroll_speed = 40

        @text_color = options[:color]

        @children = []
+
+        event(:window_size_changed)
      end

      def build
@@ -44,34 +45,28 @@ module CyberarmEngine
        root.gui_state.request_recalculate
      end

+      def apend(&block)
+        old_container = $__current_container__
+
+        $__current_container__ = self
+        block.call(self) if block
+
+        $__current_container__ = old_container
+
+        root.gui_state.request_recalculate
+      end
+
      def render
        Gosu.clip_to(@x, @y, width, height) do
          @children.each(&:draw)
        end
+      end

-        if false # DEBUG
-          Gosu.flush
+      def debug_draw
+        super

-          Gosu.draw_line(
-            x, y, Gosu::Color::RED,
-            x + outer_width, y, Gosu::Color::RED,
-            Float::INFINITY
-          )
-          Gosu.draw_line(
-            x + outer_width, y, Gosu::Color::RED,
-            x + outer_width, y + outer_height, Gosu::Color::RED,
-            Float::INFINITY
-          )
-          Gosu.draw_line(
-            x + outer_width, y + outer_height, Gosu::Color::RED,
-            x, y + outer_height, Gosu::Color::RED,
-            Float::INFINITY
-          )
-          Gosu.draw_line(
-            x, outer_height, Gosu::Color::RED,
-            x, y, Gosu::Color::RED,
-            Float::INFINITY
-          )
+        @children.each do |child|
+          child.debug_draw
        end
      end

@@ -80,6 +75,8 @@ module CyberarmEngine
      end

      def hit_element?(x, y)
+        return unless hit?(x, y)
+
        @children.reverse_each do |child|
          next unless child.visible?

@@ -98,6 +95,8 @@ module CyberarmEngine

      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)
@@ -189,15 +188,46 @@ module CyberarmEngine
        @current_position.y += element.outer_height
      end

-      # def mouse_wheel_up(sender, x, y)
-      #   @children.each {|c| c.y -= @scroll_speed}
-      #   @children.each {|c| c.recalculate}
-      # end
+      def mouse_wheel_up(sender, x, y)
+        return unless @style.scroll

-      # def mouse_wheel_down(sender, x, y)
-      #   @children.each {|c| c.y += @scroll_speed}
-      #   @children.each {|c| c.recalculate}
-      # end
+        if @scroll_position.y < 0
+          @scroll_position.y += @scroll_speed
+          @scroll_position.y = 0 if @scroll_position.y > 0
+          recalculate
+
+          return :handled
+        end
+      end
+
+      def mouse_wheel_down(sender, x, y)
+        return unless @style.scroll
+
+        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
+          recalculate
+
+          return :handled
+        end
+      end
+
+      def scroll_top
+        @scroll_position.y
+      end
+
+      def scroll_top=(n)
+        n = 0 if n <= 0
+        @scroll_position.y = -n
+
+        if max_scroll_height.positive?
+          @scroll_position.y = -max_scroll_height if @scroll_position.y.abs > max_scroll_height
+        else
+          @scroll_position.y = 0
+        end
+      end

      def value
        @children.map { |c| c.class }.join(", ")
--- a/lib/cyberarm_engine/ui/elements/edit_line.rb
+++ b/lib/cyberarm_engine/ui/elements/edit_line.rb
@@ -59,6 +59,8 @@ module CyberarmEngine
      end

      def update
+        @style_event = :active if @focus
+
        @text.text = if @type == :password
                       default(:password_character) * @text_input.text.length
                     else
@@ -67,6 +69,8 @@ module CyberarmEngine

        if @last_text_value != value
          @last_text_value = value
+          @show_caret = true
+          @caret_last_interval = Gosu.milliseconds

          publish(:changed, value)
        end
@@ -192,28 +196,27 @@ module CyberarmEngine
        :handled
      end

-      def enter(_sender)
-        if @focus
-          @style.background_canvas.background = default(:active, :background)
-          @text.color = default(:active, :color)
-        else
-          @style.background_canvas.background = default(:hover, :background)
-          @text.color = default(:hover, :color)
-        end
+      def focus(sender)
+        super
+
+        window.text_input = @text_input
+        @text_input.caret_pos = @text_input.selection_start = @text_input.text.length

        :handled
      end

-      def leave(sender)
-        super unless @focus
+      def enter(sender)
+        _has_focus = @focus
+
+        super
+
+        @focus = _has_focus

        :handled
      end

      def blur(_sender)
-        @focus = false
-        @style.background_canvas.background = default(:background)
-        @text.color = default(:color)
+        super
        window.text_input = nil

        :handled
@@ -251,6 +254,10 @@ module CyberarmEngine
      def value
        @text_input.text
      end
+
+      def value=(string)
+        @text_input.text = string
+      end
    end
  end
 end
--- a/lib/cyberarm_engine/ui/elements/label.rb
+++ b/lib/cyberarm_engine/ui/elements/label.rb
@@ -1,156 +0,0 @@
-module CyberarmEngine
-  class Element
-    class TextBlock < Element
-      def initialize(text, options = {}, block = nil)
-        super(options, block)
-
-        @text = Text.new(
-          text, font: @options[:font], z: @z, color: @options[:color],
-                size: @options[:text_size], shadow: @options[:text_shadow],
-                shadow_size: @options[:text_shadow_size],
-                shadow_color: @options[:text_shadow_color]
-        )
-
-        @raw_text = text
-      end
-
-      def render
-        @text.draw
-      end
-
-      def clicked_left_mouse_button(_sender, _x, _y)
-        @block&.call(self) if @enabled
-
-        # return :handled
-      end
-
-      def recalculate
-        @width  = 0
-        @height = 0
-
-        _width  = dimensional_size(@style.width,  :width)
-        _height = dimensional_size(@style.height, :height)
-
-        handle_text_wrapping(_width)
-
-        @width  = _width  || @text.width.round
-        @height = _height || @text.height.round
-
-        @text.y = @style.border_thickness_top + @style.padding_top + @y
-        @text.z = @z + 3
-
-        if (text_alignment = @options[:text_align])
-          case text_alignment
-          when :left
-            @text.x = @style.border_thickness_left + @style.padding_left + @x
-          when :center
-            @text.x = if @text.width <= outer_width
-                        @x + outer_width / 2 - @text.width / 2
-                      else # Act as left aligned
-                        @style.border_thickness_left + @style.padding_left + @x
-                      end
-          when :right
-            @text.x = @x + outer_width - (@text.width + @style.border_thickness_right + @style.padding_right)
-          end
-        end
-
-        update_background
-      end
-
-      def handle_text_wrapping(max_width)
-        max_width ||= @parent&.width
-        max_width ||= @x - (window.width + noncontent_width)
-        wrap_behavior = style.text_wrap
-        copy = @raw_text.to_s.dup
-
-        if max_width >= line_width(copy[0]) && line_width(copy) > max_width && wrap_behavior != :none
-          breaks = []
-          line_start = 0
-          line_end   = copy.length
-
-          while line_start != copy.length
-            if line_width(copy[line_start...line_end]) > max_width
-              line_end = ((line_end - line_start) / 2.0)
-            elsif line_end < copy.length && line_width(copy[line_start...line_end + 1]) < max_width
-              # To small, grow!
-              # TODO: find a more efficient way
-              line_end += 1
-
-            else # FOUND IT!
-              entering_line_end = line_end.floor
-              max_reach = line_end.floor - line_start < 63 ? line_end.floor - line_start : 63
-              reach = 0
-
-              if wrap_behavior == :word_wrap
-                max_reach.times do |i|
-                  reach = i
-                  break if copy[line_end.floor - i].to_s.match(/[[:punct:]]| /)
-                end
-
-                puts "Max width: #{max_width}/#{line_width(@raw_text)} Reach: {#{reach}/#{max_reach}} Line Start: #{line_start}/#{line_end.floor} (#{copy.length}|#{@raw_text.length}) [#{entering_line_end}] '#{copy}' {#{copy[line_start...line_end]}}"
-                line_end = line_end.floor - reach + 1 if reach != max_reach # Add +1 to walk in front of punctuation
-              end
-
-              breaks << line_end.floor
-              line_start = line_end.floor
-              line_end = copy.length
-
-              break if entering_line_end == copy.length || reach == max_reach
-            end
-          end
-
-          breaks.each_with_index do |pos, index|
-            copy.insert(pos + index, "\n") if pos + index >= 0 && pos + index < copy.length
-          end
-        end
-
-        @text.text = copy
-      end
-
-      def line_width(text)
-        (@x + @text.textobject.markup_width(text) + noncontent_width)
-      end
-
-      def value
-        @raw_text
-      end
-
-      def value=(value)
-        @raw_text = value.to_s.chomp
-
-        old_width = width
-        old_height = height
-        recalculate
-
-        root.gui_state.request_recalculate if old_width != width || old_height != height
-
-        publish(:changed, self.value)
-      end
-    end
-
-    class Banner < TextBlock
-    end
-
-    class Title < TextBlock
-    end
-
-    class Subtitle < TextBlock
-    end
-
-    class Tagline < TextBlock
-    end
-
-    class Caption < TextBlock
-    end
-
-    class Para < TextBlock
-    end
-
-    class Inscription < TextBlock
-    end
-
-    # TODO: Remove in version 0.16.0+
-    class Label < TextBlock
-    end
-  end
-end
--- a/lib/cyberarm_engine/ui/elements/list_box.rb
+++ b/lib/cyberarm_engine/ui/elements/list_box.rb
@@ -46,6 +46,12 @@ module CyberarmEngine
        :handled
      end

+      def clicked_left_mouse_button(_sender, _x, _y)
+        @block&.call(self.value) if @enabled
+
+        :handled
+      end
+
      def show_menu
        @menu.clear

@@ -61,7 +67,7 @@ module CyberarmEngine
            },
            proc do
              self.choose = item
-              @block&.call(item)
+              @block&.call(self.value)
            end
          )

--- a/lib/cyberarm_engine/ui/elements/text_block.rb
+++ b/lib/cyberarm_engine/ui/elements/text_block.rb
@@ -8,7 +8,10 @@ module CyberarmEngine
          text, font: @options[:font], z: @z, color: @options[:color],
                size: @options[:text_size], shadow: @options[:text_shadow],
                shadow_size: @options[:text_shadow_size],
-                shadow_color: @options[:text_shadow_color]
+                shadow_color: @options[:text_shadow_color],
+                border: @options[:text_border],
+                border_size: @options[:text_border_size],
+                border_color: @options[:text_border_color]
        )

        @raw_text = text
@@ -18,13 +21,13 @@ module CyberarmEngine
        @text.draw
      end

-      def clicked_left_mouse_button(_sender, _x, _y)
-        @block&.call(self) if @enabled
-
-        # return :handled
-      end
-
      def recalculate
+        unless @enabled
+          @text.color = @style.disabled[:color]
+        else
+          @text.color = @style.color
+        end
+
        @width  = 0
        @height = 0

@@ -152,5 +155,8 @@ module CyberarmEngine

    class ToolTip < TextBlock
    end
+
+    class Link < TextBlock
+    end
  end
 end
--- a/lib/cyberarm_engine/ui/event.rb
+++ b/lib/cyberarm_engine/ui/event.rb
@@ -15,12 +15,19 @@ module CyberarmEngine

      return unless enabled?

-      return :handled if respond_to?(event) && (send(event, self, *args) == :handled)
+      was_handled = false
+
+      was_handled = true if respond_to?(event) && (send(event, self, *args) == :handled)

      @event_handler[event].reverse_each do |handler|
-        return :handled if handler.call(self, *args) == :handled
+        if handler.call(self, *args) == :handled
+          was_handled = true
+          break
+        end
      end

+      return :handled if was_handled
+
      parent.publish(event, *args) if parent
      nil
    end
--- a/lib/cyberarm_engine/ui/gui_state.rb
+++ b/lib/cyberarm_engine/ui/gui_state.rb
@@ -26,12 +26,15 @@ module CyberarmEngine
      @dragging_element = nil
      @pending_recalculate_request = false

-      @tip = Element::ToolTip.new("", parent: @root_container, z: Float::INFINITY)
      @menu = nil
      @min_drag_distance = 0
      @mouse_pos = Vector.new
    end

+    def post_setup
+      @tip = Element::ToolTip.new("", parent: @root_container, z: Float::INFINITY, theme: current_theme)
+    end
+
    # throws :blur event to focused element and sets GuiState focused element
    # Does NOT throw :focus event at element or set element as focused
    def focus=(element)
@@ -55,6 +58,12 @@ module CyberarmEngine
        Gosu.flush
        @tip.draw
      end
+
+      if defined?(GUI_DEBUG)
+        Gosu.flush
+
+        @root_container.debug_draw
+      end
    end

    def update
@@ -66,6 +75,13 @@ module CyberarmEngine
        @pending_recalculate_request = false
      end

+      if @pending_focus_request
+        @pending_focus_request = false
+
+        self.focus = @pending_focus_element
+        @pending_focus_element.publish(:focus)
+      end
+
      @menu&.update
      super

@@ -87,10 +103,10 @@ module CyberarmEngine
      if Vector.new(window.mouse_x, window.mouse_y) == @last_mouse_pos
        if @mouse_over && (Gosu.milliseconds - @mouse_moved_at) > tool_tip_delay
          @tip.value = @mouse_over.tip if @mouse_over
-          @tip.x = window.mouse_x - @tip.width / 2
+          @tip.x = window.mouse_x
          @tip.x = 0 if @tip.x < 0
          @tip.x = window.width - @tip.width if @tip.x + @tip.width > window.width
-          @tip.y = window.mouse_y - @tip.height
+          @tip.y = window.mouse_y - (@tip.height + 5)
          @tip.y = 0 if @tip.y < 0
          @tip.y = window.height - @tip.height if @tip.y + @tip.height > window.height
          @tip.update
@@ -105,7 +121,10 @@ module CyberarmEngine
      @last_mouse_pos = Vector.new(window.mouse_x, window.mouse_y)
      @mouse_pos = @last_mouse_pos.clone

-      request_recalculate if @active_width != window.width || @active_height != window.height
+      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
@@ -212,6 +231,11 @@ module CyberarmEngine
      @pending_recalculate_request = true
    end

+    def request_focus(element)
+      @pending_focus_request = true
+      @pending_focus_element = element
+    end
+
    def show_menu(list_box)
      @menu = list_box
    end
@@ -219,5 +243,14 @@ module CyberarmEngine
    def hide_menu
      @menu = nil
    end
+
+    def to_s
+      # "#{self.class} children=#{@children.map { |c| c.to_s }}"
+      @root_container.to_s
+    end
+
+    def inspect
+      to_s
+    end
  end
 end
--- a/lib/cyberarm_engine/ui/style.rb
+++ b/lib/cyberarm_engine/ui/style.rb
@@ -17,8 +17,20 @@ end

 module CyberarmEngine
  class Style
+    attr_reader :hash
+
    def initialize(hash = {})
-      @hash = Marshal.load(Marshal.dump(hash))
+      h = Marshal.load(Marshal.dump(hash))
+
+      h[:default] = {}
+
+      h.each do |key, value|
+        next if value.is_a?(Hash)
+
+        h[:default][key] = value
+      end
+
+      @hash = h
    end

    def method_missing(method, *args)
@@ -27,9 +39,8 @@ module CyberarmEngine

        @hash[method.to_s.sub("=", "").to_sym] = args.first

-      elsif args.size == 0
+      elsif args.empty?
        @hash[method]
-
      else
        raise ArgumentError, "Did not expect arguments"
      end
--- a/lib/cyberarm_engine/ui/theme.rb
+++ b/lib/cyberarm_engine/ui/theme.rb
@@ -64,6 +64,10 @@ module CyberarmEngine
        border_radius: 0
      },

+      Container: { # < Element (Base class for Stack and Flow)
+        debug_color: Gosu::Color::YELLOW
+      },
+
      Button: { # < Label
        margin: 1,
        padding: 4,
@@ -111,10 +115,14 @@ module CyberarmEngine
        text_size: 28,
        text_wrap: :word_wrap, # :word_wrap, :break_word, :none
        text_shadow: false,
+        text_border: false,
        text_align: :left,
        font: "Arial",
        margin: 0,
-        padding: 2
+        padding: 2,
+        disabled: {
+          color: Gosu::Color.rgb(175, 175, 175),
+        }
      },

      Banner: { # < TextBlock
@@ -155,11 +163,28 @@ module CyberarmEngine
        border_color: 0xffaaaaaa,
        background: 0xff404040
      },
+      Link: { # < TextBlock
+        color: Gosu::Color::BLUE,
+        border_thickness: 1,
+        border_bottom_color: Gosu::Color::BLUE,
+        hover: {
+          color: 0xff_ff00ff,
+          border_bottom_color: 0xff_ff00ff
+        },
+        active: {
+          color: 0xff_ff0000,
+          border_bottom_color: 0xff_ff0000
+        }
+      },

      ToggleButton: { # < Button
        checkmark: "√"
      },

+      CheckBox: { # < Flow
+        text_wrap: :none
+      },
+
      Progress: { # < Element
        width: 250,
        height: 36,
--- a/lib/cyberarm_engine/version.rb
+++ b/lib/cyberarm_engine/version.rb
@@ -1,4 +1,4 @@
 module CyberarmEngine
  NAME    = "InDev".freeze
-  VERSION = "0.16.0".freeze
+  VERSION = "0.19.1".freeze
 end
--- a/lib/cyberarm_engine/window.rb
+++ b/lib/cyberarm_engine/window.rb
@@ -77,10 +77,12 @@ module CyberarmEngine
      if klass.instance_of?(klass.class) && defined?(klass.options)
        @states << klass
        klass.setup if options[:setup]
+        klass.post_setup if options[:setup]
      else
        @states << klass.new(options) if child_of?(klass, GameState)
        @states << klass.new if child_of?(klass, Element::Container)
        current_state.setup if current_state.instance_of?(klass) && options[:setup]
+        current_state.post_setup if current_state.instance_of?(klass) && options[:setup]
      end
    end

@@ -93,7 +95,7 @@ module CyberarmEngine
    end

    def previous_state
-      if @states.size > 1 && state = @states[@states.size - 2]
+      if @states.size > 1 && (state = @states[@states.size - 2])
        state
      end
    end
@@ -102,6 +104,10 @@ module CyberarmEngine
      @states.pop
    end

+    def shift_state
+      @states.shift
+    end
+
    # Sourced from https://gist.github.com/ippa/662583
    def draw_circle(cx, cy, r, z = 9999, color = Gosu::Color::GREEN, step = 10)
      0.step(360, step) do |a1|
Author	SHA1	Message	Date
Cyberarm	d2bf406d29	Bump version	2021-09-23 14:36:19 -05:00
Cyberarm	f82c101728	Fixed ListBox sometimes returning self in callback instead of self.value	2021-09-23 14:35:46 -05:00
cyberarm	2f727e9bf2	Bump version	2021-09-22 09:23:24 -05:00
Cyberarm	24be9bfb29	Imported Console from I-MIC FPS	2021-06-26 13:12:44 +00:00
Cyberarm	5452d149c3	Possible fix for being able to click a button that isn't visible due to scrolling, by ensuring that the host container is hit before checking children.	2021-06-18 02:57:49 +00:00
cyberarm	cdee6548e3	Added support for 9 sliced backgrounds in UI, fixed events not propagating to subscribers if element threw :handled in its own event handler	2021-06-04 03:00:31 +00:00
Cyberarm	bd54fafc3f	Added Text#text_width method, Text#width now returns value of Text#markup_width	2021-06-03 13:05:11 +00:00
cyberarm	a92d1ad746	Made Text account for shadow and border effects in width/height methods, made TextBlock support disabled state styling	2021-06-03 01:00:13 +00:00
Cyberarm	1b080f9fb9	Use shorthand (&:method) for Element scroll_width/height max_scroll_width, possibly fix dimentional_size returning the wrong size when element has nonzero padding/margin/border_thickness	2021-05-31 01:07:24 +00:00
Cyberarm	8057bca818	Added rendered vertices count to OpenGLRenderer	2021-05-30 14:10:32 +00:00
cyberarm	c1310f3073	Renamed Text's shadow to border and added proper text shadow effect	2021-05-29 00:10:44 +00:00
Cyberarm	850bb610bb	Fixed GUI having a total recalculation whenever a style changed, made tooltip not be centered on mouse, removed duplicate loc from Text	2021-05-28 00:43:40 +00:00
Cyberarm	0b63986b64	Improved 9 slice background	2021-05-06 03:20:49 +00:00
Cyberarm	165fc6f307	Fixed draw_rect helper missing drawing mode argument, set max view distance to a large number	2021-04-25 23:22:58 +00:00
Cyberarm	e3c8e3bcc2	Added a bunch of tweens to the Animator, replaced :ease_in_out tween for Intro state engine logo to :swing_to	2021-04-25 14:58:12 +00:00
Cyberarm	551a55f894	Add fade out to intro scene	2021-04-24 20:13:06 +00:00
cyberarm	01292ead10	Bump version	2021-04-19 19:26:42 +00:00
cyberarm	7ca6e1bc58	Update README	2021-04-19 19:22:43 +00:00
cyberarm	a70f260bc6	Update README	2021-04-19 19:17:10 +00:00
cyberarm	8002708695	Updated Animator to be usable, added logo texture/image, 'finished' Intro state, added Window#shift_state	2021-04-19 19:13:15 +00:00
Cyberarm	676545f3c7	Added wip engine intro state	2021-04-19 14:42:49 +00:00
cyberarm	4b417f9ab7	More changes to how styles are applied, fixed bug where a Container would re-evaluate its build block when clicked, fixed background method in DSL having no effect, fixed edit line losing 'focus' when mouse moved out, misc. other changes and fixes.	2021-03-29 08:51:26 -05:00
cyberarm	a70c106387	Added Link element which is basically a button without a border or background, WIP: Element border, margin, padding, and other styles are now easily changable; work is needed to make style changes survive a recalculation	2021-03-29 08:51:26 -05:00
Cyberarm	f662fabc56	Use GL_SRGB_ALPHA for textures	2021-03-29 08:13:59 -05:00
Cyberarm	abb989f842	Added flags to use ffi-gosu optionally instead of always trying, made tooltip affected by theme (the last set theme in setup will be used to style the tooltip)	2021-03-12 08:33:16 -06:00
cyberarm	1e0d2004b5	More adjustments to scrolling and scroll_top, added debug_draw to elements that draws a box around the element that is atop all rendered things	2021-02-13 22:57:18 -06:00
cyberarm	92dd63dc1d	Probably fixed scrolling for real this time, added scroll_top and scroll_top = n methods	2021-02-13 20:03:10 -06:00
cyberarm	20970e5aa9	Bump version	2021-02-11 09:32:37 -06:00
cyberarm	76eb1a85d5	Added focus event, elements can request focus	2021-02-11 09:31:44 -06:00
cyberarm	e9d75d17bf	Updated gosu version, bumped version	2021-02-10 12:19:47 -06:00
cyberarm	e8bb2cac17	Update bundler in gemspec	2021-02-10 12:18:28 -06:00
Cyberarm	29fbac7140	Added Container#apend method, EditLine caret will now stay visible while typing, EditLine#value= now sets the value of @text_input	2021-02-09 17:41:29 -06:00
Cyberarm	d050f63c2b	Increased scroll speed and added window_size_changed event for containers that is thrown from the root container	2021-01-31 13:33:20 -06:00
Cyberarm	af24fc8690	Added vertical scrolling support for containers (no scrollbar yet)	2021-01-31 09:44:46 -06:00