hokusai-zero 0.2.6.pre.pinephone6 → 0.2.6

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

@@ -16,7 +16,8 @@ module Hokusai::Backends
         yield(config)
       end
 
-      backend.run(app)
+      block = app.mount
+      backend.run(block)
     end
 
     def self.cursors
@@ -29,17 +30,6 @@ 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
@@ -66,19 +56,7 @@ module Hokusai::Backends
       yield @config
     end
 
-    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)
+    def run(block)
       resize = true
       self.render_width = config.width
       self.render_height = config.height
@@ -102,7 +80,6 @@ module Hokusai::Backends
           image_libpath: "#{SDL_PATH}/libSDL2_image.so"
         )
       end
-
       SDL.Init(config.init_flags)
       SDL.TTF_Init
 
@@ -110,77 +87,46 @@ 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"]
 
-      input = Hokusai::Input.new
-      
-      if config.touch
-        input.support_touch!
-      end
-
+      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
-        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
+        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)
         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
@@ -211,76 +157,52 @@ module Hokusai::Backends
     end
 
     def reset_keys(input)
-      if !input.keyboard_override
-        input.keyboard.reset
-
-        Modifiers.each do |(sdlk, hkey)| 
-          input.keyboard.set(hkey, false)
-        end
+      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|
-          input.keyboard.set(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)
 
-      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
-        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
+        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
-
-          input.keyboard.set(hkey, true) unless hkey.nil?
         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
-        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
+        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
-
-          input.keyboard.set(hkey, false) unless hkey.nil?
         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
@@ -301,65 +223,54 @@ module Hokusai::Backends
 
         return true
       when SDL::MOUSEMOTION
-        if input.mouse.delta.y > 0
-          input.mouse.delta.y = 0.0
-          input.mouse.scroll_delta = 0.0
-          input.mouse.scroll = event[:motion][:y]
+        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
 
-        input.mouse.pos.x = event[:motion][:x]
-        input.mouse.pos.y = event[:motion][:y]
+        # 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)|
-          input.mouse.send(btn).clicked = false
+          button = input.raw[:mouse][btn]
+          button[:clicked] = false
+          LibHokusai.hoku_input_mouse_set_button(input.raw, button, i)
         end
 
         return true
       when SDL::MOUSEWHEEL
-        input.mouse.scroll = event[:wheel][:preciseY]
-        input.mouse.delta.y = event[:wheel][:preciseY]
+        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)|
-          input.mouse.send(btn).clicked = false
+          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
-        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
+        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
-        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
+        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::TEXTEDITING
-        # start = event[:edit][:start]
-        # len = event[:edit][:length]
-        # text = event[:edit][:text]
+      when SDL::TEXTINPUT
         return false
       else
         false
@@ -499,21 +410,16 @@ module Hokusai::Backends
                       self.class.images[command.source]
                     else
                       file = File.read(command.source)
-                      SDL.SetHint(SDL::HINT_RENDER_SCALE_QUALITY, "0");
-                      texture = SDL.IMG_LoadTexture(renderer, command.source)
-                      if texture.null?
+
+                      rw = SDL.RWFromConstMem(file, file.size)
+                      surface_ptr = SDL.IMG_Load_RW(rw, 1)
+                      if surface_ptr.null?
                         raise Hokusai::Error.new("Can't load Image: #{SDL.GetError.read_string}")
                       end
 
-                      # 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)
+                      texture = SDL.CreateTextureFromSurface(renderer, surface_ptr)
                       self.class.images[command.source] = texture
-                      # SDL.FreeSurface(surface_ptr)
+                      SDL.FreeSurface(surface_ptr)
                       texture
                     end
                   end
@@ -525,7 +431,6 @@ 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]
 
@@ -601,6 +506,7 @@ 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
@@ -609,7 +515,6 @@ 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 || event.input.keyboard_override
+    return unless node.meta.focused
     case event
     when proc(&:ctrl), proc(&:super)
       if event.char == "z"
@@ -154,7 +154,7 @@ class Hokusai::Blocks::Input < Hokusai::Block
           self.buffer_offset = offset
         end
 
-        self.buffer += event.char unless event.char.nil?
+        self.buffer += event.char
       end
     end
 

data/ui/src/hokusai/commands/rect.rb

@@ -2,7 +2,7 @@ module Hokusai
   class Commands::Rect < Commands::Base
     attr_reader :x, :y, :width, :height,
                 :rounding, :color, :outline,
-                :outline_color, :padding, :gradient
+                :outline_color, :padding
 
     def initialize(x, y, width, height)
       @x = x.to_f
@@ -11,10 +11,9 @@ module Hokusai
       @height = height.to_f
       @outline = Outline.default
       @rounding = 0.0
-      @color = Color.new(255, 255, 255, 0)
-      @outline_color = Color.new(0, 0, 0, 0)
+      @color = Color.new(0, 0, 0, 0)
+      @outline_color = Color.new(0, 0, 0, 255)
       @padding = Padding.new(0.0, 0.0, 0.0, 0.0)
-      @gradient = nil
     end
 
     def hash
@@ -45,14 +44,6 @@ module Hokusai
       height
     end
 
-    def gradient=(colors)
-      unless colors.is_a?(Array) && colors.size == 4 && colors.all? { |color| color.is_a?(Hokusai::Color) }
-        raise Hokusai::Error.new("Gradient must be an array of 4 Hokuai::Color")
-      end
-
-      @gradient = colors
-    end
-
     # Sets padding for the rectangle
     # `value` is an array with padding declarations
     # at [top, right, bottom, left]

data/ui/src/hokusai/commands.rb

@@ -4,8 +4,6 @@ require_relative "./commands/image"
 require_relative "./commands/rect"
 require_relative "./commands/scissor"
 require_relative "./commands/text"
-require_relative "./commands/shader"
-require_relative "./commands/texture"
 
 module Hokusai
   # A proxy class for invoking various UI commands
@@ -83,26 +81,6 @@ module Hokusai
       queue << Commands::ScissorEnd.new
     end
 
-    def shader_begin
-      command = Commands::ShaderBegin.new
-
-      yield command
-
-      queue << command
-    end
-
-    def shader_end
-      queue << Commands::ShaderEnd.new
-    end
-
-    def texture(x, y, w, h)
-      command = Commands::Texture.new(x, y, w, h)
-
-      yield command
-
-      queue << command
-    end
-
     # Draws text
     #
     # @param [String] the text content

data/ui/src/hokusai/event.rb

@@ -65,5 +65,4 @@ module Hokusai
 end
 
 require_relative './events/keyboard'
-require_relative './events/mouse'
-require_relative './events/touch'
+require_relative './events/mouse'

data/ui/src/hokusai/events/keyboard.rb

@@ -1,11 +1,10 @@
-# frozen_string_literal: true
-
 module Hokusai
   class KeyboardEvent < Event
     extend Forwardable
 
     def_delegators :@keyboard, :shift, :super, :ctrl,
-                   :alt, :pressed, :released, :char, :code
+                   :alt, :pressed, :pressed_len, :released,
+                   :released_len
 
     attr_reader :input
 
@@ -36,40 +35,48 @@ module Hokusai
   class KeyUpEvent < KeyboardEvent
     name "keyup"
 
+    def keyboard_key
+      input.raw[:keyboard][:released]
+    end
+
     def key
-      released[0]&.[](:symbol)
+      keyboard_key[:key][:key]
     end
 
     def code
-      released[0]&.[](:code)
+      keyboard_key[:char_code]
     end
 
     def char
-      released[0]&.[](:char)
+      code.chr
     end
 
     def capture(block, _)
-      captures << block if matches(block) && released.size > 0
+      captures << block if matches(block) && released_len > 0
     end
   end
 
   class KeyPressEvent < KeyboardEvent
     name "keypress"
 
+    def keyboard_key
+      input.raw[:keyboard][:pressed]
+    end
+
     def key
-      pressed[0]&.[](:symbol)
+      keyboard_key[:key][:key]
     end
 
     def code
-      pressed[0]&.[](:code)
+      keyboard_key[:char_code]
     end
 
     def char
-      pressed[0]&.[](:char)
+      code.chr
     end
 
     def capture(block, _)
-      return unless matches(block) && pressed.size > 0
+      return unless matches(block) && pressed_len > 0
 
       captures << block
     end

data/ui/src/hokusai/events/mouse.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Hokusai
   class MouseEvent < Event
     extend Forwardable
@@ -69,7 +67,7 @@ module Hokusai
     protected
 
     def hovered(canvas)
-      input.hovered?(canvas)
+      LibHokusai.hoku_input_is_hovered(input.raw, canvas.to_hoku_rect)
     end
   end
 
@@ -87,19 +85,19 @@ module Hokusai
     name "click"
 
     def capture(block, canvas)
-      if left.clicked && clicked(canvas)
+      if left[:clicked] && clicked(canvas)
         block.node.meta.focus
 
         if matches(block)
           captures << block
         end
-      elsif left.clicked
+      elsif left[:clicked]
         block.node.meta.blur
       end
     end
 
     def clicked(canvas)
-      left.clicked && input.hovered?(canvas)
+      LibHokusai.hoku_input_is_clicked(input.raw, canvas.to_hoku_rect)
     end
   end
 
@@ -107,7 +105,7 @@ module Hokusai
     name "mouseup"
 
     def capture(block, _)
-      if left.up && matches(block)
+      if left[:up] && matches(block)
         captures << block
       end
     end
@@ -117,7 +115,7 @@ module Hokusai
     name "mousedown"
 
     def capture(block, _)
-      if left.down && matches(block)
+      if left[:down] && matches(block)
         captures << block
       end
     end
@@ -170,13 +168,13 @@ module Hokusai
     def capture(block, canvas)
       captures << block if matches(block)
 
-      if left.clicked && !clicked(canvas)
+      if left[:clicked] && !clicked(canvas)
         block.node.meta.blur
       end
     end
 
     def clicked(canvas)
-      left.clicked && input.hovered?(canvas)
+      LibHokusai.hoku_input_is_clicked(input.raw, canvas.to_hoku_rect)
     end
   end
 end

data/ui/src/hokusai/mounting/loop_entry.rb

@@ -65,7 +65,7 @@ module Hokusai
 
           portal = Node.new(ast)
           node = child_block_class.compile(ast.type, portal)
-          child_block = child_block_class.new(node: node, providers: mount_providers)
+          child_block = child_block_class.new(node: node)
           child_block.node.add_styles(target.class)
           child_block.node.add_props_from_block(target, context: ctx)
           child_block.node.meta.set_prop(ast.loop.var.to_sym, value)