discussion about render tree painting

[RodrigoDornelles]

I only noticed the issue when I created a more complex example, app-weather-tv, that the node tree system — introduced in version 0.0.8 as a feature similar to Godot, where the game is structured in a hierarchy of nodes — has a problem with rendering order/hierarchy. This causes components to be rendered out of order or misaligned. I implemented a temporary workaround in version 0.0.21 that fixes the issue, but it's not the most efficient solution.

0.0.8

local function event_bus(std, engine, key, a, b, c, d, e, f)
    local index = 1
    local depth = 0
    
    while index <= #buses.list do
        local application = buses.list[index]
        if engine.current ~= application then
            local node = application
            engine.current = application
            engine.offset_x = 0
            engine.offset_y = 0
            while node and depth < 100 do
                engine.offset_x = engine.offset_x + node.config.offset_x
                engine.offset_y = engine.offset_y + node.config.offset_y
                node = node.config.parent
                depth = depth + 1
            end
        end

        local ret = emit(std, application, key, a, b, c, d, e, f)
        
        if ret ~= nil then
            engine.bus_emit_ret(key, ret)
        end
        
        index = index + 1
    end
end

0.0.21

local function event_bus(std, engine, key, a, b, c, d, e, f)
    local index = 1
    local count = 0
    local depth = 0

    repeat
        index = 1
        count = 0
        depth = depth + 1
        while index <= #buses.list do
            local application = buses.list[index]
            if application.config.depth == depth then
                count = count + 1
                if engine.current ~= application then
                    local node = application
                    local safe_depth = 0
                    engine.current = application
                    engine.offset_x = 0
                    engine.offset_y = 0
                    while node and safe_depth < 100 do
                        if safe_depth > 50 then
                            error('fatal error parent three')
                        end
                        engine.offset_x = engine.offset_x + node.config.offset_x
                        engine.offset_y = engine.offset_y + node.config.offset_y
                        node = node.config.parent
                        safe_depth = safe_depth + 1
                    end
                end
        
                local ret = emit(std, application, key, a, b, c, d, e, f)
                
                if ret ~= nil then
                    engine.bus_emit_ret(key, ret)
                end
            end
            index = index + 1
        end
    until count == 0
end

doubts

The current approach seems to introduce unnecessary and ambiguous processing. It involves three nested node loops executed every frame, which is inefficient. Some aspects of the system need to be reconsidered and redesigned, as the current implementation mixes responsibilities across bus logic, rendering, and i18n.

• Should the return logic be exclusive to certain topics only?
• Should the render tree logic be restricted exclusively to the draw topic?
• Does the old logic from version 0.0.8 have the correct design but a flawed implementation?
• Should the logic from 0.0.20 be kept, but only triggered on resize or node changes using a cached flag?