c++ - gluPerspective 和 glOrtho 都没有任何效果-6ren

c++ - gluPerspective 和 glOrtho 都没有任何效果

转载作者：行者123 更新时间：2023-11-28 00:45:55

编辑........ 所以我已经摆脱了所有的废话，现在只有一个 SSCE(希望我明白现在是什么)。对于还没有看到这个问题的人，我想在调整大小时保持纵横比，但窗口的行为就好像我已经注释掉了与调整大小时有关的任何事情(它会拉伸(stretch))。我已经检查了沿所有点的投影矩阵，它会在您期望的点发生变化，并在您期望的点保持不变。

我去掉了依赖于其他文件的东西，所以它应该为你编译，除了着色器文件，我也会发布它们的代码(它们很短)。很抱歉，它看起来格式不太好，很难保持格式必须在大多数行前面放置 4 个空格。

顺便说一句，电线立方体并没有出现。但是当逐字复制我的第一个回答者的建议并进行编译时，它确实出现了。不确定这是否与我的问题有关。

#define GLEW_STATIC

#include "glew.h"
#include "glut.h"
#include <Windows.h>
#include <iostream>
//#include "TgaParser.h"
//#include "Vertex.h"
//#include "ObjParser.h"
//#include "Car.h"
//#include "Floor.h"
//#include "BitmapParser.h"
using namespace std;
#pragma comment(lib,"winmm.lib")
#pragma comment(lib,"glut32.lib")
#pragma comment(lib, "glew32s.lib")

/*GLOBALS*/
int g_ScreenWidth       = 800;
int g_ScreenHeight      = 800;
int g_Program           = 0;
int g_PositionHandle    = 0;
int g_TextureCoordhandle = 0;
int g_ModelMatrixHandle = 0;

//Car* g_pCar = 0;
//Floor* g_pFloor = 0;

void error(char * error)
{
    printf(error);
    system("pause");
    exit(0);
}

static void checkGlError(const char* op) 
{
    for (GLint error = glGetError(); error; error
        = glGetError()) 
    {
        const GLubyte* sError = gluErrorString(error);
        printf("Shader error %s\n",sError);
    }
}

GLuint loadShader(GLenum shaderType, const char* pSource) 
{
    GLuint shader = glCreateShader(shaderType);
    if (shader) 
    {
        glShaderSource(shader, 1, &pSource, NULL);
        glCompileShader(shader);
        GLint compiled = 0;
        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
        checkGlError("createVertexShader");
        if (!compiled) 
        {
            GLint infoLen = 0;
            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
            if (infoLen) 
            {
                char* buf = (char*) malloc(infoLen);
                if (buf) 
                {
                    glGetShaderInfoLog(shader, infoLen, NULL, buf);
                    printf(buf);
                    free(buf);
                }
                glDeleteShader(shader);
                shader = 0;
            }
        }
    }
    return shader;
}

GLuint createProgram(const char* pVertexSource, const char* pFragmentSource) 
{
    GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
    checkGlError("createVertexShader");
    if (!vertexShader) 
    {
        return 0;
    }

    GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
    if (!pixelShader) 
    {
        return 0;
    }

    GLuint program = glCreateProgram();
    g_Program=program;
    if (program) 
    {
        glAttachShader(program, vertexShader);
        checkGlError("glAttachShader");
        glAttachShader(program, pixelShader);
        checkGlError("glAttachShader");
        glLinkProgram(program);
        GLint linkStatus = GL_FALSE;
        glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
        if (linkStatus != GL_TRUE) 
        {
            GLint bufLength = 0;
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
            if (bufLength) 
            {
                char* buf = (char*) malloc(bufLength);
                if (buf) 
                {
                    glGetProgramInfoLog(program, bufLength, NULL, buf);
                    free(buf);
                }
            }
            glDeleteProgram(program);
            program = 0;
        }
    }
    return program;
}

void forward_display()
{
    glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60, (GLfloat)g_ScreenWidth/(GLfloat)g_ScreenHeight, 0.1, 100);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    //gluLookAt(0, -0.5, 1, 0, 0, -1, 0, 1, 0);

    //glPushMatrix ();
    //glRotatef(timeGetTime()*0.05,0,1,0);
    //g_pCar->Draw(g_ModelMatrixHandle, g_PositionHandle, g_TextureCoordhandle);
    //glPopMatrix ();
    glTranslatef(0, 0, -2);
    glColor3f(1,0,0);
    glRotatef( 45, 1, 1, 0 );
    glutWireCube(1);


    glutSwapBuffers();
}

void forward_animate()
{
    forward_display();
}

/*Reads in all of the data contents automatically allocating memory for the content*/
char* readFileData (char * fileName)
{
    FILE *fp = fopen(fileName,"r"); 
    if (fp==0)
    {
        error("Why is all rum gone!!\n");
        return 0;
    }
    fseek(fp, 0L, SEEK_END);
    int sz = ftell(fp);
    fseek(fp, 0L, SEEK_SET);
    char * data = new char[sz+1];
    memset(data,0,sz+1);
    fread(data,1,sz,fp);
    fclose(fp);
    return data;
}

void init()
{
    char  * vertexShaderBuffer = readFileData("../resources/shaders/IntroToShaders.vs");
    char  * pixelShaderBuffer  = readFileData("../resources/shaders/IntroToShaders.ps");

    g_Program = createProgram (vertexShaderBuffer, pixelShaderBuffer);

    //We have finished  compiling the shader now delete the char arrays with the source code
    delete [] vertexShaderBuffer;
    delete [] pixelShaderBuffer;

    g_PositionHandle        = glGetAttribLocation(g_Program, "vPosition");
    g_TextureCoordhandle    = glGetAttribLocation(g_Program, "vTextureCoord");
    g_ModelMatrixHandle     = glGetUniformLocation(g_Program, "modelview_matrix");

    if (g_PositionHandle == -1)
    {
        printf("g_PositionHandle is bad\n");
    }

    if (g_TextureCoordhandle == -1)
    {
        printf("g_TextureCoordhandle is bad\n");
    }

    if (g_ModelMatrixHandle == -1)
    {
        printf("g_ModelMatrixHandle is bad\n");
    }
    glUseProgram(g_Program);


    //g_pCar = new Car();
    //g_pCar->Initialise ();
    //g_pFloor = new Floor ();
    //g_pFloor->Initialise ();

    //g_pCar->InitTextures();
    //g_pFloor->InitTextures ();

    //g_pCar->LoadTextures ();
    //g_pFloor->LoadTextures ();

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glEnable (GL_BLEND);
    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

void reshape(int w, int h)
{
    g_ScreenWidth = w;
    g_ScreenHeight = h;
    glViewport(0, 0, w, h);
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    glutInitWindowSize(g_ScreenWidth, g_ScreenHeight);
    glutCreateWindow("Assignment 1");
    glewInit();

    init ();

    glutDisplayFunc(forward_display);
    glutIdleFunc(forward_animate);
    glutReshapeFunc(reshape);

    glutMainLoop();
    /*
    DONT DO THINGS HERE
    */
    return 0;
}

IntroToShaders.ps:

varying  vec2 vTexCoord; 
uniform sampler2D myTexture;
void main (void)  
{  
   gl_FragColor =  texture2D(myTexture, vTexCoord);     
}

IntroToShaders.vs:

attribute vec3 vPosition;
attribute vec2 vTextureCoord;
varying  vec2 vTexCoord; 
uniform  mat4 modelview_matrix;

void main(void)  
{     
   vTexCoord =  vTextureCoord;
   gl_Position =  modelview_matrix*vec4(vPosition,1.0);
}

最佳答案

如果没有 glutInit() 调用，我不完全确定您希望完成什么。

试试这个:

#include <GL/glut.h>

void forward_display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    double w = glutGet( GLUT_WINDOW_WIDTH );
    double h = glutGet( GLUT_WINDOW_HEIGHT );
    gluPerspective(60, w / h, 0.1, 100);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef( 0, 0, -2 );

    glColor3ub(255, 0, 0);
    glRotatef( 45, 1, 1, 0 );
    glutWireCube( 1 );

    glutSwapBuffers();
}

int main(int argc, char **argv)
{
    glutInit( &argc, argv );
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    glutInitWindowSize(800, 800);
    glutCreateWindow("Intro to shading");

    glutDisplayFunc(forward_display);
    glutMainLoop();
    return 0;
}

编辑:给定代码(截至撰写本文时)the most recent revision ，试一试:

#include <GL/glew.h>
#include <GL/glut.h>
#include <cstdio>

/*GLOBALS*/
int g_Program = 0;
int g_ProjectionMatrixHandle = 0;
int g_ModelMatrixHandle = 0;

static void checkGlError(const char* op) 
{
    for (GLint error = glGetError(); error; error
        = glGetError()) 
    {
        const GLubyte* sError = gluErrorString(error);
        printf("Shader error %s\n",sError);
    }
}

GLuint loadShader(GLenum shaderType, const char* pSource) 
{
    GLuint shader = glCreateShader(shaderType);
    if (shader) 
    {
        glShaderSource(shader, 1, &pSource, NULL);
        glCompileShader(shader);
        GLint compiled = 0;
        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
        checkGlError("createVertexShader");
        if (!compiled) 
        {
            GLint infoLen = 0;
            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
            if (infoLen) 
            {
                char* buf = (char*) malloc(infoLen);
                if (buf) 
                {
                    glGetShaderInfoLog(shader, infoLen, NULL, buf);
                    printf(buf);
                    free(buf);
                }
                glDeleteShader(shader);
                shader = 0;
            }
        }
    }
    return shader;
}

GLuint createProgram(const char* pVertexSource, const char* pFragmentSource) 
{
    GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
    checkGlError("createVertexShader");
    if (!vertexShader) 
    {
        return 0;
    }

    GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
    if (!pixelShader) 
    {
        return 0;
    }

    GLuint program = glCreateProgram();
    g_Program=program;
    if (program) 
    {
        glAttachShader(program, vertexShader);
        checkGlError("glAttachShader");
        glAttachShader(program, pixelShader);
        checkGlError("glAttachShader");
        glLinkProgram(program);
        GLint linkStatus = GL_FALSE;
        glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
        if (linkStatus != GL_TRUE) 
        {
            GLint bufLength = 0;
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
            if (bufLength) 
            {
                char* buf = (char*) malloc(bufLength);
                if (buf) 
                {
                    glGetProgramInfoLog(program, bufLength, NULL, buf);
                    free(buf);
                }
            }
            glDeleteProgram(program);
            program = 0;
        }
    }
    return program;
}

void forward_display()
{
    glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    double w = glutGet( GLUT_WINDOW_WIDTH );
    double h = glutGet( GLUT_WINDOW_HEIGHT );
    gluPerspective(60, w / h, 0.1, 100);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0, 0, -2);

    glColor3f(1,0,0);
    glRotatef( 45, 1, 1, 0 );

    GLfloat projection[16];
    glGetFloatv( GL_PROJECTION_MATRIX, projection );
    glUniformMatrix4fv( g_ProjectionMatrixHandle, 1, GL_FALSE, projection );

    GLfloat modelview[16];
    glGetFloatv( GL_MODELVIEW_MATRIX, modelview );
    glUniformMatrix4fv( g_ModelMatrixHandle, 1, GL_FALSE, modelview );

    glutWireCube(1);

    glutSwapBuffers();
}

void forward_timer( int extra )
{
    glutTimerFunc( 16, forward_timer, 0 );
    glutPostRedisplay();
}

#define GLSL(version, shader) "#version " #version "\n" #shader

const char * vertexShaderBuffer = GLSL
(
    120,
    uniform mat4 projection_matrix;
    uniform mat4 modelview_matrix;

    varying vec4 vColor; 

    void main(void)  
    {
        vColor = gl_Color;
        gl_Position = projection_matrix * modelview_matrix * gl_Vertex;
    }
);

const char * pixelShaderBuffer = GLSL
(
    120,
    varying vec4 vColor; 
    void main (void)  
    {  
        gl_FragColor = vColor;
    }
);

void init()
{
    g_Program = createProgram (vertexShaderBuffer, pixelShaderBuffer);
    glUseProgram(g_Program);

    g_ProjectionMatrixHandle = glGetUniformLocation(g_Program, "projection_matrix");
    if (g_ProjectionMatrixHandle == -1)
    {
        printf("g_ProjectionMatrixHandle is bad\n");
    }

    g_ModelMatrixHandle = glGetUniformLocation(g_Program, "modelview_matrix");
    if (g_ModelMatrixHandle == -1)
    {
        printf("g_ModelMatrixHandle is bad\n");
    }

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glEnable (GL_BLEND);
    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    glutInitWindowSize(800, 800);
    glutCreateWindow("Assignment 1");
    glewInit();

    init ();

    glutDisplayFunc(forward_display);
    glutTimerFunc( 0, forward_timer, 0 );

    glutMainLoop();
    return 0;
}

关于c++ - gluPerspective 和 glOrtho 都没有任何效果，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/16238706/

文章推荐： Javascript:如何在滚动时更改 div 内的图像？

文章推荐： html - Bootstrap 导航栏粘性

文章推荐： html - 如何将显示 :flex? 的图像相互叠加

c - gluPerspective 看不到绘图中的所有对象
我创建了一个 5 面盒子，并在其中放入一个球，并让它在盒子内弹跳。我使用 glOrtho 创建了这个。我想为我的类(class)创建一个 3d 打砖 block 风格的游戏，所以我想把我的相机放进盒
c++ - gluPerspective 不工作
我用gluPerspective主要是增加绘制距离，但是好像不行。这是它在我的代码中的显示方式: gluPerspective(0, 70/70, 0, 4333); ratio:窗口的Width和
c++ - 如何只使用一次 gluPerspective？
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set viewpoint glMatrixMode(GL_PROJECTION); glLoa
c++ - 使用 gluPerspective()
我正在学习 OpenGL；我设法制作了我的第一个 2D 程序，但我仍然坚持使用 gluPerspective。我正在尝试一个小测试，试图掌握如何制作 3D 项目，但我似乎无法弄清楚我缺少什么以及使这
opengl - gluPerspective 与 gluOrtho2D
我查看了 MSDN 上关于这两个函数的文档。但是，我并不完全理解这两个函数之间的区别，除了一个用于设置 3D 相机 View ，另一个用于设置 2D 相机 View 。如果能得到解答就好了。提前感谢您
opengl - gluPerspective 参数——它们是什么意思？
我想知道 gluPerspective参数。在所有示例中，我看到 fovy设置为45-60度左右我试图将它设置为不同的值，但对象就消失了对此有何解释？ aspect值(value)应该永远是比率
java - 将顶点缓冲区对象与 gluPerspective 结合使用
我正在尝试了解顶点缓冲区对象。我已经能够在 2D 空间中成功渲染四边形(在初始化期间使用 glOrtho)，但在使用 gluPerspective 渲染时使用 VBO 时遇到问题。我正在使用 Jav
c - 从 glOrtho 切换到 gluPerspective
我在 (0,0) 处抽了一辆汽车，并设置了一些障碍，但现在我主要关心的是从 glPerspective 切换到 glOrtho，反之亦然。当我从透视切换到正射时，我得到的只是黑屏。 void myin
opengl - glm::perspective 与 gluPerspective
我正在用 glm 替换我的项目中对 glu 方法的使用，我似乎遇到了一个我无法解释的奇怪差异。当我使用此代码使用 gluPerspective 设置投影矩阵时，我得到以下显示: glMatrixMod
opengl - 在 OpenGL 中使用 gluPerspective
我正在做我的 OpenGL 程序，碰巧遇到了问题，你能找出它出了什么问题吗？以y轴为中心旋转一个平面当我使用 glOrtho 时，它工作正常，但 gluPerspective 则不然。 gluPer
OpenGL 已弃用的函数以及 gluPerspective 和 Transform
我是 OpenGL 新手，仍在尝试基本形状。我有时会发现许多函数，例如 glEnd 等，OpenGL 3+ 文档中未提及这些函数。它们被其他功能取代了吗？或者我必须手动编写它们？是否有使用 OpenG
java - 我正在尝试使用 GLU.gluPerspective()，但它给了我静态引用错误
好吧。我对 OpenGL 之类的东西还是全新的。我正在使用 LWJGL 3 和 JOGL(用于 GLU)，并且我的自学过程完全停止了。现在我正在尝试使用 GLU.gluPerspective(80,
java - 我如何在 jogl 中使用 gluPerspective()？
我有一个 init() 方法，我正在尝试创建一个 Perspective 渲染。下面是我到目前为止的代码，但是我传递给 gluPerspective(fovy, aspect, zNear, zFar
c++ - Opengl 与 gluPerspective 的混淆
大家好，我是 opengl 的初学者，正在尝试理解 gluPerspective() 函数的概念。我浏览了这篇文章 gluPerspective parameters- what do they me
c++ - gluPerspective 和 glOrtho 都没有任何效果
编辑........ 所以我已经摆脱了所有的废话，现在只有一个 SSCE(希望我明白现在是什么)。对于还没有看到这个问题的人，我想在调整大小时保持纵横比，但窗口的行为就好像我已经注释掉了与调整大小时有
c - SFML - 未找到 gluPerspective 函数
在所有未被引用的函数中，我的 gluPerspective 在我尝试使用它时返回错误。我知道它与语法或人为错误无关:我一直在从 SFML 教程中复制/粘贴它使用的代码行。我正在使用 QT Creat
c++ - 替换 gluPerspective(使用 glFrustrum)
如何将 gluPerspective 函数转换为 glFrustum？我曾尝试使用此等式，但运气不佳，因为它生成的图像与使用 gluPerspective 生成的图像不同。 top = tan(f
c++ - GLUPerspective 的原始 OpenGL 等价物？
如果没有 Glu，我怎么能像 GluPerspective 一样呢？谢谢例如:gluPerspective(45.0, (float)w/(float)h, 1.0, 200.0); 最佳答案 vo
OpenGL - gluPerspective/glFrustum - zNear & zFar 问题
我正在编写一个太空探索应用程序。我决定以光年为单位，并准确地模拟了恒星之间的距离。经过修补和大量艰巨的工作(主要是学习绳索)，我让相机从穿越宇宙的星舰的角度正常工作。最初我没有注意 gluPersp
opengl - 如何增加 openGL 停止绘制对象的距离(zfar/gluPerspective)？
我正在学习 OpenGL，但在使用 gluPerspective 时遇到了问题。这是我在 Init() 中使用的代码 // Calculate The Aspect Ratio Of The Wind

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - gluPerspective 和 glOrtho 都没有任何效果