hokusai-zero 0.1.1

data/ui/src/hokusai/backends/sdl2/keys.rb

@@ -0,0 +1,119 @@
+module Hokusai::Backends
+  class SDLBackend
+    Keys = [
+      [:null, SDL::SDLK_UNKNOWN],
+      # [:left_super, SDL::SDLK_LSUPER],
+      # [:right_super, SDL::SDLK_RSUPER],
+      [:apostrophe, SDL::SDLK_QUOTE],
+      [:comma, SDL::SDLK_COMMA],
+      [:minus, SDL::SDLK_MINUS],
+      [:period, SDL::SDLK_PERIOD],
+      [:slash, SDL::SDLK_SLASH],
+      [:zero, SDL::SDLK_0],
+      [:one, SDL::SDLK_1],
+      [:two, SDL::SDLK_2],
+      [:three, SDL::SDLK_3],
+      [:four, SDL::SDLK_4],
+      [:five, SDL::SDLK_5],
+      [:six, SDL::SDLK_6],
+      [:seven, SDL::SDLK_7],
+      [:eight, SDL::SDLK_8],
+      [:nine, SDL::SDLK_9],
+      [:semicolon, SDL::SDLK_SEMICOLON],
+      [:equal, SDL::SDLK_EQUALS],
+      [:a, SDL::SDLK_a],
+      [:b, SDL::SDLK_b],
+      [:c, SDL::SDLK_c],
+      [:d, SDL::SDLK_d],
+      [:e, SDL::SDLK_e],
+      [:f, SDL::SDLK_f],
+      [:g, SDL::SDLK_g],
+      [:h, SDL::SDLK_h],
+      [:i, SDL::SDLK_i],
+      [:j, SDL::SDLK_j],
+      [:k, SDL::SDLK_k],
+      [:l, SDL::SDLK_l],
+      [:m, SDL::SDLK_m],
+      [:n, SDL::SDLK_n],
+      [:o, SDL::SDLK_o],
+      [:p, SDL::SDLK_p],
+      [:q, SDL::SDLK_q],
+      [:r, SDL::SDLK_r],
+      [:s, SDL::SDLK_s],
+      [:t, SDL::SDLK_t],
+      [:u, SDL::SDLK_u],
+      [:v, SDL::SDLK_v],
+      [:w, SDL::SDLK_w],
+      [:x, SDL::SDLK_x],
+      [:y, SDL::SDLK_y],
+      [:z, SDL::SDLK_z],
+      [:left_bracket, SDL::SDLK_LEFTBRACKET],
+      [:backslash, SDL::SDLK_BACKSLASH],
+      [:right_bracket, SDL::SDLK_RIGHTBRACKET],
+      [:grave, SDL::SDLK_BACKQUOTE],
+      [:space, SDL::SDLK_SPACE],
+      [:escape, SDL::SDLK_ESCAPE],
+      [:enter, SDL::SDLK_RETURN],
+      [:tab, SDL::SDLK_TAB],
+      [:backspace, SDL::SDLK_BACKSPACE],
+      [:insert, SDL::SDLK_INSERT],
+      [:delete, SDL::SDLK_DELETE],
+      [:right, SDL::SDLK_RIGHT],
+      [:left, SDL::SDLK_LEFT],
+      [:down, SDL::SDLK_DOWN],
+      [:up, SDL::SDLK_UP],
+      [:page_up, SDL::SDLK_PAGEUP],
+      [:page_down, SDL::SDLK_PAGEDOWN],
+      [:home, SDL::SDLK_HOME],
+      [:end, SDL::SDLK_END],
+      [:caps_lock, SDL::SDLK_CAPSLOCK],
+      [:scroll_lock, SDL::SDLK_SCROLLLOCK],
+      [:num_lock, SDL::SDLK_NUMLOCKCLEAR],
+      [:print_screen, SDL::SDLK_PRINTSCREEN],
+      [:pause, SDL::SDLK_PAUSE],
+      [:f1, SDL::SDLK_F1],
+      [:f2, SDL::SDLK_F2],
+      [:f3, SDL::SDLK_F3],
+      [:f4, SDL::SDLK_F4],
+      [:f5, SDL::SDLK_F5],
+      [:f6, SDL::SDLK_F6],
+      [:f7, SDL::SDLK_F7],
+      [:f8, SDL::SDLK_F8],
+      [:f9, SDL::SDLK_F9],
+      [:f10, SDL::SDLK_F10],
+      [:f11, SDL::SDLK_F11],
+      [:f12, SDL::SDLK_F12],
+      [:kb_menu, SDL::SDLK_MENU],
+      [:kp_0, SDL::SDLK_KP_0],
+      [:kp_1, SDL::SDLK_KP_1],
+      [:kp_2, SDL::SDLK_KP_2],
+      [:kp_3, SDL::SDLK_KP_3],
+      [:kp_4, SDL::SDLK_KP_4],
+      [:kp_5, SDL::SDLK_KP_5],
+      [:kp_6, SDL::SDLK_KP_6],
+      [:kp_7, SDL::SDLK_KP_7],
+      [:kp_8, SDL::SDLK_KP_8],
+      [:kp_9, SDL::SDLK_KP_9],
+      [:kp_decimal, SDL::SDLK_KP_DECIMAL],
+      [:kp_divide, SDL::SDLK_KP_DIVIDE],
+      [:kp_multiply, SDL::SDLK_KP_MULTIPLY],
+      [:kp_subtract, SDL::SDLK_KP_MINUS],
+      [:kp_add, SDL::SDLK_KP_PLUS],
+      [:kp_enter, SDL::SDLK_KP_ENTER],
+      [:kp_equal, SDL::SDLK_KP_EQUALS],
+      [:back, SDL::SDLK_AC_BACK],
+      [:menu, SDL::SDLK_MENU],
+      [:volume_up, SDL::SDLK_VOLUMEUP],
+      [:volume_down, SDL::SDLK_VOLUMEDOWN]].to_h {|(k,v)| [v, k]}
+
+    Modifiers = [
+      [SDL::KMOD_LSHIFT, :left_shift],
+      [SDL::KMOD_RSHIFT, :right_shift],
+      [SDL::KMOD_RALT, :right_alt],
+      [SDL::KMOD_RCTRL, :right_control],
+      [SDL::KMOD_LALT, :left_alt],
+      [SDL::KMOD_LCTRL, :left_control],
+    ]
+
+  end
+end

data/ui/src/hokusai/backends/sdl2.rb

@@ -0,0 +1,529 @@
+require "sdl2"
+require_relative "./sdl2/color"
+require_relative "./sdl2/config"
+require_relative './sdl2/font'
+require_relative './sdl2/keys'
+
+module Hokusai::Backends
+  class SDLBackend
+    attr_reader :config
+    attr_accessor :render_width, :render_height
+
+    SDL_PATH = ENV["SDL_PATH"] || "#{__dir__}/../../../../vendor/lib"
+
+    def self.run(app)
+      backend = new do |config|
+        yield(config)
+      end
+
+      block = app.mount
+      backend.run(block)
+    end
+
+    def self.cursors
+      @cursors ||= {
+       default: SDL.CreateSystemCursor(SDL::SYSTEM_CURSOR_ARROW),
+       arrow: SDL.CreateSystemCursor(SDL::SYSTEM_CURSOR_ARROW),
+       ibeam: SDL.CreateSystemCursor(SDL::SYSTEM_CURSOR_IBEAM),
+       crosshair: SDL.CreateSystemCursor(SDL::SYSTEM_CURSOR_CROSSHAIR),
+       pointer: SDL.CreateSystemCursor(SDL::SYSTEM_CURSOR_HAND)
+     }
+    end
+
+    def self.stopped
+      @stopped ||= false
+    end
+
+    def self.stopped=(val)
+      @stopped = val
+    end
+
+    def self.images
+      @images ||= {}
+    end
+
+    def self.fonts
+      @fonts ||= {}
+    end
+
+    def self.font_textures
+      @font_textures ||= {}
+    end
+
+    def initialize
+      @config = Config.new
+
+      yield @config
+    end
+
+    def run(block)
+      resize = false
+      self.render_width = config.width
+      self.render_height = config.height
+
+      case RbConfig::CONFIG['host_os']
+      when /darwin/
+        SDL.load_lib(
+          "#{SDL_PATH}/libSDL2.dylib",
+          true,
+          gfx_libpath: "#{SDL_PATH}/libSDL2_gfx.dylib",
+          ttf_libpath: "#{SDL_PATH}/libSDL2_ttf.dylib",
+          image_libpath: "#{SDL_PATH}/libSDL2_image.dylib"
+        )
+      when /mswin|msys|mingw/
+        SDL.load_lib("#{SDL_PATH}/SDL2.dll", true, gfx_libpath: "#{SDL_PATH}/libSDL2_gfx.dll" )
+      when /linux/
+        SDL.load_lib(
+          "#{SDL_PATH}/libSDL2.so", true,
+          gfx_libpath: "#{SDL_PATH}/libSDL2_gfx.so",
+          ttf_libpath: "#{SDL_PATH}/libSDL2_ttf.so",
+          image_libpath: "#{SDL_PATH}/libSDL2_image.so"
+        )
+      end
+      SDL.Init(config.init_flags)
+      SDL.TTF_Init
+
+      window = SDL.CreateWindow(config.title, 30, 30, render_width, render_height, config.window_config_flags)
+      SDL.SetWindowPosition(window, SDL::WINDOWPOS_CENTERED_MASK, SDL::WINDOWPOS_CENTERED_MASK)
+      renderer = SDL.CreateRenderer(window, -1, SDL::RENDERER_TARGETTEXTURE | SDL::RENDERER_ACCELERATED)
+
+      Hokusai.fonts.register "default", SDLBackend::Font.from("#{__dir__}/sdl2/Monaco.ttf", 121)
+      Hokusai.fonts.activate "default"
+      config.after_load&.call
+
+      register_command_handlers(renderer, window)
+      # MemoryProfiler.start if ENV["PROFILE"]
+
+      ptr = FFI::MemoryPointer.new :pointer
+      LibHokusai.hoku_input_init(ptr)
+      raw = LibHokusai::HmlInput.new(ptr.get_pointer(0))
+      input = Hokusai::Input.new(raw)
+      canvas = Hokusai::Canvas.new(render_width.to_f, render_height.to_f)
+      event = SDL::Event.new
+
+      loop do
+        SDL.WaitEvent(event)
+        break if event[:common][:type] == SDL::QUIT || self.class.stopped
+        if process_input(input, event)
+          # since we are using wait event, we need to process the render twice
+          # once to capture all events, and once after updating block state.
+          SDL.SetRenderDrawBlendMode(renderer, SDL::BLENDMODE_BLEND)
+          SDL.SetRenderDrawColor(renderer, config.background[:r], config.background[:g], config.background[:b], config.background[:a])
+          SDL.RenderClear(renderer)
+          canvas.reset(nil, nil, render_width.to_f, render_height.to_f)
+          painter = Hokusai::Painter.new(block, input)
+          painter.render(canvas, resize)
+          block.update
+          SDL.RenderPresent(renderer)
+
+          SDL.SetRenderDrawBlendMode(renderer, SDL::BLENDMODE_BLEND)
+          SDL.SetRenderDrawColor(renderer, config.background[:r], config.background[:g], config.background[:b], config.background[:a])
+          SDL.RenderClear(renderer)
+          canvas.reset(nil, nil, render_width.to_f, render_height.to_f)
+          painter = Hokusai::Painter.new(block, input)
+          painter.render(canvas, resize, capture: false)
+          SDL.RenderPresent(renderer)
+        end
+      end
+
+      LibHokusai.hoku_input_free(input.raw)
+      if ENV["PROFILE"]
+        # report = MemoryProfiler.stop
+        # report.pretty_print
+      end
+    end
+
+    def mouse_button(clicked: false, down: false, released: false, up: false)
+      if @mouse_button.nil?
+        @mouse_button = LibHokusai::HmlInputMouseButton.create(clicked: clicked, down: down, released: released, up: up)
+      else
+        @mouse_button[:clicked] = clicked
+        @mouse_button[:down] = down
+        @mouse_button[:released] = released
+        @mouse_button[:up] = up
+      end
+
+      @mouse_button
+    end
+
+    def sdl_rect(x, y, w, h)
+      @sdl_rect ||= SDL::Rect.new
+      @sdl_rect[:x] = x
+      @sdl_rect[:y] = y
+      @sdl_rect[:w] = w
+      @sdl_rect[:h] = h
+
+      @sdl_rect
+    end
+
+    def reset_keys(input)
+      LibHokusai.hoku_input_keyboard_start(input.raw)
+      Modifiers.each do |(sdlk, hkey)|
+        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
+      end
+
+      Keys.values.each do |hkey|
+        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
+      end
+
+      LibHokusai.hoku_input_keyboard_stop(input.raw)
+    end
+
+    def process_input(input, event)
+      reset_keys(input)
+
+      case event[:common][:type]
+      when SDL::KEYDOWN
+        modifier = event[:key][:keysym][:mod]
+        code = event[:key][:keysym][:sym]
+        hkey = Keys[code]
+
+        LibHokusai.hoku_input_keyboard_start(input.raw)
+        Modifiers.each do |(sdlk, hkey)|
+          if modifier & sdlk == sdlk
+            LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, true)
+          end
+        end
+
+        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, true) unless hkey.nil?
+        LibHokusai.hoku_input_keyboard_stop(input.raw)
+
+        return true
+      when SDL::KEYUP
+        modifier = event[:key][:keysym][:mod]
+        code = event[:key][:keysym][:sym]
+        hkey = Keys[code]
+
+        LibHokusai.hoku_input_keyboard_start(input.raw)
+        Modifiers.each do |(sdlk, hkey)|
+          if modifier & sdlk == sdlk
+            LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
+          end
+        end
+
+        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false) unless hkey.nil?
+        LibHokusai.hoku_input_keyboard_stop(input.raw)
+        return true
+      when SDL::WINDOWEVENT
+        if event[:window][:event] == SDL::WINDOWEVENT_RESIZED
+          self.render_width = event[:window][:data1]
+          self.render_height = event[:window][:data2]
+
+          # free all static font textures
+          self.class.fonts.each do |k, payload|
+            texture, *_ = payload
+
+            SDL.DestroyTexture(texture)
+          end
+
+          self.class.fonts.clear
+        elsif event[:window][:event] == SDL::WINDOWEVENT_MOVED
+          # pp ["moved", Time.now.strftime("%H:%M:%S %L")]
+        end
+
+        return true
+      when SDL::MOUSEMOTION
+        if input.raw[:mouse][:delta][:y] > 0
+          # LibHokusai.hoku_input_mouse_set_scroll(input.raw, 0.0)
+          input.raw[:mouse][:delta][:y] = 0.0
+          input.raw[:mouse][:scroll_delta] = 0.0
+          input.raw[:mouse][:scroll] = event[:motion][:y]
+        end
+
+        # pp ["set mouse", Time.now.strftime("%H:%M:%S %L")]
+        hoku_mouse_pos = LibHokusai::HmlVec2.create(event[:motion][:x], event[:motion][:y])
+        LibHokusai.hoku_input_set_mouse_position(input.raw, hoku_mouse_pos)
+
+        # clear any click events
+        [[:left, 0], [:right, 2], [:middle, 1]].each do |(btn, i)|
+          button = input.raw[:mouse][btn]
+          button[:clicked] = false
+          LibHokusai.hoku_input_mouse_set_button(input.raw, button, i)
+        end
+
+        return true
+      when SDL::MOUSEWHEEL
+        LibHokusai.hoku_input_mouse_set_scroll(input.raw, event[:wheel][:preciseY])
+        input.raw[:mouse][:delta][:y] = event[:wheel][:preciseY]
+
+        # clear any click events
+        [[:left, 0], [:right, 2], [:middle, 1]].each do |(btn, i)|
+          button = input.raw[:mouse][btn]
+          button[:clicked] = false
+          LibHokusai.hoku_input_mouse_set_button(input.raw, button, i)
+        end
+        return true
+      when SDL::MOUSEBUTTONDOWN
+        clicked = event[:button][:clicks] > 0
+        button = mouse_button(down: true, clicked: clicked)
+
+        # LibHokusai.hoku_input_mouse_set_scroll(input.raw, 0.0)
+        # input.raw[:mouse][:delta][:y] = 0.0
+
+        LibHokusai.hoku_input_mouse_set_button(input.raw, button, event[:button][:which])
+        return true
+      when SDL::MOUSEBUTTONUP
+        button = mouse_button(up: true)
+        #
+        # LibHokusai.hoku_input_mouse_set_scroll(input.raw, 0.0)
+        # input.raw[:mouse][:delta][:y] = 0.0
+
+        LibHokusai.hoku_input_mouse_set_button(input.raw, button, event[:button][:which])
+        return true
+      when SDL::TEXTINPUT
+        return false
+      else
+        false
+      end
+    end
+
+    def nine_slice(x, y, w, h, rounding)
+      tx = x + rounding
+      ty = y
+      tw = w - (rounding * 2)
+      th = rounding
+
+      mx = x + rounding
+      my = y + rounding
+      mw = w - (rounding * 2)
+      mh = h - (rounding * 2)
+
+      bx = x + rounding
+      by = h - rounding
+      bw = w - (rounding * 2)
+      bh = rounding
+
+      {
+        top_center: [tx, ty, tw, th],
+        middle_center: [mx, my, mw, mh],
+        bottom_center: [bx, by, bw, bh]
+      }
+    end
+
+    def inside_scissor(x, y, h = 0)
+      return true if @scissor.nil?
+
+      val = y + h >= @scissor[1] && y <= @scissor[1] + @scissor[3]
+      # pp ["inside scissor", val, [x,y], @scissor]
+      val
+    end
+
+
+    def register_command_handlers(renderer, window)
+      Hokusai.on_set_mouse_cursor do |type|
+        sdl = self.class.cursors[type]
+        SDL.SetCursor(sdl)
+      end
+
+      Hokusai.on_maximize_window do
+        SDL.MaximizeWindow(window)
+      end
+
+      Hokusai.on_close_window do
+        self.class.stopped = true
+      end
+
+      Hokusai.on_minimize_window do
+        SDL.MinimizeWindow(window)
+      end
+
+      Hokusai.on_set_window_position do |(ox, oy)|
+        xp = FFI::MemoryPointer.new :int
+        yp = FFI::MemoryPointer.new :int
+
+        SDL.GetWindowPosition(window, xp, yp)
+
+        x = xp.read_int
+        y = yp.read_int
+
+        SDL.SetWindowPosition(window, (x + ox).to_i, (y + oy).to_i)
+        xp.free
+        yp.free
+      end
+
+      Hokusai.on_renderable do |canvas|
+        inside_scissor(canvas.x, canvas.y, canvas.height)
+      end
+
+      Hokusai::Commands::ScissorBegin.on_draw do |command|
+        rect = sdl_rect(command.x, command.y, command.width, command.height)
+        SDL.RenderSetClipRect(renderer, rect)
+
+        @scissor = [command.x, command.y, command.width, command.height]
+      end
+
+      Hokusai::Commands::ScissorEnd.on_draw do |_|
+        SDL.RenderSetClipRect(renderer, nil)
+
+        @scissor = nil
+      end
+
+      Hokusai::Commands::Circle.on_draw do |command|
+        next unless inside_scissor(command.x, command.y)
+
+        if command.outline > 0 && command.outline_color.a > 0
+          SDL.filledCircleRGBA(
+            renderer,
+            command.x,
+            command.y,
+            command.radius + command.outline,
+            command.color.r, command.color.g, command.color.b, command.color.a)
+        end
+
+        SDL.filledCircleRGBA(
+          renderer,
+          command.x,
+          command.y,
+          command.radius,
+          command.color.r, command.color.g, command.color.b, command.color.a
+        )
+      end
+
+      Hokusai::Commands::Image.on_draw do |command|
+        next unless inside_scissor(command.x, command.y, command.height)
+
+        texture = begin
+                    if self.class.images[command.source]
+                      self.class.images[command.source]
+                    else
+                      surface_ptr = SDL.IMG_Load(command.source)
+                      if surface_ptr.null?
+                        raise Hokusai::Error.new("Can't load Image: #{SDL.GetError.read_string}")
+                      end
+
+                      texture = SDL.CreateTextureFromSurface(renderer, surface_ptr)
+                      self.class.images[command.source] = texture
+                      SDL.FreeSurface(surface_ptr)
+                      texture
+                    end
+                  end
+
+        rect = sdl_rect(command.x, command.y, command.width, command.height)
+        SDL.RenderCopy(renderer, texture, nil, rect)
+      end
+
+      Hokusai::Commands::Rect.on_draw do |command|
+        next unless inside_scissor(command.x, command.y, command.height)
+
+        # draw background first
+        x, y, w, h = [command.x, command.y, command.width, command.height]
+
+        if command.outline_uniform? && command.rounding > 0 && command.outline_color.a > 0
+          SDL.roundedBoxRGBA(
+            renderer, x, y, x + w, y + h, (command.rounding).ceil.to_i,
+            command.outline_color.r,
+            command.outline_color.g,
+            command.outline_color.b,
+            command.outline_color.a
+          )
+        elsif command.outline_uniform? && command.rounding <= 0 && command.outline_color.a > 0
+          SDL.boxRGBA(
+            renderer, x, y, x + w, y + h,
+            command.outline_color.r,
+            command.outline_color.g,
+            command.outline_color.b,
+            command.outline_color.a
+          )
+        elsif command.outline_color.a > 0 && command.rounding <= 0
+          # x, y, w, h = command.background_boundary
+          if command.outline.top > 0
+            SDL.thickLineRGBA(
+              renderer,
+              x, y + (command.outline.top / 2), x + w, y + (command.outline.top / 2),
+              command.outline.top,
+              command.outline_color.r,
+              command.outline_color.g,
+              command.outline_color.b,
+              command.outline_color.a
+            )
+          end
+
+          if command.outline.right > 0
+            SDL.thickLineRGBA(
+              renderer,
+              x + w - (command.outline.right / 2), y, x + w - (command.outline.right / 2), y + h,
+              command.outline.right,
+              command.outline_color.r,
+              command.outline_color.g,
+              command.outline_color.b,
+              command.outline_color.a
+            )
+          end
+
+          if command.outline.bottom > 0
+            SDL.thickLineRGBA(
+              renderer,
+              x, y + h - (command.outline.bottom / 2), x + w, y + h - (command.outline.bottom / 2),
+              command.outline.bottom,
+              command.outline_color.r,
+              command.outline_color.g,
+              command.outline_color.b,
+              command.outline_color.a
+            )
+          end
+
+          if command.outline.left > 0
+            SDL.thickLineRGBA(
+              renderer,
+              x + (command.outline.left / 2), y , x + (command.outline.left / 2), y + h,
+              command.outline.left,
+              command.outline_color.r,
+              command.outline_color.g,
+              command.outline_color.b,
+              command.outline_color.a
+            )
+          end
+        end
+
+
+        x, y, w, h = command.background_boundary
+        rounding = command.rounding
+
+        if command.rounding > 0
+          SDL.roundedBoxRGBA(renderer, x, y, x + w, y + h, (command.rounding).ceil.to_i, command.color.r, command.color.g, command.color.b, command.color.a)
+        else
+          rect = SDL::Rect.new
+          rect[:x] = x
+          rect[:y] = y
+          rect[:w] = w
+          rect[:h] = h
+
+          SDL.SetRenderDrawColor(renderer, command.color.r, command.color.g, command.color.b, command.color.a)
+          SDL.RenderFillRect(renderer, rect)
+        end
+      end
+
+      Hokusai::Commands::Text.on_draw do |command|
+        next unless inside_scissor(command.x, command.y, command.size)
+
+        unless command.content.empty?
+          payload = begin
+                      if self.class.fonts[command.hash] && command.static
+                        self.class.fonts[command.hash]
+                      else
+                        font = (!command.font.nil? ? Hokusai.fonts.get(command.font) : Hokusai.fonts.active)
+                        font.size = command.size
+                        surface_ptr = font.render(command.content, command.color, bold: command.bold, italic: command.italic)
+                        texture = SDL.CreateTextureFromSurface(renderer, surface_ptr)
+                        surface = SDL::Surface.new(surface_ptr)
+                        load = [texture, surface[:w], surface[:h]]
+                        self.class.fonts[command.hash] = load
+                        SDL.FreeSurface(surface_ptr)
+                        load
+                      end
+                    end
+
+          texture, width, height = payload
+
+          SDL.RenderCopy(renderer, texture, nil, sdl_rect(
+            command.x + command.padding.left,
+            command.y + command.padding.top,
+            width,# - (command.padding.left + command.padding.right),
+            height# - (command.padding.top + command.padding.bottom)
+          ))
+          SDL.DestroyTexture(texture) unless command.static
+        end
+      end
+    end
+  end
+end