hokusai-zero 0.2.6.pre.pinephone2 → 0.2.6.pre.pinephone4

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

@@ -113,31 +113,64 @@ module Hokusai::Backends
     end
 
     def process_input(input)
-      raylib_mouse_pos = Raylib.GetMousePosition
-      raylib_mouse_delta = Raylib.GetMouseDelta
-      LibHokusai.hoku_input_mouse_set_scroll(input.raw, Raylib.GetMouseWheelMove)
-      LibHokusai.hoku_input_set_mouse_position(input.raw, hml_vec2(raylib_mouse_pos.x, raylib_mouse_pos.y))
+      if !config.touch
+        raylib_mouse_pos = Raylib.GetMousePosition
+        raylib_mouse_delta = Raylib.GetMouseDelta
+        LibHokusai.hoku_input_mouse_set_scroll(input.raw, Raylib.GetMouseWheelMove)
+        LibHokusai.hoku_input_set_mouse_position(input.raw, hml_vec2(raylib_mouse_pos.x, raylib_mouse_pos.y))
+
+        input.raw[:mouse][:delta][:x] = raylib_mouse_delta.x
+        input.raw[:mouse][:delta][:y] = raylib_mouse_delta.y
+      end
+
+      if config.touch
+        count = Raylib.GetTouchPointCount
+        if count > 0
+          vec = Raylib.GetTouchPosition(0)
+          unless vec.x.zero? && vec.y.zero?
+            input.touch.record(0, vec.x, vec.y)
+          end
+        else
+          input.touch.clear
+        end
+      else
+        [0,1,2].each do |button_id|
+          clicked = Raylib.IsMouseButtonPressed(button_id)
+          down = Raylib.IsMouseButtonDown(button_id)
+          released = Raylib.IsMouseButtonReleased(button_id)
+          up = Raylib.IsMouseButtonUp(button_id)
+
+          button = mouse_button(clicked: clicked, down: down, released: released, up: up)
+          LibHokusai.hoku_input_mouse_set_button(input.raw, button, button_id)
+        end
+      end
 
-      input.raw[:mouse][:delta][:x] = raylib_mouse_delta.x
-      input.raw[:mouse][:delta][:y] = raylib_mouse_delta.y
+      if config.touch
+        if input.touch.touching?
+          token = input.touch.token
 
-      [0,1,2].each do |button_id|
-        clicked = Raylib.IsMouseButtonPressed(button_id)
-        down = Raylib.IsMouseButtonDown(button_id)
-        released = Raylib.IsMouseButtonReleased(button_id)
-        up = Raylib.IsMouseButtonUp(button_id)
+          LibHokusai.hoku_input_set_mouse_position(input.raw, hml_vec2(token[:x], token[:y]))
+        end
 
-        button = mouse_button(clicked: clicked, down: down, released: released, up: up)
-        LibHokusai.hoku_input_mouse_set_button(input.raw, button, button_id)
+        # translate taps to clicks
+        if input.touch.tapped?
+          button = mouse_button(clicked: true, down: true, released: false, up: false)
+          LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+        else
+          button = mouse_button(clicked: false, down: false, released: true, up: true)
+          LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+        end
       end
 
-      LibHokusai.hoku_input_keyboard_start(input.raw)
+      if !input.keyboard_override
+        LibHokusai.hoku_input_keyboard_start(input.raw)
 
-      Keys.each do |(hoku_key, raylib_key)|
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hoku_key, Raylib.IsKeyDown(raylib_key))
-      end
+        Keys.each do |(hoku_key, raylib_key)|
+          LibHokusai.hoku_input_keyboard_set_key(input.raw, hoku_key, Raylib.IsKeyDown(raylib_key))
+        end
 
-      LibHokusai.hoku_input_keyboard_stop(input.raw)
+        LibHokusai.hoku_input_keyboard_stop(input.raw)
+      end
     end
 
     def self.run(app)
@@ -153,7 +186,6 @@ module Hokusai::Backends
       self.class.reset
 
       Raylib.load_lib(RAYLIB_PATH)
-
       resize = false
       initial = true
       width = config.width
@@ -166,6 +198,7 @@ module Hokusai::Backends
       raw = LibHokusai::HmlInput.new(ptr.get_pointer(0))
       input = Hokusai::Input.new(raw)
       ptr.free
+      input.support_touch! if config.touch
 
       Raylib.SetConfigFlags(config.config_flags)
       Raylib.InitWindow(config.width, config.height, config.title)
@@ -219,7 +252,7 @@ module Hokusai::Backends
         block.update
         block.public_send(:after_updated) if block.respond_to?(:after_updated)
 
-        canvas.reset(nil, nil, width.to_f, height.to_f)
+        canvas.reset(0.0, 0.0, width.to_f, height.to_f)
 
         Raylib.BeginDrawing
         Raylib.ClearBackground(config.background)
@@ -243,6 +276,7 @@ module Hokusai::Backends
         Raylib.DrawFPS(10, 10) if ENV["PROFILE"] || ENV["FPS"]
         Raylib.EndDrawing
 
+        GC.start
 
         break if self.class.stopped?
       end

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

@@ -3,8 +3,8 @@ module Hokusai::Backends
     class Config
       attr_accessor :width, :height, :fps, :init_flags,
                     :title, :background, :automation_driver,
-                    :after_load_cb, :host, :port, :automated,
-                    :window_config_flags
+                    :after_load_cb, :host, :port, :automated, :mobile,
+                    :window_config_flags, :touch
 
       def after_load(&block)
         self.after_load_cb = block
@@ -14,16 +14,19 @@ module Hokusai::Backends
         @width = 500
         @height = 500
         @fps = 60
+        @touch = false
 
         @init_flags = ::SDL::INIT_VIDEO | ::SDL::INIT_EVENTS
-        @window_config_flags = SDL::WINDOW_RESIZABLE
+        @window_config_flags = SDL::WINDOW_RESIZABLE | SDL::WINDOW_ALLOW_HIGHDPI
         @title = "(Unknown Title)"
         @background = SDLBackend.color(255,255,255, 0)
 
         after_load do
-          font = Hokusai::Backends::SDLBackend::Font.from "#{__dir__}/Monaco.ttf"
-          Hokusai.fonts.register "default", font
-          Hokusai.fonts.activate "default"
+          if Hokusai.fonts.get("default").nil?
+            font = Hokusai::Backends::SDLBackend::Font.from "#{__dir__}/Monaco.ttf"
+            Hokusai.fonts.register "default", font
+            Hokusai.fonts.activate "default"
+          end
         end
       end
     end

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

@@ -21,7 +21,7 @@ module Hokusai::Backends
     end
 
     class Font < Hokusai::Font
-      def self.from(file = "#{__dir__}/Monaco.ttf", size=50)
+      def self.from(file = "#{__dir__}/Monaco.ttf", size=60)
         raw = SDL.TTF_OpenFont(file, size)
 
         raise Hokusai::Error.new("Cannot open font from #{file}: #{ttf_error}") if raw.null?
@@ -51,6 +51,8 @@ module Hokusai::Backends
         set_style(**args)
 
         render_color = SDLBackend.color(color.r, color.g, color.b, color.a)
+        # bg = SDLBackend.color(0, 0, 0, 0)
+
         SDL.TTF_RenderUTF8_Blended(raw, text, render_color)
       end
 

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,43 +110,73 @@ 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)
+      
+      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
+
+              LibHokusai.hoku_input_set_mouse_position(input.raw, hml_vec2(token[:x], token[:y]))
+            end
+
+            # translate taps to clicks
+            if input.touch.tapped?
+              button = mouse_button(clicked: true, down: true, released: false, up: false)
+              LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+            else
+              button = mouse_button(clicked: false, down: false, released: true, up: true)
+              LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+            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)
@@ -157,52 +210,78 @@ 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
+        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
+        Keys.values.each do |hkey|
+          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
+        end
 
-      LibHokusai.hoku_input_keyboard_stop(input.raw)
+        LibHokusai.hoku_input_keyboard_stop(input.raw)
+      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::KEYDOWN
-        modifier = event[:key][:keysym][:mod]
-        code = event[:key][:keysym][:sym]
-        hkey = Keys[code]
+      when SDL::FINGERDOWN
+        x = event[:tfinger][:x] * render_width
+        y = event[:tfinger][:y] * render_height
 
-        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)
+        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
+        if !input.keyboard_override
+          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
-        end
 
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, true) unless hkey.nil?
-        LibHokusai.hoku_input_keyboard_stop(input.raw)
+          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, true) unless hkey.nil?
+          LibHokusai.hoku_input_keyboard_stop(input.raw)
+        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]
+
+          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
-        end
 
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false) unless hkey.nil?
-        LibHokusai.hoku_input_keyboard_stop(input.raw)
+          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false) unless hkey.nil?
+          LibHokusai.hoku_input_keyboard_stop(input.raw)
+        end
         return true
       when SDL::WINDOWEVENT
         if event[:window][:event] == SDL::WINDOWEVENT_RESIZED
@@ -257,20 +336,34 @@ module Hokusai::Backends
         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_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_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
+        char = event[:text][:text].to_s
+        LibHokusai.hoku_input_keyboard_start(input.raw)
+
+        Modifiers.each do |(sdlk, hkey)|
+          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
+        end
+        LibHokusai.hoku_input_keyboard_set_key(input.raw, char.to_sym, true)
+        LibHokusai.hoku_input_keyboard_stop(input.raw)
+
+        return true
+      when SDL::TEXTEDITING
+        # start = event[:edit][:start]
+        # len = event[:edit][:length]
+        # text = event[:edit][:text]
         return false
       else
         false
@@ -410,16 +503,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 +529,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 +605,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 +613,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

data/ui/src/hokusai/blocks/input.rb

@@ -87,7 +87,7 @@ class Hokusai::Blocks::Input < Hokusai::Block
   end
 
   def dynamic_keypress_handle(event)
-    return unless node.meta.focused
+    return unless node.meta.focused || event.input.keyboard_override
     case event
     when proc(&:ctrl), proc(&:super)
       if event.char == "z"