hokusai-zero 0.2.6.pre.pinephone6 → 0.2.6

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

@@ -5,34 +5,6 @@ require 'memory_profiler'
 
 module Hokusai::Backends
   class RaylibBackend
-
-    SDF_SHADER = <<~EOF
-    #version 100
-
-    precision mediump float;
-
-    // Input vertex attributes (from vertex shader)
-    varying vec2 fragTexCoord;
-    varying vec4 fragColor;
-
-    // Input uniform values
-    uniform sampler2D texture0;
-    uniform vec4 colDiffuse;
-
-    // NOTE: Add your custom variables here
-    const float smoothing = 1.0/16.0;
-
-    void main()
-    {
-        // Texel color fetching from texture sampler
-        // NOTE: Calculate alpha using signed distance field (SDF)
-        float distance = texture2D(texture0, fragTexCoord).a;
-        float alpha = smoothstep(0.5 - smoothing, 0.5 + smoothing, distance);
-
-        // Calculate final fragment color
-        gl_FragColor = vec4(fragColor.rgb, fragColor.a*alpha);
-    }
-    EOF
     
     RAYLIB_PATH = ENV["RAYLIB_PATH"] || begin
       path = "#{__dir__}/../../../../vendor/lib"
@@ -56,10 +28,6 @@ module Hokusai::Backends
       @images ||= {}
     end
 
-    def self.shaders
-      @shaders ||= {}
-    end
-
     def self.stopped?
       @stop = false if @stop.nil?
 
@@ -101,8 +69,8 @@ module Hokusai::Backends
       @hml_vec2
     end
 
-    def color(hc, fresh = false)
-      if @raylib_color.nil? || fresh
+    def color(hc)
+      if @raylib_color.nil?
         @raylib_color = Raylib::Color.from_u8(hc.red, hc.green, hc.blue, hc.alpha)
       else
         @raylib_color[:r] = hc.red
@@ -141,67 +109,31 @@ module Hokusai::Backends
     end
 
     def process_input(input)
-      if !config.touch
-        raylib_mouse_pos = Raylib.GetMousePosition
-        raylib_mouse_delta = Raylib.GetMouseDelta
-
-        input.mouse.pos.x = raylib_mouse_pos.x
-        input.mouse.pos.y = raylib_mouse_pos.y
-        input.mouse.delta.x = raylib_mouse_delta.x
-        input.mouse.delta.y = raylib_mouse_delta.y
-        input.mouse.scroll = Raylib.GetMouseWheelMove
-      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
-         {left: 0, middle: 1, right: 2}.each do |key, button_id|
+      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))
 
-          button = input.mouse.public_send(key)
-          button.clicked = Raylib.IsMouseButtonPressed(button_id)
-          button.down = Raylib.IsMouseButtonDown(button_id)
-          button.released = Raylib.IsMouseButtonReleased(button_id)
-          button.up = Raylib.IsMouseButtonUp(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)
 
-          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
+        button = mouse_button(clicked: clicked, down: down, released: released, up: up)
+        LibHokusai.hoku_input_mouse_set_button(input.raw, button, button_id)
       end
 
-      if !input.keyboard_override
-        input.keyboard.reset
+      LibHokusai.hoku_input_keyboard_start(input.raw)
 
-        Keys.each do |(hoku_key, raylib_key)|
-          input.keyboard.set(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)
     end
 
     def self.run(app)
@@ -217,6 +149,7 @@ module Hokusai::Backends
       self.class.reset
 
       Raylib.load_lib(RAYLIB_PATH)
+
       resize = false
       initial = true
       width = config.width
@@ -224,8 +157,11 @@ module Hokusai::Backends
 
       register_command_handlers
 
-      input = Hokusai::Input.new
-      input.support_touch! if config.touch
+      ptr = FFI::MemoryPointer.new :pointer
+      LibHokusai.hoku_input_init(ptr)
+      raw = LibHokusai::HmlInput.new(ptr.get_pointer(0))
+      input = Hokusai::Input.new(raw)
+      ptr.free
 
       Raylib.SetConfigFlags(config.config_flags)
       Raylib.InitWindow(config.width, config.height, config.title)
@@ -279,7 +215,7 @@ module Hokusai::Backends
         block.update
         block.public_send(:after_updated) if block.respond_to?(:after_updated)
 
-        canvas.reset(0.0, 0.0, width.to_f, height.to_f)
+        canvas.reset(nil, nil, width.to_f, height.to_f)
 
         Raylib.BeginDrawing
         Raylib.ClearBackground(config.background)
@@ -303,6 +239,7 @@ module Hokusai::Backends
         Raylib.DrawFPS(10, 10) if ENV["PROFILE"] || ENV["FPS"]
         Raylib.EndDrawing
 
+
         break if self.class.stopped?
       end
 
@@ -314,9 +251,7 @@ module Hokusai::Backends
         Raylib.UnloadTexture(texture)
       end
 
-      self.class.shaders.each do |k, shader|
-        Raylib.UnloadShader(shader)
-      end
+      LibHokusai.hoku_input_free(input.raw)
 
       if ENV["PROFILE"]
         report = MemoryProfiler.stop
@@ -328,26 +263,6 @@ module Hokusai::Backends
       config.automation_driver&.stop
     end
 
-    def shader_value(value, type)
-      case type
-      when Hokusai::SHADER_UNIFORM_FLOAT
-        ptr = FFI::MemoryPointer.new(:float)
-        ptr.write_float(value)
-        ptr
-      when Hokusai::SHADER_UNIFORM_INT
-        ptr = FFI::MemoryPointer.new(:int)
-        ptr.write_int(value)
-        ptr
-      when Hokusai::SHADER_UNIFORM_IVEC2, Hokusai::SHADER_UNIFORM_UIVEC2, Hokusai::SHADER_UNIFORM_VEC2
-        Raylib::Vector2.create(*value)
-      when Hokusai::SHADER_UNIFORM_VEC3, Hokusai::SHADER_UNIFORM_IVEC3, Hokusai::SHADER_UNIFORM_UIVEC3
-        Raylib::Vector3.create(*value)
-      when Hokusai::SHADER_UNIFORM_VEC4, Hokusai::SHADER_UNIFORM_UIVEC4, Hokusai::SHADER_UNIFORM_IVEC4
-        Raylib::Vector4.create(*value)
-      end
-    end
-
-
     def inside_scissor(x, y, h = 0)
       return true if @scissor.nil?
 
@@ -367,17 +282,11 @@ module Hokusai::Backends
           ibeam: Raylib::MOUSE_CURSOR_IBEAM,
           crosshair: Raylib::MOUSE_CURSOR_CROSSHAIR,
           pointer: Raylib::MOUSE_CURSOR_POINTING_HAND,
-          none: -1,
         }[type]
 
         raise Hokusai::Error.new("Cursor #{type} not recognized") if raylib_type.nil?
 
-        if raylib_type == -1
-          Raylib.HideCursor
-        else
-          Raylib.ShowCursor
-          Raylib::SetMouseCursor(raylib_type)
-        end
+        Raylib::SetMouseCursor(raylib_type)
       end
 
       Hokusai.on_set_mouse_position do |mouse|
@@ -410,38 +319,6 @@ module Hokusai::Backends
         inside_scissor(canvas.x, canvas.y, canvas.height)
       end
 
-      Hokusai::Commands::ShaderBegin.on_draw do |command|
-        self.class.shaders[command.hash] ||= Raylib.LoadShaderFromMemory(command.vertex_shader, command.fragment_shader)
-
-        unless command.uniforms.empty?
-          command.uniforms.each do |key, value|
-            location = Raylib.GetShaderLocation(self.class.shaders[command.hash], key.to_s)
-
-            ptr = shader_value(value[0],  value[1])
-            Raylib.SetShaderValue(self.class.shaders[command.hash], location, ptr, value[1])
-            ptr.free if ptr.is_a?(FFI::MemoryPointer)
-          end
-        end
-
-        Raylib.BeginShaderMode(self.class.shaders[command.hash])
-
-        @shader = self.class.shaders[command.hash]
-      end
-
-      Hokusai::Commands::ShaderEnd.on_draw do |_|
-        Raylib.EndShaderMode
-
-        @shader = nil
-      end
-
-      Hokusai::Commands::Texture.on_draw do |command|
-        self.class.images[command.hash] ||= begin
-                  image = Raylib.GenImageColor(command.width, command.height, Raylib::BLANK)
-                  Raylib.LoadTextureFromImage(image)
-                end
-        Raylib.DrawTexture(self.class.images[command.hash], command.x, command.y, Raylib::WHITE)  
-      end
-
       Hokusai::Commands::ScissorBegin.on_draw do |command|
         Raylib.BeginScissorMode(command.x, command.y, command.width, command.height)
         @scissor = [command.x, command.y, command.width, command.height]
@@ -507,9 +384,9 @@ module Hokusai::Backends
         next unless inside_scissor(command.x, command.y, command.size)
 
         active_name = Hokusai.fonts.active_font_name
-        font_name = command.font.nil? ? active_name : command.font
+        font = Hokusai.fonts.active
 
-        Hokusai.fonts.activate font_name
+        Hokusai.fonts.activate command.font.nil? ? active_name : command.font
         font = Hokusai.fonts.active
 
         c = color(command.color)
@@ -517,16 +394,9 @@ module Hokusai::Backends
         y = command.y + command.padding.t
 
         if fnt = font
-          if fnt.sdf
-            self.class.shaders["font-sdf-#{font_name}"] ||= Raylib.LoadShaderFromMemory(nil, SDF_SHADER)
-            Raylib.BeginShaderMode(self.class.shaders["font-sdf-#{font_name}"])
-          end
-    
+          # content = FFI::MemoryPointer.from_string(command.content)
           Raylib.DrawTextEx(fnt.raw, command.content.to_s, vec2(x, y), command.size, fnt.spacing, c)
-
-          if fnt.sdf
-            Raylib.EndShaderMode
-          end
+          # content.free
         else
           Raylib.DrawText(command.content, x, y, command.size, c)
         end
@@ -583,9 +453,8 @@ module Hokusai::Backends
           end
         else
           rect = rect(command.background_boundary)
-          if command.gradient
-            Raylib.DrawRectangleGradientEx(rect, color(command.gradient[0], true), color(command.gradient[1], true), color(command.gradient[2], true), color(command.gradient[3], true))    
-          elsif command.rounding > 0
+
+          if command.rounding > 0
             Raylib.DrawRectangleRounded(rect, command.rounding, 50, background_color)
           else
             Raylib.DrawRectangleRec(rect, background_color)

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, :mobile,
-                    :window_config_flags, :touch
+                    :after_load_cb, :host, :port, :automated,
+                    :window_config_flags
 
       def after_load(&block)
         self.after_load_cb = block
@@ -14,19 +14,16 @@ 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 | SDL::WINDOW_ALLOW_HIGHDPI
+        @window_config_flags = SDL::WINDOW_RESIZABLE
         @title = "(Unknown Title)"
         @background = SDLBackend.color(255,255,255, 0)
 
         after_load do
-          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
+          font = Hokusai::Backends::SDLBackend::Font.from "#{__dir__}/Monaco.ttf"
+          Hokusai.fonts.register "default", font
+          Hokusai.fonts.activate "default"
         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=60)
+      def self.from(file = "#{__dir__}/Monaco.ttf", size=50)
         raw = SDL.TTF_OpenFont(file, size)
 
         raise Hokusai::Error.new("Cannot open font from #{file}: #{ttf_error}") if raw.null?
@@ -51,8 +51,6 @@ 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