Return to Question

found a solution but got a new problem

edited Sep 11 at 17:14

EDIT: While waiting for someone to answer me, I got a solution.

We can linearize all components in an array and then, call the Render method on them, this removes the tree structure.

pool cmps = {A, B, C, ...} FOR EACH cmp IN cmps DO: IF cmp.IsChanged() THEN: cmp.Render()

Of course, it is possible to add an observer pattern to the components to signal change

STRUCT ButtonTable /* fields */ List<T> observers Attach() Signal() ...

However, there are still few issues that I have to address.

Since the render phase occurs every once in a while, if the rendering phase causes other "children" components to change, thay can be rendered two times; thus, wasting precious cycles.

Also, how is it possible to create an API that gives an illusion of a tree-like structure when in reality is this pool-observer pattern?

Like, before we could do

new MyComponent( /* sub components */)

but with the new structure we have to do the following:

mc <- new MyComponent() mc.Attach( /* sub components */ ) main_program.Add( /* sub components */) ```

EDIT: While waiting for someone to answer me, I got a solution.

We can linearize all components in an array and then, call the Render method on them, this removes the tree structure.

pool cmps = {A, B, C, ...} FOR EACH cmp IN cmps DO: IF cmp.IsChanged() THEN: cmp.Render()

Of course, it is possible to add an observer pattern to the components to signal change

STRUCT ButtonTable /* fields */ List<T> observers Attach() Signal() ...

However, there are still few issues that I have to address.

Since the render phase occurs every once in a while, if the rendering phase causes other "children" components to change, thay can be rendered two times; thus, wasting precious cycles.

Also, how is it possible to create an API that gives an illusion of a tree-like structure when in reality is this pool-observer pattern?

Like, before we could do

new MyComponent( /* sub components */)

but with the new structure we have to do the following:

mc <- new MyComponent() mc.Attach( /* sub components */ ) main_program.Add( /* sub components */) ```

Source Link

asked Sep 11 at 16:34

Binary Series

Problem with SDL2 optimization (tree structure)

while I was trying to optimize SDL2 rendering phase as much as possible, I reached a wall. I tried to search on the internet but I could not find any solution. So, I need help.

Let me explain the problem. I will use pseudo-code for code examples since this problem is not language-dependent.

Let's imagine we have a main program that follows a tree structure like the following:

Main Handler Component A0 Component A1 ... Component B0 Component B1 ... ...

Tree structures like these are really good for code modularity since, when changes are needed, I can just swap components instead of changing the entire code.

Therefore, to render components, I have the following interface:

INTERFACE Renderer Render( /* SDL renderer */ ) -> error

And so, the main body can just do the following:

PROGRAM main() -> void MyApp <- new MyApp() renderer <- /* setup */ WHILE TRUE DO: /* Handle Events */ err <- MyApp.Render(renderer) IF err THEN: PRINT err BREAK WAIT /* delay (ms) */

The problem is that, when rendering, the main body has to traverse this huge tree for each frame; thus, slowing the entire rendering phase.

To solve this, I updated the Renderer interface to include a function that reports whether the component has changed since the last rendering step. If it did, render it, otherwise skip it.

INTERFACE Renderer IsChanged() -> bool Render( /* SDL renderer */ ) -> error

At first, this sped the rendering phase since now it can skip components that do not change or are unnecessary to draw every frame.

Still, this approach caused another issue since, at every frame, not only the main execution has to traverse this tree one time to check if any component has changed, but when changes occur, the execution has to walk up the tree until the root and then render everything.

However, this created a new problem: At every frame, not only the engine must traverse this tree one time to check if it is changed, but if it did, it has to walk back to the root and render everything.

Especially on components like this one:

STRUCT ButtonTable IMPLEMENTS Renderer List<Renderer> buttons IsChanged() -> bool /* check if this has changed */ /* check if any subcomponent has changed */ FOR EACH button IN this.buttons DO: IF button.IsChanged() THEN: RETURN TRUE RETURN FALSE Render( /* SDL renderer */ r) -> error /* render ButtonTable */ FOR EACH button IN this.buttons DO: err <- button.Render(r) IF err THEN: RETURN err RETURN NONE

I even tried to add multi-threading to speed up processes but occasionally things get rendered in a wrong order (one component before another one).

Any ideas on how to fix this?

optimization sdl2