hokusai-zero 0.2.6 → 0.2.7

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

@@ -5,6 +5,34 @@ 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/32.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"
@@ -28,6 +56,10 @@ module Hokusai::Backends
       @images ||= {}
     end
 
+    def self.shaders
+      @shaders ||= {}
+    end
+
     def self.stopped?
       @stop = false if @stop.nil?
 
@@ -69,8 +101,8 @@ module Hokusai::Backends
       @hml_vec2
     end
 
-    def color(hc)
-      if @raylib_color.nil?
+    def color(hc, fresh = false)
+      if @raylib_color.nil? || fresh
         @raylib_color = Raylib::Color.from_u8(hc.red, hc.green, hc.blue, hc.alpha)
       else
         @raylib_color[:r] = hc.red
@@ -109,31 +141,67 @@ 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))
-
-      input.raw[:mouse][:delta][:x] = raylib_mouse_delta.x
-      input.raw[:mouse][:delta][:y] = raylib_mouse_delta.y
+      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
 
-      [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)
+      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|
 
-        button = mouse_button(clicked: clicked, down: down, released: released, up: up)
-        LibHokusai.hoku_input_mouse_set_button(input.raw, button, button_id)
+          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
 
-      LibHokusai.hoku_input_keyboard_start(input.raw)
+      if config.touch
+        if input.touch.touching?
+          token = input.touch.token
 
-      Keys.each do |(hoku_key, raylib_key)|
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hoku_key, Raylib.IsKeyDown(raylib_key))
+          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
 
-      LibHokusai.hoku_input_keyboard_stop(input.raw)
+      if !input.keyboard_override
+        input.keyboard.reset
+
+        Keys.each do |(hoku_key, raylib_key)|
+          input.keyboard.set(hoku_key, Raylib.IsKeyDown(raylib_key))
+        end
+      end
     end
 
     def self.run(app)
@@ -149,7 +217,6 @@ module Hokusai::Backends
       self.class.reset
 
       Raylib.load_lib(RAYLIB_PATH)
-
       resize = false
       initial = true
       width = config.width
@@ -157,11 +224,8 @@ module Hokusai::Backends
 
       register_command_handlers
 
-      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
+      input = Hokusai::Input.new
+      input.support_touch! if config.touch
 
       Raylib.SetConfigFlags(config.config_flags)
       Raylib.InitWindow(config.width, config.height, config.title)
@@ -215,7 +279,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)
@@ -239,7 +303,6 @@ module Hokusai::Backends
         Raylib.DrawFPS(10, 10) if ENV["PROFILE"] || ENV["FPS"]
         Raylib.EndDrawing
 
-
         break if self.class.stopped?
       end
 
@@ -251,7 +314,9 @@ module Hokusai::Backends
         Raylib.UnloadTexture(texture)
       end
 
-      LibHokusai.hoku_input_free(input.raw)
+      self.class.shaders.each do |k, shader|
+        Raylib.UnloadShader(shader)
+      end
 
       if ENV["PROFILE"]
         report = MemoryProfiler.stop
@@ -263,6 +328,26 @@ 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?
 
@@ -282,11 +367,17 @@ 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?
 
-        Raylib::SetMouseCursor(raylib_type)
+        if raylib_type == -1
+          Raylib.HideCursor
+        else
+          Raylib.ShowCursor
+          Raylib::SetMouseCursor(raylib_type)
+        end
       end
 
       Hokusai.on_set_mouse_position do |mouse|
@@ -319,6 +410,38 @@ 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]
@@ -384,9 +507,9 @@ module Hokusai::Backends
         next unless inside_scissor(command.x, command.y, command.size)
 
         active_name = Hokusai.fonts.active_font_name
-        font = Hokusai.fonts.active
+        font_name = command.font.nil? ? active_name : command.font
 
-        Hokusai.fonts.activate command.font.nil? ? active_name : command.font
+        Hokusai.fonts.activate font_name
         font = Hokusai.fonts.active
 
         c = color(command.color)
@@ -394,9 +517,16 @@ module Hokusai::Backends
         y = command.y + command.padding.t
 
         if fnt = font
-          # content = FFI::MemoryPointer.from_string(command.content)
+          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
+    
           Raylib.DrawTextEx(fnt.raw, command.content.to_s, vec2(x, y), command.size, fnt.spacing, c)
-          # content.free
+
+          if fnt.sdf
+            Raylib.EndShaderMode
+          end
         else
           Raylib.DrawText(command.content, x, y, command.size, c)
         end
@@ -453,8 +583,9 @@ module Hokusai::Backends
           end
         else
           rect = rect(command.background_boundary)
-
-          if command.rounding > 0
+          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
             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,
-                    :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