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

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

@@ -1,540 +0,0 @@
-require "raylib"
-require 'memory_profiler'
-
-# frozen_string_literal: true
-
-module Hokusai::Backends
-  class EmbeddedBackend
-    
-    RAYLIB_PATH = ENV["RAYLIB_PATH"] || begin
-      path = "#{__dir__}/../../../../vendor/lib"
-      case RbConfig::CONFIG['host_os']
-      when /darwin/
-        "#{path}/libraylib.dylib"
-      when /mswin|msys|mingw/
-        "#{path}/libraylib.dll"
-      when /linux/
-        "#{path}/libraylib.so"
-      end
-    end
-
-    attr_reader :config
-    attr_accessor :last_touch, :last_gesture, :touches, :stuff
-
-    def self.icons
-      @icons ||= {}
-    end
-
-    def self.images
-      @images ||= {}
-    end
-
-    def self.shaders
-      @shaders ||= {}
-    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, fresh = false)
-      if @raylib_vec2.nil? || fresh
-        @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, 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
-        @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)
-      self.touches = Raylib.GetTouchPointCount
-      if touches > 0
-        touches.times do |i|
-          vec = Raylib.GetTouchPosition
-
-          if LibHokusai.hoku_input_record_touch(input.raw, i, vec.x, vec.y) == -1
-            raise Hokusai::Error.new("Could not record touch")
-          end
-        end
-      else
-        config.max_touch_count.times do |i|
-          LibHokusai.hoku_input_clear_touch(input.raw, i)
-        end
-      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
-
-    def self.run(app)
-      backend = new do |config|
-        yield config
-      end
-
-      block = app.mount
-      backend.run(block)
-    end
-
-    def run(block)
-      self.class.reset
-
-      Raylib.load_lib(RAYLIB_PATH)
-
-      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))
-      LibHokusai.hoku_input_attach_touch(raw, config.max_touch_count)
-
-      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::EmbeddedBackend::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
-        if Raylib.IsWindowFocused
-          Raylib.DisableEventWaiting
-        else
-          Raylib.EnableEventWaiting
-        end
-
-        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.public_send(:before_updated) if block.respond_to?(:before_updated)
-        block.update
-        block.public_send(:after_updated) if block.respond_to?(:after_updated)
-
-        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.DrawText("Touches: #{touches}", 10, 10, 14, color(Hokusai::Color.new(244,22,22)));
-        Raylib.DrawText("Stuff: #{stuff}", 10, 24, 14, color(Hokusai::Color.new(244,22,22))) if stuff
-
-        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
-
-      self.class.images.each do |_, texture|
-        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
-        report.pretty_print(scale_bytes: true)
-      end
-
-      Raylib.CloseWindow
-
-      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?
-
-      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,
-          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
-      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::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]
-      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|
-        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
-                      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
-                      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)
-
-        active_name = Hokusai.fonts.active_font_name
-        font = Hokusai.fonts.active
-
-        Hokusai.fonts.activate command.font.nil? ? active_name : command.font
-        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
-
-        Hokusai.fonts.activate active_name
-      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.DrawRectangleRoundedLinesEx(outline_rect, command.rounding, 50, command.outline.top + 1, 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, true), vec2(ox + ow, oy, true), command.outline.top, outline_color)
-            end
-
-            if command.outline.left > 0.0
-              Raylib.DrawLineEx(vec2(ox, oy, true), vec2(ox, oy + oh, true), command.outline.left, outline_color)
-            end
-
-            if command.outline.right > 0.0
-              Raylib.DrawLineEx(vec2(ox + ow, oy, true), vec2(ox + ow, oy + oh, true), command.outline.right, outline_color)
-            end
-
-            if command.outline.bottom > 0.0
-              Raylib.DrawLineEx(vec2(ox, oy + oh, true), vec2(ox + ow, oy + oh, true), command.outline.bottom, outline_color)
-            end
-          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
-            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 "./embedded/config"
-require_relative "./embedded/font"
-require_relative "./embedded/keys"