gluPerspective도 glOrtho도 아무런 효과가 없습니다.

Question

EDIT ........ 그래서 나는 모든 허튼 소리를 없애고 현재 SSCE를 가졌습니다. (잘하면 나는 현재 무엇인지 이해합니다). 이 문제를 이미 보지 못했지만 크기를 조정할 때 가로 세로 비율을 유지하고 싶지만 크기 조정과 관련하여 아무 것도 주석 처리하지 않은 것처럼 윈도우가 작동합니다 (늘어납니다). 나는 모든 점을 따라 투영 행렬을 검사했고 기대했던 점에서 바뀌었고 기대했던 점에서 같았습니다.

다른 파일에 의존하는 항목을 제거 했으므로 셰이더 파일을 제외하고 컴파일해야합니다. 코드도 게시합니다 (매우 짧습니다). 미안하지만 형식이 매우 멋지게 보이지 않으므로 대부분의 줄 앞에 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); 
} 

Answer 1

나는 당신이 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; 
} 

Answer 2

gluPerspective가 작동하지 않습니다 , 당신이 쉐이더에 투영 행렬 핸들을 전달하지 않는다면.

그래서 처음에 다른 전역 변수와 함께 g_ProjectionMatrixHandle = 0으로 설정하십시오.

그런 다음 초기화 단계에서 핸들을 얻을 :

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

그런 다음 쉐이더의 핸들을 수집하고 그것을 사용 :

g_ProjectionMatrixHandle = glGetUniformLocation(g_Program, "projection_matrix"); 

그런 다음 도면 단계에서 셰이더 핸들을 보내 :

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의 코드를 참조하십시오.