thodg/exterm/lib/exterm.ex

• Show log

  Commit

• Hash : 1321585e
  Author : Thomas de Grivel
  Date : 2022-02-13T08:49:52
  

  wip font

Download

• lib/exterm.ex

• defmodule Exterm do
    @behaviour :wx_object
    use Bitwise
  
    @title 'exterm'
    @size {800, 600}
  
    def start_link(opts) do
      {_ref, _num, _type, pid} = :wx_object.start_link(__MODULE__, opts, [])
      {:ok, pid}
    end
  
    def child_spec(opts) do
      %{
        id: __MODULE__,
        start: {__MODULE__, :start_link, [opts]},
        type: :worker,
        restart: :permanent,
        shutdown: 500
      }
    end
  
    def init(config) do
      IO.inspect({&Exterm.init/1, config})
      wx = :wx.new(config)
      frame = :wxFrame.new(wx, :wx_const.wx_id_any, @title, [{:size, @size}])
      :ok = :wxWindow.connect(frame, :close_window)
      true = :wxFrame.show(frame)
      Exterm.Font.init()
      font = Exterm.Font.load()
      opts = [{:size, @size}]
      gl_attrib = [{:attribList, [:wx_const.wx_gl_rgba,
                                  :wx_const.wx_gl_doublebuffer,
                                  :wx_const.wx_gl_min_red, 8,
                                  :wx_const.wx_gl_min_green, 8,
                                  :wx_const.wx_gl_min_blue, 8,
                                  :wx_const.wx_gl_depth_size, 24, 0]}]
      canvas = :wxGLCanvas.new(frame, opts ++ gl_attrib)
      :ok = :wxGLCanvas.connect(canvas, :size)
      :ok = :wxGLCanvas.connect(canvas, :char)
      :wxWindow.reparent(canvas, frame)
      context = :wxGLContext.new(canvas)
      :wxGLCanvas.setCurrent(canvas, context)
      setup_gl(canvas)
      state = %{canvas: canvas,
                font: font,
                lines: ['$>_hello_world_!  ',
                        'plop',
                        'hop',
                        'toto toto']}
      :wx.batch(fn -> render(state) end)
      {frame, state}
    end
  
    def code_change(_, _, state) do
      {:stop, :not_implemented, state}
    end
  
    def handle_cast(msg, state) do
      IO.puts "Cast:"
      IO.inspect msg
      {:noreply, state}
    end
  
    def handle_call(msg, _from, state) do
      IO.puts "Call:"
      IO.inspect msg
      {:reply, :ok, state}
    end
  
    def handle_info(:stop, state) do
      :wxGLCanvas.destroy(state.canvas)
      {:stop, :normal, state}
    end
  
    def handle_info(:update, state) do
      :wx.batch(fn -> render(state) end)
      {:noreply, state}
    end
  
    # Example input:
    # {:wx, -2006, {:wx_ref, 35, :wxFrame, []}, [], {:wxClose, :close_window}}
    def handle_event({:wx, _, _, _, {:wxClose, :close_window}}, state) do
      {:stop, :normal, state}
    end
  
    def handle_event(x = {:wx, _, _, _, {:wxSize, :size, {width, height}, _}}, state) do
      IO.inspect(x)
      if width != 0 and height != 0 do
        resize_gl_scene(width, height)
        :wx.batch(fn -> render(state) end)
        :ok
      end
      {:noreply, state}
    end
  
    def handle_event({:wx, _, _, _, {:wxKey, :char, _, _, code, _, _, _, _, _, _, _}}, state) do
      IO.inspect([code])
      lines = if [code] == '\r' do
        [[] | state.lines]
      else
        first_line = hd(state.lines) ++ [code]
        [first_line | tl(state.lines)]
      end
      state = %{state | lines: lines}
      :wx.batch(fn -> render(state) end)
      {:noreply, state}
    end
  
    def handle_event(data, state) do
      IO.inspect({:handle_event, data, state})
      {:noreply, state}
    end
  
    def terminate(_reason, state) do
      :wxGLCanvas.destroy(state.canvas)
    end
  
    defp setup_gl(win) do
      {w, h} = :wxWindow.getClientSize(win)
      resize_gl_scene(w, h)
      #:gl.shadeModel(:gl_const.gl_smooth)
      :gl.clearColor(1.0, 1.0, 1.0, 0.0)
      #:gl.clearDepth(1.0)
      #:gl.enable(:gl_const.gl_depth_test)
      #:gl.depthFunc(:gl_const.gl_lequal)
      #:gl.hint(:gl_const.gl_perspective_correction_hint, :gl_const.gl_nicest)
      :ok
    end
  
    defp resize_gl_scene(width, height) do
      IO.inspect({:resize_gl_scene, width, height})
      width = width * 2
      height = height * 2
      :gl.viewport(0, 0, width, height)
      :gl.matrixMode(:gl_const.gl_projection)
      :gl.loadIdentity()
      :gl.ortho(0.0, width + 0.0, 0.0, height + 0.0, -1.0, 1.0)
      :gl.matrixMode(:gl_const.gl_modelview)
      :gl.loadIdentity()
      :ok
    end
  
    defp draw(font, lines) do
      IO.inspect(:draw)
      :gl.clear(:gl_const.gl_color_buffer_bit)
      :gl.loadIdentity()
      lines
      |> Enum.with_index()
      |> Enum.each(fn {line, i} ->
        :gl.pushMatrix()
        line
        |> Enum.map(fn c when is_integer(c) ->
          Exterm.Font.load_glyph(font.regular, c)
        end)
        |> :gl.callLists()
        :gl.popMatrix()
        :gl.translatef(0.0, 50.0, 0.0)
      end)
    end
  
    defp render(%{canvas: canvas, font: font, lines: lines} = _state) do
      draw(font, lines)
      :wxGLCanvas.swapBuffers(canvas)
      :ok
    end
  end
  

Download