C++ openGL GLFW白色屏幕，运行时加载光标

问题：启动时，GLWindow仅显示一个白色屏幕，光标显示一个加载圆圈，表示仍在加载某些内容。此后不久，窗口将显示“无响应”

我曾尝试降级到openGL 3.3，并使用了“乐于助人”，但问题依然存在

大家好,

我一直在使用顶点着色器创建具有交替颜色的球体

我在下面分享的代码与用于为四边形着色的代码略有不同，后者工作得很好。我预计，使用类似的逻辑来着色一个圆，或构建一个球体并着色该圆，会出现一些问题。然而，我还没有到那一步。我的GL窗口无法正常显示，我希望有人能帮助我使用GLFW和glew逻辑，分享窗口无法加载的原因

注意：我已经编辑了这段代码，为每个步骤添加了注释，这使得它看起来比实际更长。如果有任何帮助或见解，我将不胜感激

小学

#include <iostream>
#include <sstream>
#define GLEW_STATIC
    //always GLEW before GLFW
#include "GL/glew.h"    
#include "GLFW/glfw3.h"
#include "glm/glm.hpp"

#include "ShaderProgram.h"

#ifndef M_PI
# define M_PI 3.141592653
#endif


/////gLOBAL
GLFWwindow* w = NULL;
const int wWidth = 800;
const int wHeight = 600;

void key_callback(GLFWwindow *w, int key, int scancode, int action, int mode);
//update colors based on average framerate
void averageFPS(GLFWwindow* window);
//screen resizing
void glfw_onFramebufferSize(GLFWwindow* window, int width, int height);
bool initOpenGL();


static void error(int error, const char *desc)
{
    fputs(desc, stderr);
}
//setting up values for keys


int main() {

    if (!initOpenGL())  ///5IMPR
    {
        // An error occured
        std::cerr << "GLFW not initialized" << std::endl;
        return -1;
    }

    glfwSetErrorCallback(error);


    GLfloat vertices[] = {
        -0.5f,  0.5f, 0.0f,     
        0.5f,  0.5f, 0.0f,      
        -0.5f, 1.0f, 0.0f       
    };

    GLuint indices[] = {
        0, 1, 2,  
        0, 2, 3   
    };

    // 2. Set up buffers on the GPU
    GLuint vbo, ibo, vao;                       

    glGenBuffers(1, &vbo);                  // Generate an empty vertex buffer on the GPU
    glBindBuffer(GL_ARRAY_BUFFER, vbo);     // "bind" or set as the current buffer we are working with
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);  // copy the data from CPU to GPU

    glGenVertexArrays(1, &vao);             // Tell OpenGL to create new Vertex Array Object
    glBindVertexArray(vao);                 // Make it the current one
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);   // Define a layout for the first vertex buffer "0"
    glEnableVertexAttribArray(0);           // Enable the first attribute or attribute "0"

                                            // Set up index buffer
    glGenBuffers(1, &ibo);  // Create buffer space on the GPU for the index buffer
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    glBindVertexArray(0);                   // unbind to make sure other code doesn't change it

    ShaderProgram shaderProgram;        
    shaderProgram.assignShaders("shaders/ColorShader.vert", "shaders/ColorShader.frag"); 

            ////////SETUP RENDERING
    while (!glfwWindowShouldClose(w))
    {
        averageFPS(w);

            //process events
        glfwPollEvents();           

            // Clear the screen
        glClear(GL_COLOR_BUFFER_BIT);   

        shaderProgram.use();    

        GLfloat time = (GLfloat)glfwGetTime();          
        GLfloat blueSetting = (sin(time) / 2) + 0.5f;       
        glm::vec2 pos;
        pos.x = sin(time) / 2;
        pos.y = cos(time) / 2;
        shaderProgram.setUniform("vertColor", glm::vec4(0.0f, 0.0f, blueSetting, 1.0f));    
        shaderProgram.setUniform("posOffset", pos);

            /////COLOR OF CIRCLE OUTLINE
        //glColor4f(0.0, 0.0, 1.0, 1.0); //RGBA

            //PRIMARY BODY
                    // Draw our line
        glBegin(GL_LINE_LOOP);

        //glColor3f(0,0,1);


        static double iteration = 0;
        // The x, y offset onto the screen -- this should later be centered
        static const int offset = 150;

        static const float radius = 50;


        // Calculate our x, y cooredinates
        double x1 = offset + radius + 100 * cos(1);
        double y1 = offset + radius + 100 * sin(1);
        static double wobble = 0.0;


        // A = (π * r²)
        double a = M_PI * (100 * 2);    //area
                                        // C = (2 * π * r)
        double c = 2 * M_PI * 100;  //circumference

        static double b = 128;

        for (double i = 0; i < 2 * M_PI; i = i + ((2 * M_PI) / b))
        {
            double x = x1 + radius * cos(i);

            double y = y1 + radius * sin(i);

            glVertex2f(x, y);

            glVertex2f(x, y);
        }

        iteration += 0.01;

        ////PRIMARY BODY End

        glBindVertexArray(vao);

        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
            //glDrawElements(GL_LINE_LOOP, 6, GL_UNSIGNED_INT, 0);
        glBindVertexArray(0);
        // Swap buffers and look for events

        glfwSwapBuffers(w);


    }
        //clean up
    glDeleteVertexArrays(1, &vao);
    glDeleteBuffers(1, &vbo);
    glDeleteBuffers(1, &ibo);

    //glfwDestroyWindow(w);
    glfwTerminate();

    return 0;
    }


            ///////START Initializing glfw glew etc
bool initOpenGL(){

    //this method will exit on these conditions
    GLuint error = glfwInit();
    if (!error)
        return false;

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);


    w = glfwCreateWindow(wWidth, wHeight, "Exercise", NULL, NULL);

    //Filling  Window

    if (w== NULL)
    {
        std::cerr << "glfw window not created" << std::endl;
        glfwTerminate();
        return false;
    }

        //update context
    glfwMakeContextCurrent(w);

    // Initialize GLEWunifor
    glewExperimental = GL_TRUE;
    GLuint err = glewInit();
    if (err != GLEW_OK)
    {
        std::cerr << "initialize GLEW Failed" << std::endl;
        return false;
    }

        //setup key callbacks
    glfwSetKeyCallback(w, key_callback);
    glfwSetFramebufferSizeCallback(w, glfw_onFramebufferSize);

    while (!glfwWindowShouldClose(w))
    {
        //int width, height;
    //  glfwGetFramebufferSize(w, &width, &height); //move out of while??

        // glViewport(0, 0, width, height); //remove??
    }
    glClearColor(0.23f, 0.38f, 0.47f, 1.0f);    ///5ADD

                                                // Define the viewport dimensions
    glViewport(0, 0, wWidth, wHeight);  //necessary?

    return true;

}

void key_callback(GLFWwindow *w, int key, int scancode, int action, int mode)
{
    // See http://www.glfw.org/docs/latest/group__keys.html
    if ((key == GLFW_KEY_ESCAPE || key == GLFW_KEY_Q) && action == GLFW_PRESS)
        glfwSetWindowShouldClose(w, GL_TRUE);

    if (key == GLFW_KEY_W && action == GLFW_PRESS)
    {
        bool showWires = false;
        if (showWires)
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        else
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    }

}

    //whever window resizes, do this
void glfw_onFramebufferSize(GLFWwindow* window, int width, int height)
{
    glViewport(0, 0, width, height);
}

void averageFPS(GLFWwindow* window) ///5ADDdown
{
    static double previousSeconds = 0.0;
    static int frameCount = 0;
    double passedSeconds;
    double currentSeconds = glfwGetTime(); //seconds since GLFW started

    passedSeconds = currentSeconds - previousSeconds;

    // Limit time updates to 4 times per second
    if (passedSeconds > 0.25)
    {
        previousSeconds = currentSeconds;
        double fps = (double)frameCount / passedSeconds;
    //  double frameInMilSecs = 1000.0 / fps;
         frameCount = 0;} 
    frameCount++;
}

#包括
#包括
#定义GLEW_静态
//总是在GLFW之前GLEW
#包括“GL/glew.h”
#包括“GLFW/glfw3.h”
#包括“glm/glm.hpp”
#包括“ShaderProgram.h”
#伊夫德夫·穆皮
#定义M_PI 3.141592653
#恩迪夫
/////全球的
GLFWwindow*w=NULL；
常数int wWidth=800；
常数int wHeight=600；
void key_回调（GLFWwindow*w，int key，int scancode，int action，int mode）；
//基于平均帧率更新颜色
无效平均FPS（GLFWwindow*window）；
//屏幕大小调整
void glfw_onFramebufferSize（GLFWwindow*窗口，整数宽度，整数高度）；
bool initOpenGL（）；
静态无效错误（整数错误，常量字符*desc）
{
FPUT（描述、标准）；
}
//设置键的值
int main（）{
如果（！initOpenGL（））///5IMPR
{
//发生了一个错误
std:：cerr在init函数中有这个

while (!glfwWindowShouldClose(w))
{
    //int width, height;
//  glfwGetFramebufferSize(w, &width, &height); //move out of while??

    // glViewport(0, 0, width, height); //remove??
}

您的代码可能挂在这里。
我明白了，我应该意识到此代码仍在运行。谢谢。非常感谢。现在我仍然需要创建球体的顶点，而不是四边形。我建议从立方体开始，而不是从球体开始。立方体有8个顶点，您可以手动写出，而球体将有8个顶点“我有数百个顶点，这些顶点需要一个3d建模程序来制作，在代码中需要某种形式的文件加载器。@platinum95。谢谢。我被要求创建一些可以产生以下圆形视图的东西。视频不到1分钟，但显示了我最终的产品应该是什么样子。很公平，我认为你指的是3d ob。”有点棘手的对象，但这可能是您可以使用基本trig生成顶点的东西。
while (!glfwWindowShouldClose(w))
{
    //int width, height;
//  glfwGetFramebufferSize(w, &width, &height); //move out of while??

    // glViewport(0, 0, width, height); //remove??
}