Pointant vers une fonction qui est un membre de la classe - glfw setKeycallback

Il y a une syntaxe C++ pour le pointage de membre de la classe des méthodes, mais vous ne pouvez pas passer pour un C API de style. C comprend les appels de fonction et tous les non-statique méthode de l'objet, en prenant votre events comme un exemple, ressemble à cette pensée dans C conditions: void events(void* this, int, int); ce qui signifie que chaque méthode en dehors de la norme arguments obtient également un this pointeur silencieusement passé.

Pour faire de votre events C compatible faire static void events(int, int);. De cette façon, il suivra l'appel C sémantique, il ne sera pas besoin d'un this pointeur passé. Vous devez aussi vous en quelque sorte passer votre objet de ce rappel d'une autre façon (si vous avez besoin de cet objet de données dans le rappel).

J'ai aussi rencontré ce problème avec un autre glfw fonction de rappel, mais je ne voulais pas annoncer ma méthode de classe comme static, parce que j'avais besoin d'accéder aux variables membres à l'intérieur. J'ai donc essayé std::function et std::bind pour me donner la possibilité de lier une méthode d'instance que la fonction de rappel, mais malheureusement ce n'est pas une option lorsque vous travaillez avec C rappels.

La réponse à ce problème est également indiqué dans le GLFW FAQ "Comment puis-je utiliser des méthodes C++ comme des callbacks":

Vous ne pouvez pas utiliser les méthodes de rappels, comme GLFW est une bibliothèque C
et ne savent pas à propos des objets et ce pointeurs. Si vous souhaitez
recevoir des rappels à un objet C++, utiliser des méthodes ou des fonctions classiques comme les rappels, stocker le pointeur vers l'objet que vous souhaitez
appel dans un endroit accessible à partir de l'rappels et de l'utiliser pour appeler
les méthodes de l'objet.

Cependant, cela m'a encouragé à appliquer le pattern Singleton pour ma classe de rappel et de l'intégrer comme suit:

• la méthode de rappel de ma classe est toujours statique, de sorte qu'il peut être spécifié utilisé comme glfw rappel
• ce rappel statique méthode permet l'utilisation du singleton et passe le rappel des paramètres à une méthode d'instance
• cette méthode d'instance gère en fait les paramètres de rappel, avec l'avantage d'être en mesure d'accéder aux variables membres

C'est à quoi il ressemble:

//Input.h (the actual callback class for glfwSetMouseButtonCallback)
class Input 
{
public:
    static Input& getInstance() //Singleton is accessed via getInstance()
    {
        static Input instance; //lazy singleton, instantiated on first use
        return instance;
    }

    static void mouseButtonCallback(int key, int action) //this method is specified as glfw callback
    {
        //here we access the instance via the singleton pattern and forward the callback to the instance method
        getInstance().mouseButtonCallbackImpl(key, action); 
    }

    void mouseButtonCallbackImpl(int key, int action) //this is the actual implementation of the callback method
    {
        //the callback is handled in this instance method           
        //... [CODE here]
    }

private:
    Input(void) //private constructor necessary to allow only 1 instance
    {
    }

    Input(Input const&); //prevent copies
    void operator=(Input const&); //prevent assignments
};

et dans mon main.cpp:

Input &hexmap = Input::getInstance(); //initialize the singleton

//The glfw callback is set up as follows:   
glfwSetMouseButtonCallback( &Input::mouseButtonCallback); //specifying the static callback method, which internally forwards it to the instance method

Inspiré par N0vember réponse, je vous présente encore plus générique et dynamique de la solution:

class MyGlWindow {
public:
    std::function<void(MyGlWindow*)> onClose;
    std::function<void(MyGlWindow*, int, int, int)> onMouseClick = [](auto self, int, int, int) { /*some default behavior*/ };
};

void makeWindow() {
    GLFWwindow* glfwWindow;
    MyGlWindow* myWindow;

    /* ... Initialize everything here ... */

    glfwSetWindowUserPointer(glfwWindow, myWindow);

    #define genericCallback(functionName)\
        [](GLFWwindow* window, auto... args) {\
            auto pointer = static_cast<MyGlWindow*>(glfwGetWindowUserPointer(window));\
            if (pointer->functionName) pointer->functionName(pointer, args...);\
        }

    glfwSetWindowCloseCallback(glfwWindow, genericCallback(onClose));
    glfwSetMouseButtonCallback(glfwWindow, genericCallback(onMouseClick));

    myWindow->onMouseClick = [](auto self, int, int, int) {
        std::cout << "I'm such a rebel" << std::endl;
        self->onClose = [](auto self) {
            std::cout << "I'm such a rebellion" << std::endl;
        };
    };
}

C'est une discussion utile sur les solutions possibles qui m'ont aidé avec le même problème, et je vais ajouter ma solution au cas où il s'avère utile.

Énoncé Du Problème

Mon scénario est plus générale que celles adressées par BIC, L. Senionis, et N0vember. En particulier, mon cas d'utilisation nécessite:

• Généralement, de l'occurrence de données doit être accessible à la fonction de rappel
• De nombreuses applications peuvent être créées en utilisant un ensemble commun de gestionnaires de réponse
• Dans une application, un nombre quelconque de windows peut être créé
• L'ensemble de rappels attaché à chaque fenêtre doit être mélangés et assortis d'un certain bibliothèque du possible intervenants.

Proposé L'Utilisation Des Solutions

Le simple de conception singleton n'est plus de résoudre le problème. Au lieu de cela, je vais vous donner une GLFWResponder super-classe qui gère l'ensemble de l'installation de la complexité. Pour utiliser la classe et l'attacher réponse à une fenêtre, ici est ce qui est nécessaire.

//Implement custom responder
class MyResponder : public GLFWResponder {
  public:
    virtual void cursor_position_callback(GLFWwindow* w, double x, double y) {...}
    ... override relevant callbacks ...
 };

//in main ************************************************

//Assuming initialized GLFWwindow* my_window and my_other_window

MyResponder resp;
MyResponder resp2;  //Can be another subclass of GLFWResponder

//Two responders can respond to same window
resp.respond_to(my_window, GLFWResponder::CURSOR_POSITION);
resp2.respond_to(my_window, GLFWResponder::CURSOR_POSITION);

//One responder can respond to multiple windows
resp2.respond_to(my_other_window, GLFWResponder::CURSOR_POSITION);

//One window can have different handlers for different events
resp.respond_to(my_other_window, GLFWResponder::CURSOR_ENTER);

Solution Proposée De La Mise En Œuvre

Voici le sketch de la GLFWResponder mise en œuvre, pleinement fonctionnelle, mais avec quelques tâches. Il peut y avoir des implications sur la performance, dont je n'ai pas encore étudié.

//GLFWResponder.h ************************************************
/**
* Responder superclass that allows subclasses to handle events from multiple
* GLFW windows (which have only C API for callbacks).
* Callbacks are automatically cleaned up when responder goes out of scope.
*/
class GLFWResponder {
public:
virtual ~GLFWResponder();
//Interface -----------------------------------
enum GLFWEventType {
CURSOR_POSITION = 0,
CURSOR_ENTER = 1
//TODO: add support for other callbacks
};
void respond_to(GLFWwindow* window, GLFWEventType event);
bool does_respond_to(GLFWwindow* window, GLFWEventType event) const;
//Subclasses implement ------------------------
virtual void cursor_position_callback(GLFWwindow* window, double xpos, double ypos);
virtual void cursor_enter_callback(GLFWwindow* window, int entered);
//TODO: add support for other callbacks
//Under the hood ------------------------------
static std::set<GLFWResponder*> getResponders(GLFWwindow* windo, GLFWEventType event);
private:
//Windows and events that this instance responds to
std::set<std::pair<GLFWwindow*, GLFWEventType> > enabled_events_;
//Global responders keyed by events they respond to
//(each responder knows which windows it responds to)
static std::map<GLFWEventType, std::set<GLFWResponder*> > responders_;
}; 
//GLFWResponder.cpp **************************************************
namespace {
void cursor_position_callback_private(GLFWwindow* window, double xpos, double ypos) {
for (GLFWResponder* r : GLFWResponder::getResponders(window, GLFWResponder::CURSOR_POSITION)) {
r->cursor_position_callback(window, xpos, ypos);
}
}
void cursor_enter_callback_private(GLFWwindow* window, int entered) {
for (GLFWResponder* r : GLFWResponder::getResponders(window, GLFWResponder::CURSOR_ENTER)) {
r->cursor_enter_callback(window, entered);
}
}
} //namespace
std::map<GLFWResponder::GLFWEventType, std::set<GLFWResponder*> > GLFWResponder::responders_;
GLFWResponder::~GLFWResponder() {
for (auto& pr : responders_) {
pr.second.erase(this);
}
//TODO: also clean up window's callbacks
}
void GLFWResponder::respond_to(GLFWwindow* window, GLFWResponder::GLFWEventType event) {
enabled_events_.insert(std::make_pair(window, event));
responders_[event].insert(this);
if (event == CURSOR_POSITION) {
glfwSetCursorPosCallback(window, cursor_position_callback_private);
} else if (event == CURSOR_ENTER) {
glfwSetCursorEnterCallback(window, cursor_enter_callback_private);
} else {
//TODO: add support for other callbacks
LOG(FATAL) << "Unknown GLFWResponder event: " << event;
}
}
bool GLFWResponder::does_respond_to(GLFWwindow* window, GLFWEventType event) const {
return enabled_events_.find(std::make_pair(window, event)) != enabled_events_.end();
}
std::set<GLFWResponder*> GLFWResponder::getResponders(
GLFWwindow* window, GLFWEventType event) {
std::set<GLFWResponder*> result;
auto it = responders_.find(event);
if (it != responders_.end()) {
for (GLFWResponder* resp : it->second) {
if (resp->does_respond_to(window, event)) {
result.insert(resp);
}
}
}
return result;
}
void GLFWResponder::cursor_position_callback(
GLFWwindow* window, double xpos, double ypos) {
//TODO: fail with message "GLFWResponder::do_respond called on a subclass that does not implement a handler for that event"
}
void GLFWResponder::cursor_enter_callback(GLFWwindow* window, int entered) {
//TODO: fail with message "GLFWResponder::do_respond called on a subclass that does not implement a handler for that event"
}