gluPerspective和glOrtho都没有任何效果

编辑........所以我已经摆脱了所有废话，只是有一个SSCE现在（希望我明白现在是什么）。对于那些还没有看到这个问题的人，我想在调整大小的时候保持高宽比，但是窗口的行为好像我已经评论过任何与调整大小有关的事情（它会拉伸）。我已经检查了所有点上的投影矩阵，并且它在你期望的点上变化，并且保持在你期望的点上。gluPerspective和glOrtho都没有任何效果

我删除了依赖其他文件的东西，所以它应该为你编译，除了着色器文件，我也会发布他们的代码（它们很短）。我很抱歉，它看起来不太好格式化，很难保持格式不得不在大多数行前放置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); 
}

来源

2013-04-26 Erin

-1：类似于你的*不*你有什么。发布工作代码并不能帮助我们在*不工作的代码中找到问题。我们需要看到您的*代码的SSCCE，它表现出您遇到的问题。 – 2013-04-27 04:58:58

“很难保持格式不得不在大多数行前放置4个空格。”...如果您使用Visual Studio/Eclipse/Netbeans进行编辑，只需在选项中设置4-space选项卡，请选择您的整个程序，然后点击选项卡。它应该缩进4个空格。 – genpfault 2013-04-30 02:24:36

谢谢genpfault !!!我会在下次发布一个问题时做到这一点:-) – Erin 2013-04-30 03:51:49

我不完全相信你如愿没有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; 
}

来源

2013-04-26 14:49:29 genpfault

我试着像你所建议的那样添加glutInit，而其他所有东西都一样，都没有用。然后我试着让它与你的一样（摆脱了idlefunc和重塑func，在绘图功能中进行了重塑），并且仍然如此，只有我的车不再旋转。 – Erin 2013-04-26 22:22:50

[SSCCE]的时间（http://sscce.org/）。 – genpfault 2013-04-26 22:44:32

我也尝试画线多维数据集而不是车，但没有出现。我认为这是因为使用着色器可能？ – Erin 2013-04-26 23:12:31

gluPerspective不起作用，除非您将投影矩阵句柄传递给着色器。

所以有一个全局int g_ProjectionMatrixHandle = 0在你的其他全局开始。

然后让手柄在初始化阶段：

g_ProjectionMatrixHandle = glGetUniformLocation(g_Program, "projection_matrix");

然后把手发送到着色器在绘图阶段：

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

然后收集处理着色器，并使用它：

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

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

我还想知道为什么我不能很快画出形状并稍后编辑此答案以防其他人遇到问题。

顺便说一句，如果你只是绘制常规形状（线条，多边形等）而不是数组的坐标和纹理，并且出于某种原因使用着色器，请参考genpfault的着色器代码。

来源

2013-05-10 02:18:23 Erin

gluPerspective和glOrtho都没有任何效果

回答

相关问题