hokusai-zero 0.2.6 → 0.2.7

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

@@ -16,8 +16,7 @@ module Hokusai::Backends
         yield(config)
       end
 
-      block = app.mount
-      backend.run(block)
+      backend.run(app)
     end
 
     def self.cursors
@@ -30,6 +29,17 @@ module Hokusai::Backends
      }
     end
 
+    def hml_vec2(x, y)
+      if @hml_vec2.nil?
+        @hml_vec2 = LibHokusai::HmlVec2.create(x, y)
+      else
+        @hml_vec2[:x] = x
+        @hml_vec2[:y] = y
+      end
+
+      @hml_vec2
+    end
+
     def self.stopped
       @stopped ||= false
     end
@@ -56,7 +66,19 @@ module Hokusai::Backends
       yield @config
     end
 
-    def run(block)
+    def get_size(window)
+      w = FFI::MemoryPointer.new :int
+      h = FFI::MemoryPointer.new :int
+      
+      SDL.GL_GetDrawableSize(window, w, h)
+
+      res = { width: w.read_int, height: h.read_int }
+      w.free
+      h.free
+      res
+    end
+
+    def run(app)
       resize = true
       self.render_width = config.width
       self.render_height = config.height
@@ -80,6 +102,7 @@ module Hokusai::Backends
           image_libpath: "#{SDL_PATH}/libSDL2_image.so"
         )
       end
+
       SDL.Init(config.init_flags)
       SDL.TTF_Init
 
@@ -87,46 +110,77 @@ module Hokusai::Backends
       SDL.SetWindowPosition(window, SDL::WINDOWPOS_CENTERED_MASK, SDL::WINDOWPOS_CENTERED_MASK)
       renderer = SDL.CreateRenderer(window, -1, SDL::RENDERER_TARGETTEXTURE | SDL::RENDERER_ACCELERATED)
 
+      size = get_size(window)
+      SDL.RenderSetScale(renderer, size[:width] / render_width, size[:height] / render_height);
+
       Hokusai.fonts.register "default", SDLBackend::Font.from("#{__dir__}/sdl2/Monaco.ttf", 121)
       Hokusai.fonts.activate "default"
       config.after_load_cb&.call
 
       register_command_handlers(renderer, window)
+      block = app.mount
       # 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)
+      input = Hokusai::Input.new
+      
+      if config.touch
+        input.support_touch!
+      end
+
       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_NONE)
-          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_NONE)
-          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)
+        if SDL.PollEvent(event)
+          self.class.stopped = true if event[:common][:type] == SDL::QUIT || self.class.stopped
+          
+          process_input(input, event)
+          if config.touch
+            if input.touch.touching?
+              token = input.touch.token
+
+              input.mouse.pos.x = token[:x]
+              input.mouse.pos.y = token[:y]
+            end
+
+            # translate taps to clicks
+            if input.touch.tapped?
+              input.mouse.left.clicked = true
+              input.mouse.left.down = true
+              input.mouse.left.released = false
+              input.mouse.left.up = false
+            else
+              input.mouse.left.clicked = true
+              input.mouse.left.down = true
+              input.mouse.left.released = false
+              input.mouse.left.up = false
+            end
+          end
         end
+
+        break if self.class.stopped
+        # 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(0.0, 0.0, render_width.to_f, render_height.to_f)
+        painter = Hokusai::Painter.new(block, input)
+        painter.render(canvas, resize)
+
+        SDL.RenderPresent(renderer)
+        block.update
+
+        # SDL.SetRenderDrawBlendMode(renderer, SDL::BLENDMODE_NONE)
+        # 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)
+        SDL.Delay(10)
       end
 
-      LibHokusai.hoku_input_free(input.raw)
       if ENV["PROFILE"]
         # report = MemoryProfiler.stop
         # report.pretty_print
@@ -157,52 +211,76 @@ module Hokusai::Backends
     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
+      if !input.keyboard_override
+        input.keyboard.reset
 
-      Keys.values.each do |hkey|
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
-      end
+        Modifiers.each do |(sdlk, hkey)| 
+          input.keyboard.set(hkey, false)
+        end
 
-      LibHokusai.hoku_input_keyboard_stop(input.raw)
+        Keys.values.each do |hkey|
+          input.keyboard.set(hkey, false)
+        end
+      end
     end
 
     def process_input(input, event)
       reset_keys(input)
 
+      t = event[:common][:type]
+      if  config.touch && t != SDL::FINGERDOWN && t != SDL::WINDOWEVENT && t != SDL::FINGERUP && t != SDL::FINGERMOTION && t != SDL::MOUSEMOTION && t != SDL::POLLSENTINEL
+        input.touch.clear
+      end
+
       case event[:common][:type]
+      when SDL::FINGERDOWN
+        x = event[:tfinger][:x] * render_width
+        y = event[:tfinger][:y] * render_height
+
+        input.touch.record(0, x, y)
+        return true
+      when SDL::FINGERUP
+        input.touch.clear
+        return true
+      when SDL::FINGERMOTION
+        x = event[:tfinger][:x] * render_width
+        y = event[:tfinger][:y] * render_height
+
+        input.touch.record(0, x, y)
+        return true
       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)
+        if !input.keyboard_override
+          modifier = event[:key][:keysym][:mod]
+          code = event[:key][:keysym][:sym]
+          hkey = Keys[code]
+
+          input.keyboard.reset
+
+          Modifiers.each do |(sdlk, hkey)|
+            if modifier & sdlk == sdlk
+              input.keyboard.set(hkey, true)
+            end
           end
-        end
 
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, true) unless hkey.nil?
-        LibHokusai.hoku_input_keyboard_stop(input.raw)
+          input.keyboard.set(hkey, true) unless hkey.nil?
+        end
 
         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)
+        if !input.keyboard_override
+          modifier = event[:key][:keysym][:mod]
+          code = event[:key][:keysym][:sym]
+          hkey = Keys[code]
+          input.keyboard.reset
+
+          Modifiers.each do |(sdlk, hkey)|
+            if modifier & sdlk == sdlk
+              input.keyboard.set(hkey, false)
+            end
           end
-        end
 
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false) unless hkey.nil?
-        LibHokusai.hoku_input_keyboard_stop(input.raw)
+          input.keyboard.set(hkey, false) unless hkey.nil?
+        end
         return true
       when SDL::WINDOWEVENT
         if event[:window][:event] == SDL::WINDOWEVENT_RESIZED
@@ -223,54 +301,65 @@ module Hokusai::Backends
 
         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]
+        if input.mouse.delta.y > 0
+          input.mouse.delta.y = 0.0
+          input.mouse.scroll_delta = 0.0
+          input.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)
+        input.mouse.pos.x = event[:motion][:x]
+        input.mouse.pos.y = event[:motion][:y]
 
         # 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)
+          input.mouse.send(btn).clicked = false
         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]
+        input.mouse.scroll = event[:wheel][:preciseY]
+        input.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)
+          input.mouse.send(btn).clicked = false
         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
+        btn = {
+          0 => :left,
+          1 => :middle,
+          2 => :right
+        }[event[:button][:which]]
+
+        input.mouse.send(btn).clicked = clicked
+        input.mouse.send(btn).down = true
+        input.mouse.send(btn).up = false
+        input.mouse.scroll = 0.0
+        input.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])
+        btn = {
+          0 => :left,
+          1 => :middle,
+          2 => :right
+        }[event[:button][:which]]
+
+        input.mouse.send(btn).up = true
+        input.mouse.send(btn).down = false
+        input.mouse.scroll = 0.0
+        input.mouse.delta.y = 0.0
         return true
       when SDL::TEXTINPUT
+
+        return true
+      when SDL::TEXTEDITING
+        # start = event[:edit][:start]
+        # len = event[:edit][:length]
+        # text = event[:edit][:text]
         return false
       else
         false
@@ -410,16 +499,21 @@ module Hokusai::Backends
                       self.class.images[command.source]
                     else
                       file = File.read(command.source)
-
-                      rw = SDL.RWFromConstMem(file, file.size)
-                      surface_ptr = SDL.IMG_Load_RW(rw, 1)
-                      if surface_ptr.null?
+                      SDL.SetHint(SDL::HINT_RENDER_SCALE_QUALITY, "0");
+                      texture = SDL.IMG_LoadTexture(renderer, command.source)
+                      if texture.null?
                         raise Hokusai::Error.new("Can't load Image: #{SDL.GetError.read_string}")
                       end
 
-                      texture = SDL.CreateTextureFromSurface(renderer, surface_ptr)
+                      # rw = SDL.RWFromConstMem(file, file.size)
+                      # surface_ptr = SDL.IMG_LoadSVG_RW(rw)
+                      # 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)
+                      # SDL.FreeSurface(surface_ptr)
                       texture
                     end
                   end
@@ -431,6 +525,7 @@ module Hokusai::Backends
 
       Hokusai::Commands::Rect.on_draw do |command|
         next unless inside_scissor(command.x, command.y, command.height)
+        next if command.color.a == 0
         # draw background first
         x, y, w, h = [command.x, command.y, command.width, command.height]
 
@@ -506,7 +601,6 @@ module Hokusai::Backends
         rounding = command.rounding
 
         if command.rounding > 0
-          pp command.color
           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
@@ -515,6 +609,7 @@ module Hokusai::Backends
           rect[:w] = w
           rect[:h] = h
 
+          SDL.SetRenderDrawBlendMode(renderer, SDL::BLENDMODE_BLEND)
           SDL.SetRenderDrawColor(renderer, command.color.r, command.color.g, command.color.b, command.color.a)
           SDL.RenderFillRect(renderer, rect)
         end