C Glut整形功能不工作

当我尝试调整glut窗口的大小时，屏幕变为空白

以下是重塑回调函数的代码：

void Resize(int width, int height) 
{  
    CurrentWidth = width;
    CurrentHeight = height;


    glViewport(0, 0, (GLsizei)CurrentWidth, (GLsizei)CurrentHeight); 

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity(); 
    glOrtho(0, CurrentWidth, CurrentHeight, 0, NearPlane, FarPlane);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glutPostRedisplay();
}

我对opengl世界还很陌生，但据我所知，这应该是可行的

这是所有代码的总和：

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <GL/glew.h>
#include <GL/freeglut.h>
#include <gl/glut.h>

#include "Utils.h"

int LEFT = 0;
int RIGHT = 0;
int UP = 0;
int DOWN = 0;

int CurrentWidth = 800,
    CurrentHeight = 800,
    WindowHandle = 0;

float NearPlane = 1.0f,
      FarPlane = 100.0f;

float lightX,
      lightY;

void Initialize(int, char*[]);
void InitWindow(int, char*[]);
void Idle(void);
void Resize(int, int);
void KeyPressed(unsigned char, int, int);
void SpecialPressed(int, int, int);
void SpecialReleased(int, int, int);
void Update(void);
void Render(void);
void FillZBuffer(void);
void ClearAlpha(void);
void RenderLightAlpha(float);
void GeometryPass(void);
void Draw(void);

int main (int argc, char* argv[]) 
{  
    Initialize(argc, argv);

    glutMainLoop(); 

    exit(EXIT_SUCCESS);
}

void Initialize(int argc, char* argv[])
{
    InitWindow(argc, argv);

    fprintf(
        stdout,
        "INFO: OpenGL Version: %s\n",
        glGetString(GL_VERSION)
    );

    lightX = 300.0f;
    lightY = 300.0f;
}

void InitWindow(int argc, char* argv[])
{
    glutInit(&argc, argv);

    glutInitContextVersion(3, 3);
    glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE);

    glutSetOption(
        GLUT_ACTION_ON_WINDOW_CLOSE,
        GLUT_ACTION_GLUTMAINLOOP_RETURNS
    );

    glutInitWindowSize (CurrentWidth, CurrentHeight); 
    glutInitWindowPosition (100, 100);

    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_ALPHA);

    WindowHandle = glutCreateWindow ("Shadows");  

    if(WindowHandle < 1) {
        fprintf(
            stderr,
            "ERROR: Could not create a new rendering window.\n"
        );
        exit(EXIT_FAILURE);
    }

    glutDisplayFunc(Render); 
    glutReshapeFunc(Resize);
    glutIdleFunc(Idle);
    glutKeyboardFunc(KeyPressed);
    glutSpecialFunc(SpecialPressed);
    glutSpecialUpFunc(SpecialReleased);
} 

void Update()
{
    int speed = 10;
    if (LEFT)
    {
        lightX -= speed;
    }
    if (RIGHT)
    {
        lightX += speed;
    }
    if (UP)
    {
        lightY -= speed;
    }
    if (DOWN)
    {
        lightY += speed;
    }
}

void Draw()
{
    float x = 200;
    float y = 200;
    float w = 100;
    float h = 100;
    float depth = 0.0f;

    // floor
    glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
    depth = -10.0f;
    glBegin(GL_QUADS);
    {
        glVertex3f(0, 0, depth);
        glVertex3f((float)CurrentWidth, 0, depth);
        glVertex3f((float)CurrentWidth, (float)CurrentHeight, depth);
        glVertex3f(0, (float)CurrentHeight, depth);
    }
    glEnd();

    // square
    glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
    depth = -5.0;
    glBegin(GL_QUADS);
    {
        glVertex3f( x,  y, depth);
        glVertex3f( x + w, y, depth);
        glVertex3f(x + w, y + h, depth);
        glVertex3f(x,  y + h, depth);
    }
    glEnd();
}

void Render() 
{
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glDisable(GL_CULL_FACE);

    Update();

    FillZBuffer();

    ClearAlpha();

    RenderLightAlpha(1.0f);

    GeometryPass();

    glutSwapBuffers();
    glutPostRedisplay(); 
}  

void FillZBuffer()
{
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
    glDepthMask(GL_TRUE);

    Draw();

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    glDepthMask(GL_FALSE);
}

void ClearAlpha()
{
    glDisable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
    glColor4f(0.0f, 0.0f, 0.0f, 0.0f);

    glBegin (GL_QUADS);
    {
        glVertex2f(0, 0);
        glVertex2f((float)CurrentWidth, 0);
        glVertex2f((float)CurrentWidth, (float)CurrentHeight);
        glVertex2f(0, (float)CurrentHeight);
    }
    glEnd ();
}

void RenderLightAlpha(float intensity)
{
    float depth = -1.0f;  
    float radius = 300.0f;
    float angle;
    int numSubdivisions = 32;

    glDisable(GL_BLEND);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);

    glBegin(GL_TRIANGLE_FAN);
    {
        glColor4f(0.0f, 0.0f, 0.0f,  intensity);
        glVertex3f(lightX, lightY, depth);

        // Set edge colour for rest of shape
        glColor4f(0.0f, 0.0f, 0.0f, 0.0f);

        for (angle = 0; angle <= (float)PI * 2; angle += (((float)PI * 2) / numSubdivisions))
        {
            glVertex3f( radius*(float)cos(angle) + lightX, radius*(float)sin(angle) + lightY, depth);  
        }

        glVertex3f(lightX + radius, lightY, depth);
    }
    glEnd();
}

void GeometryPass()
{
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_BLEND);
    glBlendFunc(GL_DST_ALPHA, GL_ONE);

    Draw();
}

void Idle()
{
    glutPostRedisplay();
}

void Resize(int width, int height) 
{  
    CurrentWidth = width;
    CurrentHeight = height;


    glViewport(0, 0, (GLsizei)CurrentWidth, (GLsizei)CurrentHeight); 

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity(); 
    glOrtho(0, CurrentWidth, CurrentHeight, 0, NearPlane, FarPlane);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glutPostRedisplay();
}

void KeyPressed(unsigned char key, int x, int y)
{
    UNREFERENCED_PARAMETER(x);
    UNREFERENCED_PARAMETER(y);

    // escape key
    if (key == 27)
    {
        exit(0);
    }
}

void SpecialPressed(int keyCode, int x, int y)
{
    UNREFERENCED_PARAMETER(x);
    UNREFERENCED_PARAMETER(y);

    if (keyCode == GLUT_KEY_LEFT)
    {
        LEFT = 1;
    }
    else if (keyCode == GLUT_KEY_RIGHT)
    {
        RIGHT = 1;
    }
    else if (keyCode == GLUT_KEY_UP)
    {
        UP = 1;
    }
    else if (keyCode == GLUT_KEY_DOWN)
    {
        DOWN = 1;
    }
}

void SpecialReleased(int keyCode, int x, int y)
{
    UNREFERENCED_PARAMETER(x);
    UNREFERENCED_PARAMETER(y);
    if (keyCode == GLUT_KEY_LEFT)
    {
        LEFT = 0;
    }
    else if (keyCode == GLUT_KEY_RIGHT)
    {
        RIGHT = 0;
    }
    else if (keyCode == GLUT_KEY_UP)
    {
        UP = 0;
    }
    else if (keyCode == GLUT_KEY_DOWN)
    {
        DOWN = 0;
    }
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括“Utils.h”
int左=0；
int RIGHT=0；
int UP=0；
int-DOWN=0；
int CurrentWidth=800，
当前高度=800，
WindowHandle=0；
浮动近平面=1.0f，
远平面=100.0f；
浮动lightX，
轻盈的；
无效初始化（int，char*[]）；
void InitWindow（int，char*[]）；
无效空闲（void）；
无效调整大小（int，int）；
按下void键（无符号字符，int，int）；
特殊压缩的void（int，int，int）；
无效特殊删除（int，int，int）；
作废更新（作废）；
无效渲染（无效）；
无效填充缓冲（无效）；
void ClearAlpha（void）；
无效渲染灯光Alpha（浮动）；
空隙几何体（空隙）；
作废提款（作废）；
int main（int argc，char*argv[]）
{  
初始化（argc，argv）；
glutMainLoop（）；
退出（退出成功）；
}
无效初始化（int argc，char*argv[]）
{
初始化窗口（argc，argv）；
fprintf(
斯特杜特，
“信息：OpenGL版本：%s\n”，
glGetString（GLU版本）
);
lightX=300.0f；
轻盈=300.0f；
}
void InitWindow（int argc，char*argv[]）
{
glutInit（&argc，argv）；
glutInitContextVersion（3,3）；
glutInitContextProfile（GLUT_兼容性_PROFILE）；
glutSetOption(
GLUT\u操作\u打开\u窗口\u关闭，
GLUT\u操作\u GLUTMAINLOOP\u返回
);
GLUTINITWindowsSize（当前宽度、当前高度）；
位置（100100）；
glutInitDisplayMode（GLUT_DOUBLE | GLUT_RGBA | GLUT_ALPHA）；
WindowHandle=glutCreateWindow（“阴影”）；
如果（窗口句柄<1）{
fprintf(
斯特德尔，
“错误：无法创建新的渲染窗口。\n”
);
退出（退出失败）；
}
glutDisplayFunc（渲染）；
GLUTEFUNC（调整大小）；
glutIdleFunc（空闲）；
键盘功能（按键）；
glutSpecialFunc（特殊加压）；
glutSpecialUpFunc（特殊删除）；
} 
无效更新（）
{
内速度=10；
如果（左）
{
lightX-=速度；
}
如果（右）
{
lightX+=速度；
}
如果（向上）
{
轻快-=速度；
}
如果（向下）
{
轻快+=速度；
}
}
作废提款（）
{
浮点数x=200；
浮动y=200；
浮球w=100；
浮动h=100；
浮动深度=0.0f；
//地板
glColor4f（0.5f，0.5f，0.5f，1.0f）；
深度=-10.0f；
glBegin（GL_QUADS）；
{
glVertex3f（0,0，深度）；
glVertex3f（（浮动）电流宽度，0，深度）；
glVertex3f（（浮动）电流宽度，（浮动）电流高度，深度）；
glVertex3f（0，（浮动）当前高度、深度）；
}
格伦德（）；
//方格
glColor4f（1.0f、0.0f、0.0f、1.0f）；
深度=-5.0；
glBegin（GL_QUADS）；
{
glVertex3f（x，y，深度）；
glVertex3f（x+w，y，深度）；
glVertex3f（x+w，y+h，深度）；
glVertex3f（x，y+h，深度）；
}
格伦德（）；
}
void Render（）
{
glClearColor（0.0f、0.0f、0.0f、0.0f）；
glClear（GL_颜色_缓冲_位| GL_深度_缓冲_位）；
glDisable（GLU消隐面）；
更新（）；
FillZBuffer（）；
ClearAlpha（）；
RenderLightAlpha（1.0f）；
GeometryPass（）；
glutSwapBuffers（）；
再发现（）；
}  
void FillZBuffer（）
{
glEnable（GLU深度试验）；
glDepthFunc（GL_LESS）；
GLCOLORSMASK（GL_FALSE、GL_FALSE、GL_FALSE、GL_FALSE）；
glDepthMask（GL_TRUE）；
Draw（）；
GLCOLORSMASK（GL_真、GL_真、GL_真、GL_真）；
glDepthMask（GL_FALSE）；
}
void ClearAlpha（）
{
glDisable（GLU混合）；
glDisable（GLU深度测试）；
GLCOLORSMASK（GL_FALSE、GL_FALSE、GL_FALSE、GL_TRUE）；
glColor4f（0.0f，0.0f，0.0f，0.0f）；
glBegin（GL_QUADS）；
{
glVertex2f（0,0）；
glVertex2f（（浮动）电流宽度，0）；
glVertex2f（（浮动）电流宽度，（浮动）电流高度）；
glVertex2f（0，（浮动）当前高度）；
}
格伦德（）；
}
空心渲染灯光Alpha（浮动强度）
{
浮动深度=-1.0f；
浮动半径=300.0f；
浮动角；
int numSubdivisions=32；
glDisable（GLU混合）；
glEnable（GLU深度试验）；
glDepthFunc（GL_LEQUAL）；
glBegin（GLU三角形风扇）；
{
glColor4f（0.0f，0.0f，0.0f，强度）；
glVertex3f（亮度、亮度、深度）；
//为其余形状设置边缘颜色
glColor4f（0.0f，0.0f，0.0f，0.0f）；
对于FillZBuffer函数中的（angle=0；angle），深度掩码在该函数的末尾被禁用，并且仅在该函数的开头被重新启用。因此，当再次调用Render时，清除深度缓冲位的调用不会起任何作用，因为深度掩码被禁用

要解决此问题，必须在调用清除深度缓冲区位之前重新启用深度掩码

这就是渲染应该是什么样子

void Render() 
{
    glDepthMask(GL_TRUE); // insert this line
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glDisable(GL_CULL_FACE);

    Update();

    FillZBuffer();

    ClearAlpha();

    RenderLightAlpha(1.0f);

    GeometryPass();

    glutSwapBuffers();
    glutPostRedisplay(); 
} 

你为什么相信“重塑”函数与您的问题有关？为什么您对Glor的调用仅使用宽度？@Bart抱歉，它应该是CurrentHeight，我更改了它，但它仍然不起作用。@Nicol我没有说重塑问题不是问题的一部分，我只是说它应该起作用，但它不起作用。请不要将您的解决方案添加到问题中或者在标题中添加“已解决”。将您的解决方案作为答案发布，然后接受它。