hokusai-zero 0.1.1

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

@@ -0,0 +1,449 @@
+require "raylib"
+require 'memory_profiler'
+
+# frozen_string_literal: true
+
+module Hokusai::Backends
+  class RaylibBackend
+    RAYLIB_PATH = ENV["RAYLIB_PATH"] || "#{__dir__}/../../../../vendor/lib"
+
+    attr_reader :config
+
+    def self.icons
+      @icons ||= {}
+    end
+
+    def self.images
+      @images ||= {}
+    end
+
+    def self.stopped?
+      @stop = false if @stop.nil?
+
+      @stop
+    end
+
+    def self.stop!
+      @stop = true
+    end
+
+    def self.reset
+      @stop = false
+    end
+
+    def initialize
+      @config = Config.new
+
+      yield(config)
+    end
+
+    def vec2(x, y)
+      if @raylib_vec2.nil?
+        @raylib_vec2 = Raylib::Vector2.new
+      end
+      @raylib_vec2[:x] = x
+      @raylib_vec2[:y] = y
+
+      @raylib_vec2
+    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 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
+        @raylib_color[:g] = hc.green
+        @raylib_color[:b] = hc.blue
+        @raylib_color[:a] = hc.alpha
+      end
+
+      @raylib_color
+    end
+
+    def rect(arr)
+      if @raylib_rect.nil?
+        @raylib_rect = Raylib::Rectangle.create(arr[0], arr[1], arr[2], arr[3])
+      else
+        @raylib_rect[:x] = arr[0]
+        @raylib_rect[:y] = arr[1]
+        @raylib_rect[:width] = arr[2]
+        @raylib_rect[:height] = arr[3]
+      end
+
+      @raylib_rect
+     end
+
+    def mouse_button(clicked: false, down: false, released: false, up: false)
+      if @mouse_button.nil?
+        @mouse_button = LibHokusai::HmlInputMouseButton.create(clicked: clicked, down: down, released: released, up: up)
+      else
+        @mouse_button[:clicked] = clicked
+        @mouse_button[:down] = down
+        @mouse_button[:released] = released
+        @mouse_button[:up] = up
+      end
+
+      @mouse_button
+    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
+
+      [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
+
+      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
+
+      LibHokusai.hoku_input_keyboard_stop(input.raw)
+    end
+
+    def self.run(app)
+      backend = new do |config|
+        yield config
+      end
+
+      block = app.mount
+      backend.run(block)
+    end
+
+    def run(block)
+      self.class.reset
+
+      case RbConfig::CONFIG['host_os']
+      when /darwin/
+        Raylib.load_lib("#{RAYLIB_PATH}/libraylib.dylib")
+      when /mswin|msys|mingw/
+        Raylib.load_lib("#{RAYLIB_PATH}/libraylib.dll")
+      when /linux/
+        Raylib.load_lib("#{RAYLIB_PATH}/libraylib.so")
+      end
+
+      resize = false
+      initial = true
+      width = config.width
+      height = config.height
+
+      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
+
+      Raylib.SetConfigFlags(config.config_flags)
+      Raylib.InitWindow(config.width, config.height, config.title)
+      Raylib.SetTargetFPS(config.fps)
+      Raylib.SetWindowState(config.window_state_flags)
+
+      unless Hokusai.fonts.get("default")
+        Hokusai.fonts.register "default", Hokusai::Backends::RaylibBackend::Font.default
+        Hokusai.fonts.activate "default"
+      end
+
+      config.after_load_cb&.call
+
+      if config.automated
+        config.start_automation_driver
+      end
+      
+      canvas = Hokusai::Canvas.new(width.to_f, height.to_f, 0.0, 0.0)
+      @texture = Raylib.LoadRenderTexture(width, height)
+      Raylib.SetTextureFilter(@texture.texture, Raylib::TEXTURE_FILTER_POINT)
+
+      width = nil
+      height = nil
+
+      MemoryProfiler.start if ENV["PROFILE"]
+
+      Raylib.EnableEventWaiting if config.event_waiting
+      last_input_hash = nil
+
+      until Raylib.WindowShouldClose
+        last_width = Raylib.GetScreenWidth
+        last_height = Raylib.GetScreenHeight
+
+        if last_width != width || last_height != height
+          resize = true
+        else
+          resize = false
+        end
+
+        width = last_width
+        height = last_height
+
+        process_input(input)
+        block.update
+
+        canvas.reset(nil, nil, width.to_f, height.to_f)
+
+        Raylib.BeginDrawing
+        Raylib.ClearBackground(config.background)
+
+        painter = Hokusai::Painter.new(block, input)
+
+        if config.automation_driver
+          painter.on_before_render do |blocks, canvas, input|
+            config.automation_driver.process(blocks, canvas, input)
+          end
+
+          painter.on_after_render do
+            config.automation_driver.complete
+          end
+
+          sleep 0.004
+        end
+
+        painter.render(canvas, resize)
+
+        Raylib.DrawFPS(10, 10) if ENV["PROFILE"] || ENV["FPS"]
+        Raylib.EndDrawing
+
+
+        break if self.class.stopped?
+      end
+
+      Hokusai.fonts.fonts.each do |key, font|
+        Raylib.UnloadFont(font.raw)
+      end
+
+      LibHokusai.hoku_input_free(input.raw)
+
+      if ENV["PROFILE"]
+        report = MemoryProfiler.stop
+        report.pretty_print(scale_bytes: true)
+      end
+
+      Raylib.CloseWindow
+
+      config.automation_driver&.stop
+    end
+
+    def inside_scissor(x, y, h = 0)
+      return true if @scissor.nil?
+
+      val = y + h >= @scissor[1] && y <= @scissor[1] + @scissor[3]
+      val
+    end
+
+    def register_command_handlers
+      Hokusai.on_close_window do
+        self.class.stop!
+      end
+
+      Hokusai.on_set_mouse_cursor do |type|
+        raylib_type = {
+          default: Raylib::MOUSE_CURSOR_DEFAULT,
+          arrow: Raylib::MOUSE_CURSOR_ARROW,
+          ibeam: Raylib::MOUSE_CURSOR_IBEAM,
+          crosshair: Raylib::MOUSE_CURSOR_CROSSHAIR,
+          pointer: Raylib::MOUSE_CURSOR_POINTING_HAND,
+        }[type]
+
+        raise Hokusai::Error.new("Cursor #{type} not recognized") if raylib_type.nil?
+
+        Raylib::SetMouseCursor(raylib_type)
+      end
+
+      Hokusai.on_set_mouse_position do |mouse|
+        Raylib.SetMousePosition(mouse.pos.x, mouse.pos.y)
+      end
+
+      Hokusai.on_set_window_position do |(dx, dy)|
+        wpos = Raylib.GetWindowPosition
+
+        Raylib.SetWindowPosition(wpos.x + dx, wpos.y + dy)
+      end
+
+      Hokusai.on_restore_window do
+        Raylib.RestoreWindow
+      end
+
+      Hokusai.on_maximize_window do
+        if Raylib.IsWindowMaximized
+          Raylib.RestoreWindow
+        else
+          Raylib.MaximizeWindow
+        end
+      end
+
+      Hokusai.on_minimize_window do
+        Raylib.MinimizeWindow
+      end
+
+      Hokusai.on_renderable do |canvas|
+        inside_scissor(canvas.x, canvas.y, canvas.height)
+      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]
+      end
+
+      Hokusai::Commands::ScissorEnd.on_draw do |_|
+        Raylib.EndScissorMode
+        @scissor = nil
+      end
+
+      Hokusai::Commands::Circle.on_draw do |command|
+        next unless inside_scissor(command.x, command.y)
+
+        radius = command.radius - command.outline
+        rc = command.color
+        color = Raylib::Color.from_u8(rc.r, rc.g, rc.b, rc.a)
+        Raylib.DrawCircleV(vec2(command.x, command.y), radius, color)
+
+        if command.outline > 0
+          Raylib.DrawCircleLines(command.x.ceil.to_i, command.y.ceil.to_i, command.radius, color(command.color))
+        end
+      end
+
+      Hokusai::Commands::SVG.on_draw do |command|
+        command = command.as(Hokusai::Commands::SVG)
+        texture = begin
+                    if self.class.images[command.source]
+                      self.class.images[command.source]
+                    else
+                      img = Raylib.LoadImageSVG(command.source, command.width, command.height)
+                      texture = Raylib.load_texture_from_image(img)
+                      Raylib.UnloadImage(img)
+                      self.class.images[command.source] = texture
+                      Raylib.GenTextureMipmaps(texture)
+                      texture
+                    end
+                  end
+
+        Raylib.DrawTexture(texture, command.x, command.y, color(command.color))
+      end
+
+      Hokusai::Commands::Image.on_draw do |command|
+        next unless inside_scissor(command.x, command.y, command.height)
+
+        texture = begin
+                    if self.class.images[command.cache]
+                      self.class.images[command.cache]
+                    else
+                      img = Raylib.LoadImage(command.source)
+                      Raylib.ImageResize(img.to_ptr, command.width, command.height)
+
+                      texture = Raylib.LoadTextureFromImage(img)
+                      Raylib.UnloadImage(img)
+                      self.class.images[command.cache] = texture
+                      Raylib.GenTextureMipmaps(texture)
+                      texture
+                    end
+                  end
+
+        Raylib.DrawTexture(texture, command.x, command.y, Raylib::WHITE)
+      end
+
+      Hokusai::Commands::Text.on_draw do |command|
+        next unless inside_scissor(command.x, command.y, command.size)
+
+        font = Hokusai.fonts.active
+        c = color(command.color)
+        x = command.x + command.padding.l
+        y = command.y + command.padding.t
+
+        if fnt = font
+          # content = FFI::MemoryPointer.from_string(command.content)
+          Raylib.DrawTextEx(fnt.raw, command.content.to_s, vec2(x, y), command.size, fnt.spacing, c)
+          # content.free
+        else
+          Raylib.DrawText(command.content, x, y, command.size, c)
+        end
+      end
+
+      Hokusai::Commands::Rect.on_draw do |command|
+        next unless inside_scissor(command.x, command.y, command.height)
+
+        background_color = color(command.color)
+        # the rect has an outline
+        # so we want to render twice
+        if command.outline?
+          # for Raylib, the boundaries for background and outline are the same
+          # rectangles render in from the boundary
+          # and outlines render out from the boundary
+          # background_rect = outline_rect
+          outline_rect = rect(command.background_boundary)
+          background_rect = outline_rect
+          # rect is rounded so we need a rounded outline and
+          # a regular one
+          if command.rounding > 0
+            Raylib.DrawRectangleRounded(background_rect, command.rounding, 50, background_color)
+          else
+            Raylib.DrawRectangleRec(background_rect, background_color)
+          end
+
+          outline_color = color(command.outline_color)
+
+          # now draw the outlines
+          if command.outline_uniform? && command.rounding > 0.0 && outline_color.a > 0
+            Raylib.DrawRectangleRoundedLines(outline_rect, command.rounding, 50, command.outline.top, outline_color)
+          elsif command.outline_uniform? && !(command.rounding <= 0.0) && outline_color.a > 0
+            Raylib.DrawRectangleLinesEx(outline_rect, command.outline.top, outline_color)
+          elsif !command.outline_uniform?
+            ox, oy, ow, oh = command.background_boundary
+
+            if command.outline.top > 0.0
+              Raylib.DrawLineEx(vec2(ox, oy), vec2(ox + ow, oy), command.outline.top, outline_color)
+            end
+
+            if command.outline.left > 0.0
+              Raylib.DrawLineEx(vec2(ox, oy), vec2(ox, oy + oh), command.outline.left, outline_color)
+            end
+
+            if command.outline.right > 0.0
+              Raylib.DrawLineEx(vec2(ox + ow, oy), vec2(ox + ow, oy + oh), command.outline.right, outline_color)
+            end
+
+            if command.outline.bottom > 0.0
+              Raylib.DrawLineEx(vec2(ox, oy + oh), vec2(ox + ow, oy + oh), command.outline.bottom, outline_color)
+            end
+          end
+        else
+          rect = rect(command.background_boundary)
+
+          if command.rounding > 0
+            Raylib.DrawRectangleRounded(rect, command.rounding, 50, background_color)
+          else
+            Raylib.DrawRectangleRec(rect, background_color)
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "../../hokusai/font"
+require_relative "./raylib/config"
+require_relative "./raylib/font"
+require_relative "./raylib/keys"

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

@@ -0,0 +1,12 @@
+module Hokusai::Backends
+  class SDLBackend
+    def self.color(r, g, b, a = 255)
+      color = SDL::Color.new
+      color[:r] = r
+      color[:g] = g
+      color[:b] = b
+      color[:a] = a
+      color
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Hokusai::Backends
+  class SDLBackend
+    class Config
+      attr_accessor :width, :height, :fps, :init_flags,
+                    :title, :background, :automation_driver,
+                    :after_load_cb, :host, :port, :automated,
+                    :window_config_flags
+
+      def after_load(&block)
+        self.after_load_cb = block
+      end
+
+      def initialize
+        @width = 500
+        @height = 500
+        @fps = 60
+
+        @init_flags = ::SDL::INIT_VIDEO | ::SDL::INIT_EVENTS
+        @window_config_flags = SDL::WINDOW_RESIZABLE
+        @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"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+module Hokusai::Backends
+  class SDLBackend
+    OnWidthCb = Proc.new do |char, raw|
+      minxp = FFI::MemoryPointer.new :int
+      maxxp = FFI::MemoryPointer.new :int
+      minyp = FFI::MemoryPointer.new :int
+      maxyp = FFI::MemoryPointer.new :int
+      advancep = FFI::MemoryPointer.new :int
+
+      SDL.TTF_GlyphMetrics32(raw, char.ord, minxp, maxxp, minyp, maxyp, advancep)
+
+      metrics = [minxp.read_int, maxxp.read_int, minyp.read_int, maxyp.read_int, advancep.read_int]
+
+      minxp.free
+      maxxp.free
+      minyp.free
+      maxyp.free
+      advancep.free
+
+      metrics[4].to_f
+    end
+
+    class Font < Hokusai::Font
+      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?
+
+        new(raw)
+      end
+
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def self.ttf_error
+        SDL.GetError.read_string
+      end
+
+      def set_style(bold: false, italic: false)
+        style = SDL::TTF_STYLE_NORMAL
+        style = style | SDL::TTF_STYLE_BOLD if bold
+        style = style | SDL::TTF_STYLE_ITALIC if italic
+
+        SDL.TTF_SetFontStyle(raw, style)
+      end
+
+      def render(text, color = Color.new(0, 0, 0, 255), **args)
+        set_style(**args)
+
+        render_color = SDLBackend.color(color.r, color.g, color.b, color.a)
+        SDL.TTF_RenderUTF8_Blended(raw, text, render_color)
+      end
+
+      def ascent
+        SDL.TTF_FontAscent(raw)
+      end
+
+      def descent
+        SDL.TTF_FontDescent(raw)
+      end
+
+      def height
+        SDL.TTF_FontHeight(raw)
+      end
+
+      def clamp(text, size, width, initial_offset = 0.0)
+        self.size = size
+
+        clamping_pointer = FFI::MemoryPointer.new :pointer
+
+        ret = LibHokusai.hoku_text_clamp(clamping_pointer, text, width, initial_offset, raw, SDLBackend::OnWidthCb)
+        raise Hokusai::Error.new("Clamping failed") unless ret.zero?
+
+        clamping = LibHokusai::HokuClamping.new(clamping_pointer.get_pointer(0))
+        Hokusai::Clamping.new(clamping)
+      end
+
+      def clamp_markdown(text, size, width, initial_offset = 0.0)
+        self.size = size
+
+        clamping_pointer = FFI::MemoryPointer.new :pointer
+
+        ret = LibHokusai.hoku_text_md_clamp(clamping_pointer, text, width, initial_offset, raw, SDLBackend::OnWidthCb)
+        raise Hokusai::Error.new("Clamping failed") unless ret.zero?
+
+        clamping = LibHokusai::HokuClamping.new(clamping_pointer.get_pointer(0))
+        Hokusai::Clamping.new(clamping, markdown: true)
+      end
+
+      def fits(text, width)
+        extent = FFI::MemoryPointer.new :int
+        count = FFI::MemoryPointer.new :int
+        SDL.TTF_Measure(raw, text, width.to_i, extent, count)
+
+        e = extent.read_int
+        c = count.read_int
+
+        extent.free
+        count.free
+
+        [e, c]
+      end
+
+      def measure(text, size = 15)
+        w = FFI::MemoryPointer.new :int
+        h = FFI::MemoryPointer.new :int
+
+        SDL.TTF_SizeText(raw, text, w, h)
+
+        width = w.read_int
+        height = h.read_int
+
+        w.free
+        h.free
+
+        [width, height]
+      end
+
+      def size=(val)
+        SDL.TTF_SetFontSize(raw, val.to_i)
+      end
+    end
+  end
+end