功能未在范围(GLFW，OpenGL，Slackware)中声明

Question

我正在尝试使用Linux上的G 编译我的第一个GL简单程序：

-lxcb -dri2 -lxcb -lm -ldl -lxrender -lxRender -lxDamage -lxdamage -lx111 -xcb -lxcb -glx -dri3 -l -l -l/usr/usr/local/local/local/lim/lib -lxrandr -lxrandr -lxinerama -lxinerama -lxinerama -lxInerama -lxi -lxi -lxi -lgxcursor -lggl -lggl -lggl -lggl -lggl -lggl -lggl -lggl -lggl -lg l -lxilm xcb -present -lglfw -lxcb -sync -lxshmfence -lxxf86vm -lxfixes -lxext -lxext -lxext -lxext -lpthread -lxcb -lxcb -lxau -lxdmcp -lxdmcp -lglew -lglew

lglew

我有一个错误：

graphics/window.cpp: In member function 'bool je::graphics::Window::init()':
graphics/window.cpp:55:32: error: 'key_callback' was not declared in this scope glfwSetKeyCallback(m_Window, key_callback);

我的代码在三个文件中。

main.cpp：

#include "graphics/window.h"
int main()
{
    using namespace je;
    using namespace graphics;
    Window window("just engine", 800, 600);
    glClearColor(0.2f, 0.3f, 0.8f, 1.0f);
    GLuint vao;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    while (!window.closed())
    {
        window.clear();
        if (window.isKeyPressed(GLFW_KEY_A))
        {
            std::cout << "PRESSED!" << std::endl;
        }
        glDrawArrays(GL_ARRAY_BUFFER, 0, 6);
        window.update();
    }
    return 0;
}

window.h：

#pragma once
#include <iostream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
namespace je{ namespace graphics{
#define MAX_KEYS    1024
#define MAX_BUTTONS     32
    class Window
    {
    private:
        const char *m_Title;
        int m_Width, m_Height;
        GLFWwindow *m_Window;
        bool m_Closed;
                static bool m_Keys[MAX_KEYS];
                static bool m_MouseButtons[MAX_BUTTONS];
                static double mx, my;
    public:
        Window(const char *name, int width, int height);
        ~Window();
                void clear() const;
        void update();
                bool closed() const;
        inline int getWidth() const {return m_Width; }
        int getHeight() const {return m_Height; }
        static bool isKeyPressed(unsigned int keycode);
        //friend void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
    private:
        bool init();
        friend void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
    };
}}

window.cpp：

#include "window.h"
#include <GLFW/glfw3.h>
namespace je{ namespace graphics {

    bool Window::m_Keys[MAX_KEYS];
    bool Window::m_MouseButtons[MAX_BUTTONS];
    double Window::mx;
    double Window::my;
    void window_resize(GLFWwindow *window, int width, int height);
    Window::Window(const char *title, int width, int height)
    {
        m_Title = title;
        m_Width = width;
        m_Height = height;
        if (!init())
            glfwTerminate();

        for (int i = 0; i < MAX_KEYS; i++)
        {
            m_Keys[i] = false;
        }
        for (int i = 0; i < MAX_BUTTONS; i++)
        {
            m_MouseButtons[i] = false;
        }
    }
    Window::~Window()
    {
        glfwTerminate();
    }
    bool Window::init()
    {
            if(!glfwInit())
            {
                std::cout << "Failed to initialize GLFW" << std::endl;
            return false;
        }
        m_Window = glfwCreateWindow(m_Width, m_Height, m_Title, NULL, NULL);
        if (!m_Window)
        {
            glfwTerminate();
            std::cout << "Creating window failed." << std::endl;
            return false;
        }
        glfwMakeContextCurrent(m_Window);
        glfwSetWindowUserPointer(m_Window, this);
        glfwSetWindowSizeCallback(m_Window, window_resize);
        glfwSetKeyCallback(m_Window, key_callback);
        if (glewInit() != GLEW_OK)
        {
            std::cout << "Could not initialize GLEW!" << std::endl;
            return false;
        }
                std::cout << "OpenGL " << glGetString(GL_VERSION) << std::endl;
        return true;
    }
        bool Window::isKeyPressed(unsigned int keycode)
    {
        if (keycode >= MAX_KEYS)
            return false;
        return m_Keys[keycode];
    }

    void Window::clear() const
    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }
    void Window::update()
    {
        glfwPollEvents();
        glfwGetFramebufferSize(m_Window, &m_Width, &m_Height);
        glfwSwapBuffers(m_Window);
    }
        bool Window::closed() const
        {
                return glfwWindowShouldClose(m_Window) == 1;
        }
    void window_resize(GLFWwindow *window, int width, int height)
    {
        glViewport(0, 0, width, height);
    }
        void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
    {
        Window* win = (Window*) glfwGetWindowUserPointer(window);
        win->m_Keys[key] = action != GLFW_RELEASE;
    }
} }

我真的是初学者，我迷失了方向...您能帮我找到方法吗？谢谢。

Answer 1

使用C 成员函数void key_callback()，作为C型库库函数glfwSetKeyCallback()的参数，您应该将其声明为static，但首先在类声明之外。因此，为您的 window.h 。

class Window;
static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
class Window {
    private:
        // fields here
    public:
        // other member functions here
    private:
        friend void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
};

，然后在 window.cpp 中：

static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
    Window* win = (Window*) glfwGetWindowUserPointer(window);
    win->m_Keys[key] = action != GLFW_RELEASE;
}

我没有在这个GLFW库中写过，因此我的答案可能不足以满足您的目的。看看以下问题：指向类是类成员的函数，是否可以将朋友函数声明为静态？