如何在GLFW的mouse_callback函数中使用yaw变量（不通过参数或全局变量）？

Great question! The standard solution here is to use GLFW's built-in user pointer mechanism, which lets you attach custom state data directly to your GLFWwindow instance. This keeps your code clean, avoids global variables, and works perfectly with GLFW's callback requirements.

Here's a step-by-step breakdown:

1. Create a Struct to Hold Your State #

First, define a structure that encapsulates all the variables you need access to in the callback (not just yaw—you can add pitch, camera position, etc., later if needed):

#include <GLFW/glfw3.h>

struct CameraState {
    GLfloat yaw = -90.0f;
    // Add other camera-related variables here (e.g., pitch, lastX, lastY)
};

2. Attach the State to Your GLFW Window #

When initializing your window, allocate an instance of this struct and bind it to the window using glfwSetWindowUserPointer:

int main() {
    // Initialize GLFW and create your window (standard setup)
    glfwInit();
    GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Window", nullptr, nullptr);
    glfwMakeContextCurrent(window);

    // Create and initialize your camera state
    CameraState* cameraState = new CameraState();
    // Set the user pointer to point to your state struct
    glfwSetWindowUserPointer(window, cameraState);

    // Register the mouse callback (we'll define this next)
    glfwSetCursorPosCallback(window, mouse_callback);

    // ... rest of your main loop ...
}

3. Retrieve and Use the State in the Callback #

In your mouse_callback function, use glfwGetWindowUserPointer to fetch the state struct, then cast it to the correct type to access yaw:

void mouse_callback(GLFWwindow* window, double xpos, double ypos) {
    // Get the camera state from the window's user pointer
    CameraState* state = static_cast<CameraState*>(glfwGetWindowUserPointer(window));

    // Now you can modify or use state->yaw freely!
    // Example: Update yaw based on mouse movement (adjust logic to your needs)
    static double lastX = 400.0; // Initial middle of window
    double xOffset = xpos - lastX;
    lastX = xpos;

    const float sensitivity = 0.1f;
    state->yaw += xOffset * sensitivity;
}

4. Clean Up the Allocated State #

Don't forget to free the memory for your CameraState when you're done with the window to avoid leaks:

// At the end of your program, before destroying the window
CameraState* state = static_cast<CameraState*>(glfwGetWindowUserPointer(window));
delete state;

glfwDestroyWindow(window);
glfwTerminate();

Bonus: Using a C++ Class (If You're OOP-Inclined) #

If you're using C++ and want to encapsulate your camera logic in a class, you can attach the class instance as the user pointer instead of a struct. Here's a quick example:

class Camera {
public:
    GLfloat yaw = -90.0f;
    double lastX = 400.0;

    void handleMouseInput(double xpos, double ypos) {
        double xOffset = xpos - lastX;
        lastX = xpos;
        yaw += xOffset * 0.1f;
    }
};

// Static callback wrapper (required because GLFW expects a C-style function)
static void mouseCallbackWrapper(GLFWwindow* window, double xpos, double ypos) {
    Camera* camera = static_cast<Camera*>(glfwGetWindowUserPointer(window));
    camera->handleMouseInput(xpos, ypos);
}

// In main():
Camera* myCamera = new Camera();
glfwSetWindowUserPointer(window, myCamera);
glfwSetCursorPosCallback(window, mouseCallbackWrapper);

// Cleanup later: delete myCamera;

This approach is even more modular, keeping all your camera logic contained within a class instead of a plain struct.

内容的提问来源于stack exchange，提问作者Denis Tyschenko