opengl 运行白屏

Posted 2023-03-28

#include "StdAfx.h"
#include <stdlib.h>
#include <GL/glut.h>

void init(void)

glEnable(GL_DEPTH_TEST);

GLfloat position[] = 1.0, 1.0, 1.0, 0.0;
glLightfv(GL_LIGHT0, GL_POSITION, position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);

GLfloat ambient[] = 0.0, 0.0, 0.0, 1.0;
GLfloat diffuse[] = 0.25, 0.95, 0.5, 1.0;
GLfloat specular[] = 1.0, 1.0, 1.0, 1.0;
glMaterialfv(GL_FRONT, GL_AMBIENT, ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
glMaterialf(GL_FRONT, GL_SHININESS, 50.0);


void display(void)

glClearColor(0.75f, 0.75f, 0.75f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// glNewList(1, GL_COMPILE);
glutSolidTeapot(0.5);
// glEndList();
// glCallList(1);

glFlush();


void reshape(GLsizei w, GLsizei h)

glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w<=h)
glOrtho(-1.5,1.5,-1.5*(GLfloat)h/(GLfloat)w,
1.5*(GLfloat)h/(GLfloat)w,-10.0,10.0);
else
glOrtho(-1.5*(GLfloat)w/(GLfloat)h,
1.5*(GLfloat)w/(GLfloat)h,-1.5,1.5,-10.0,10.0);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity;


int main(int argc, char** argv)

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(0, 0);
glutInitWindowSize(500, 500);
glutCreateWindow(argv[0]);
init();
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMainLoop();
return 0;

参考技术A glLightfv(GL_LIGHT0, GL_POSITION, position);
只设置了灯光的位置，没有颜色之类的。加一下看看 参考技术B 把内存条用橡皮擦几下吹净即可

运行时带有加载光标的openGL GLFW白屏

【中文标题】运行时带有加载光标的openGL GLFW白屏

【英文标题】：openGL GLFW White Screen w/ Loading Cursor on run

【发布时间】：2018-04-11 16:02:45

【问题描述】：

ISSUE: 启动时，GLWindow 只显示一个白屏，并且光标显示一个加载圆圈，表示仍在加载某些内容。窗口随即显示“未响应”。

我已经尝试降级到 openGL 3.3 并且很乐意帮助解决这个问题，但问题仍然存在。

大家好，

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

我在下面分享的代码与用于着色四边形的代码略有不同，效果很好。我希望使用类似的逻辑来为圆形着色或构建一个球体并对其进行着色会出现问题。然而，我还没有到那个时候。有些东西使我的 GL 窗口无法正常显示，我希望有人可以帮助我解决我的 GLFW 和 glew 逻辑来分享窗口无法加载的原因。

注意：我已编辑此代码以包含每个步骤的 cmets，这使它看起来比实际长得多。如有任何帮助或见解，我将不胜感激。

初级班

#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++;

着色器管理器/处理程序类

#include "ShaderProgram.h"
#include <fstream>
#include <iostream>
#include <sstream>


ShaderProgram::ShaderProgram()
    : mProgram(0)



ShaderProgram::~ShaderProgram()

    glDeleteProgram(mProgram);


bool ShaderProgram::assignShaders(const char* vertFileName, const char* fragFileName)

    //Shaders output objects called programs that define their relationship and lead to .exe functionality

    //assigning pointer to the shader

        string vsString = readFile(vertFileName);
        string fsString = readFile(fragFileName);

    const GLchar* fsSourcePtr = fsString.c_str();
    const GLchar* vsSourcePtr = vsString.c_str();

    //creating vertex shader(vs) shader object
    GLuint vs = glCreateShader(GL_VERTEX_SHADER);
    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);

    //assigning shader source using address. Replaces the source code in a shader object //@arg (shader, count Strings, pointer to const File ,size)
    glShaderSource(vs, 1, &vsSourcePtr, NULL);
    glShaderSource(fs, 1, &fsSourcePtr, NULL);

    glCompileShader(vs);
    glCompileShader(fs);

    testProgramCompile();
    testShaderCompile(vs);
    testShaderCompile(fs);


    //createProgram returns GLUint which is basically an unsigned int... we will use This Handler to create a program object
    mProgram = glCreateProgram();
    if (mProgram == 0)
    
        std::cerr << "Shader cannot be created" << std::endl;
        return false;
    
    //assign the program object(mProgram) to the Shader
    glAttachShader(mProgram, vs);
    glAttachShader(mProgram, fs);

    //this method accepts a GLuint "program" . If its an object of type GL_VERTEX_SHADER,
    //itll create a .exe that runs on the programmable vertex processor. same goes for geometric and fragment shaders if they were included
    //it will also bind all user defined uniform variables and attributes to the program 
    //The program can then be made part of a defined state by calling useProgram
    glLinkProgram(mProgram);
    testProgramCompile();
    testShaderCompile(vs);
    testShaderCompile(vs);

    //cleaning up the elements we already used
    glDeleteShader(vs);
    glDeleteShader(fs);

        //clear the identifier lookup map(in this case, there's only one)
    mUniformIdentifiers.clear();

    return true;
//end main

    //Read the shaderFile. strngstream for reading multiple lines
string ShaderProgram:: readFile(const string& filename) 

    std::stringstream strgstream;
    std::ifstream file;

    try
    
        file.open(filename, std::ios::in);

        if (!file.fail())
        
            strgstream << file.rdbuf();
        

        file.close();
    
    catch (std::exception e)
    
        std::cerr << "Error: File or File Name Issues" << std::endl;
    

    return strgstream.str();

    //use the Program Object we created in this current state(color)
void ShaderProgram::use()

    if (mProgram != 0)
        glUseProgram(mProgram);


void ShaderProgram::testProgramCompile() 
    int status = 0;

    GLuint program = mProgram;

        // ///CHECKING GL_LINK_STATUS to see if Program Link was successul. Link Status will return GL_TRUE if it was
        glGetProgramiv( mProgram, GL_LINK_STATUS, &status); //requesting the status
        if (status == GL_FALSE)
        

            std::cerr << "Linking Error with Program " << std::endl;
        


void ShaderProgram :: testShaderCompile(GLuint shader) 
    int status = 0;


    // ///CHECKING GL_LINK_STATUS to see if Program Link was successul. Link Status will return GL_TRUE if it was
    glGetProgramiv(shader, GL_LINK_STATUS, &status); //requesting the status
    if (status == GL_FALSE)
    

        std::cerr << "Linking Error with Shader " << std::endl;
    


////GETTERS AND SETTERS

GLuint ShaderProgram::getProgram() const

    return mProgram;




void ShaderProgram::setUniform(const GLchar* name, const glm::vec2& v)

    GLint address = getUniformIdentifier(name);
    glUniform2f(address, v.x, v.y);


void ShaderProgram::setUniform(const GLchar* name, const glm::vec3& v)

    GLint address = getUniformIdentifier(name);
    glUniform3f(address, v.x, v.y, v.z);


void ShaderProgram:: setUniform(const GLchar* name, const glm::vec4& v) 
    GLint address = getUniformIdentifier(name);
    glUniform4f(address, v.x, v.y, v.z, v.w);


//Maybe need to switch places with setUniform
GLint ShaderProgram :: getUniformIdentifier(const GLchar* name) 

    std::map<std::string, GLint>::iterator it;
    it = mUniformIdentifiers.find(name);
    //std::map<std::string, GLint>


        // Only need to query the shader program IF it doesn't already exist.
        if (it == mUniformIdentifiers.end())
        
            // Find it and add it to the map
            mUniformIdentifiers[name] = glGetUniformLocation(mProgram, name);
        

        // Return it
        return mUniformIdentifiers[name];
    

【参考方案1】：

你的 init 函数中有这个。

while (!glfwWindowShouldClose(w))

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

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

您的代码大概挂在这里。

【讨论】：

我明白了，我应该意识到这段代码仍在运行。谢谢你。非常感激。现在我仍然需要为球体而不是四边形创建顶点。

我建议从立方体而不是球体开始。一个立方体有 8 个顶点，您可以手动写出，而一个球体将有数百个顶点，这需要 3D 建模程序和代码中的某种形式的文件加载器。

@白金95。谢谢你。我被要求创建一些导致以下圆形视图的东西。视频不到 1 分钟，但展示了我最终的最终产品应该是什么样子。 youtu.be/8Yd76VTKulo

很公平，我以为你的意思是 3D 对象有点棘手，但这可能是你可以使用基本三角生成顶点的东西。