C/C++ Flexible yet fast way of linking UI elements to functions

Question

I am currently working on the UI functionality of my game, which will have very minimal GUI design, yet it needs to be functional and flexible e.g. easy to redesign.

I am planning to construct all my GUI elements (buttons, sliders, knobs, checkboxes) from Quads with an optional texture and a color. These quads will also serve as boundaries for text and mouse-click detection.

But I am having trouble to figure out an efficient way of linking actual functionality to triggers like buttons. I have thought of defining a Button like this:

struct Button{
    unsigned int quadIndex; //an index into the array of quads, which themselves store indices into arrays of positions and sizes
    void (*func)(int); //a pointer to the function to be called when this button is being interacted with. the parameter of the function will be the state of the relevant mouse button
}

But this way I could only make a button call a function void func(int), which will often force me to write a wrapper function for every individual button functionality. Is this the way everybody does it or is there a better, more flexible way?

Edit: Since performance/high responsiveness is very important to me, i would like to avoid pointers, virtual functions and derived classes. I am looking for a transparent, concrete solution which focusses on the minimal data which has to come in play for a functional and flexible solution

Answer 1

First off, your part about avoiding pointers and virtual functions due to responsiveness of button clicks is terribly misguided - you listened to someone you should not have listened to. If we're discussing pointers for performance, we're talking nanoseconds (worst case of 65 ns, according to one source), and if you want to react fast enough to a button click to be seen as responsive, you have 100'000'000 of these nanoseconds to spend as you please.

That said, you're either looking at virtual functions (likely in combination with std::unique_ptr), at std::function, or if you're on an old C++ version at boost::function. All of these allow you to store any number of additional arguments, and also allow correct lifetime management of resources by their destructors. Done properly, std::function with lambdas should be the cleanest code to read, but an implementation with virtual functions will be easier to debug.

Answer 2

What C++ standard are you writing against? C++ 11 Introduced support for Lambdas, which are basically unnamed functions that can "capture" variables.

So you could just define a Lambda instead of your function and then write whatever function you actually want to call in there. You're still creating the function adapters, but since you can write them in-line it's much more compact:

myButton.func = [someExternalVariable](int idx){ doMagic( buttons[idx], someExternalVariable, 42 ); };

Answer 3

Create a ButtonBehaviour abstract class with a virtual execute(Button& b)

Then your button can have several behaviours:

class Button
{
public:
    void parseMouse(Mouse& m){
        if(isInside(m.pos)) {
            if(m.clicked) {
              m_on_click->execute(*this);
            }
            else {
                if (!m_mouse_inside) {
                    m_mouse_inside = true;
                    m_mouse_enter->execute(*this);
                }
            }
            else {
                if (m_mouse_inside) {
                   m_mouse_inside = false;
                   m_mouse_leave->execute(*this);
                }
            }
        }

    }
private:
    ButtonBehaviour* m_on_mouse_enter;
    ButtonBehaviour* m_on_mouse_leave;
    ButtonBehaviour* m_on_click;
    bool m_mouseinside;
};

The mouse then calls the appropriate one depending on the mouse state.

In such a way the ButtonBehaviour concrete classes can do whatever you want: call other, wrapped up functions, or interact with other modules in your code directly.

Answer 4

You could use templates and hide the function type under an interface:

class ICallback
{
public:
    virtual void Execute() = 0;
protected:
private:
}

template <typename T> ButtonCallback : public ICallback
{
public:
    ButtonCallback(T c_) : c(c_) {}

    void Execute() override
    {
        c();
    }
protected:
private:
    const T c;
}

class Button
{
public:
    Button() 
    {
        clickCallback = new ButtonCallback(/* any function pointer/std::function here. */);
    }
private:
    ICallback* clickCallback;
}

All variables to callbacks need to be of the type ICallback, which means that you need to "double" any interface you want with the callbacks there.

Answer 5

Make Button an abstract class with a virtual function click.

Then create a derived class for each button which implements click by doing what the button is supposed to do on a click-event.

Answer 6

You can turn things around by looping over your gui every frame and doing

if(button(quadIndex)){
    // handle click
}

where button(int) will look up the quad and see if the player clicked in that area. At the same time it will also schedule it to be drawn.

For checkboxes you pass a pointer to a bool that represents the state

if(checkBox(quadIndex, &selected)){
    // handle that selected changed
}

if(selected){
    //...
}

This pattern is sometimes called an immediate mode GUI.