discussão sobre interface interna do event loop.

[RodrigoDornelles]

Problema

Depois de mais uma refatoração no eventloop da engine, percebi que a solução que estava tentando implementar não é tão adequada a todos aos cores ginga e native, assim vou voltar atrás na alteração das interfaces. mas manter parte do trabalho. mas ainda não estou 100% satisfeito, pois mecanismos internos não estão encapsulados e também o objeto application está sobrecarregado de responsabilidades que não o pertence, isso também impacta a trabalhar com launchers de games.

Alteração b8d5c15

foi pensado na seguinte alteração, onde o objeto root além de std, game e application também possua event e internal.

 local try_install = function()
-    module.install(self.std, self.game, self.application, custom, module_name)
+    module.install(self.root, custom, module_name)
 end

apartir de agora a table event conteria eventos para modulos terem independencia em escrever suas callbacks e manipular o comportamento da engine.

self.event.loop[#event.loop + 1] = function(dt)
    self.game.dt = dt * 1000
    self.game.milis = love.timer.getTime() * 1000
    self.game.fps = love.timer.getFPS()
    self.application.callbacks.loop(self.std, self.game)
end

como ficaria a interligação do backend love2d com a própria engine.

if love and not love.update then
  love.update = function(dt)
      local index = 1
      while index <= #self.event.loop do
          self.event.loop[index](dt)
          index = index + 1
      end
  end
end

débitos

native

não vejo problema nessa manipulação da global event.update do love, pois é um software de terceiro e uma camada de adptação, mas por exemplo eu fazer isso com o core native native_callback_loop está fora de questão, pois seria uma adptação em cima do próprio software, algo que deveria ser resolvido de outra forma.

function native_callback_loop(dt)
  -- how implement this ??
end

como event e internal foram criados internamente de zeebo_module como passar para fora, alias cria-los por fora começa a deixar um design feio de código.

function native_callback_init(width, height, game_lua)
    application = zeebo_module.loadgame(game_lua)
    zeebo_module.require(std, game, application)
        :package('@math', engine_math)
        :package('math', engine_math.clib)
        :run()
end

além de que também no core native não a necessidade de adicionar modulos de sistema como @draw e @loop indiretamente, pois a implementação é simples e eficaz

function native_callback_loop(milis)
    game.milis = milis
    application.callbacks.loop(std, game)
    return game.dt
end

function native_callback_draw()
    native_draw_start()
    application.callbacks.draw(std, game)
    native_draw_flush()
end

ginga

em ginga teria que trabalhar com event.register e event.timer porém, além do nome event já conflitar com a própria interface do ginga, como que seria exposto o mesmo objeto de maneira limpa?

local function main()
  application = zeebo_module.loadgame(game_lua)  
  zeebo_module.require(std, game, application)
        :package('@math', engine_math)
        :package('math', engine_math.clib)
        :run()

  event.register(event_loop)
  event.timer(1, fixed_loop)
end

local function fixed_loop()
    local delay = internal.fps_controler(event.uptime())

    do
        local index = 1
        while index <= #engine_event.loop do
            engine_event.loop[index]()
            index = index + 1
        end
    end

    do
        local index = 1
        canvas:clear()
        while index <= #engine_event.draw do
            engine_event.draw[index]()
            index = index + 1
        end
        canvas:flush()
    end

  event.timer(delay, fixed_loop)
end

tentativas de soluções

criar o metodo :register em zeebo_module

podendo ter um nome melhor, foi uma solução que pensei que se encaixaria perfeitamente tanto no ginga quanto no love, mas ainda não consegui pensar em uma maneira que ficase bom para o core native.

zeebo_module.require(std, game, application)
    :package('@draw', engine_draw)
    :register('draw', register_draw)
    :run()

love2d

local function register_draw(self, func)
    love.update = func
end

ginga

--! @c :register('loop,draw',register_loop_and_draw)
local function register_loop_and_draw(self, func)
    local tick = function()
        local delay = self.internal.fps_controler(event.uptime())
        func()
        event.timer(delay, tick)
    end
end

instanciar event e internal como globais.

sem muito mistério, é uma solução feia mas resolve o problema.

local internal = nil
local engine_event = nil
local application = nil
local game = require('src/lib/object/game')
local std = require('src/lib/object/std')

o que me parece mais sujo, é que além de .require ficar sobrecarregado de parametros. parece perder a relação de interface para :package

zeebo_module.require(std, game, application internal, event)
    :package('@draw', engine_draw)
    :run()

native

function native_callback_loop()
    application.callbacks.loop(std, game)

    local index = 1
    while index <= #self.event.loop do
        self.event.loop[index](dt)
        index = index + 1
    end
end

[RodrigoDornelles]

depois de muito pensar, tenho uma idéia de uma solução para event mas ainda não para internal o retorno do modulo pode sempre vir com {event={loop=function()}} ou o que precisar, isso é tanto útil para escrever testes unitários mas posso usar também na implementação. em register, fazer funções de alta ordem. que eu possa filtrar eventos e gerar funções que chamem por todos os eventos.

zeebo_module.require(std, game, application)
    :package('@draw', engine_draw)
    :register(register_events)
    :run()

love

local function register_events(std, game, aplication, func)
    love.update = func('loop')
    love.draw = func('draw')
end

native

local event = {}

function native_callback_loop()
   application.callbacks.loop(std, game)
   event.loop()
end

local function register_events(func)
    event.loop = func('loop')
    event.draw = func('draw')
end

ginga

local function register_fixed_loop(std, game, application, func)
    local loop = func('loop')
    local draw = func('draw')

    local tick = function()
        local delay = application.internal.fps_controler(event.uptime())
        loop()
        draw()
        event.timer(delay, tick)
    end

    event.timer(1, tick)
end

local function register_event_loop(std, game, application, func)
    event.register(func('ginga'))
end