OpenGL 코어 프로파일이 쿼드 텍스처를 사용하지 않습니다.

Question

GLFW를 사용하여 두 개의 서로 다른 모니터에 두 개의 이미지를 표시하기 위해 다음 코드를 작성했습니다. OPENGL_CORE_PROFILE을 실행하려고하면 이미지가 나타나지 않습니다.

대신 화면이 검은 색으로 유지됩니다. 그러나 핵심 프로필을 사용하지 않으면 이미지가 화면에 잘 보입니다. 코어 프로파일을 사용해야 OpenGL 3.3 및 330 쉐이더를 사용할 수 있습니다.

OpenGL 3.3을 사용하여 이미지 및 이미지를 표시하는 가장 좋은 방법은 무엇입니까?

#include <GL/glew.h> 
#include <GLFW/glfw3.h> 
#include <opencv2/highgui/highgui.hpp> 
#include <opencv2/core/core.hpp> 
#include <stdlib.h> 
#include <stdio.h> 
#include <string.h> 
#include <iostream> 

static GLuint tex_lite; 
static GLuint tex_dark; 

static GLuint tex_front; 
static GLuint tex_back; 

float ratio; 
int width, height; 

char *textFileRead(char *fn) { 


    FILE *fp; 
    char *content = NULL; 

    int count=0; 

    if (fn != NULL) { 
     fp = fopen(fn,"rt"); 

     if (fp != NULL) { 

     fseek(fp, 0, SEEK_END); 
     count = ftell(fp); 
     rewind(fp); 

      if (count > 0) { 
       content = (char *)malloc(sizeof(char) * (count+1)); 
       count = fread(content,sizeof(char),count,fp); 
       content[count] = '\0'; 
      } 
      fclose(fp); 
     } 
    } 
    return content; 
} 

void printLog(GLuint obj) 
{ 
    int infologLength = 0; 
    int maxLength; 

    if(glIsShader(obj)) 
     glGetShaderiv(obj,GL_INFO_LOG_LENGTH,&maxLength); 
    else 
     glGetProgramiv(obj,GL_INFO_LOG_LENGTH,&maxLength); 

    char infoLog[maxLength]; 

    if (glIsShader(obj)) 
     glGetShaderInfoLog(obj, maxLength, &infologLength, infoLog); 
    else 
     glGetProgramInfoLog(obj, maxLength, &infologLength, infoLog); 

    if (infologLength > 0) 
     printf("%s\n",infoLog); 
} 

void image2texture(cv::Mat Image,GLuint &texName, int i) 
{ 
    glClearColor (0.0, 0.0, 0.0, 0.0); 
    glShadeModel(GL_FLAT); 
    glEnable(GL_DEPTH_TEST); 

    glActiveTexture(GL_TEXTURE0+i); 
    glGenTextures(1, &texName); 
    glBindTexture(GL_TEXTURE_2D, texName); 

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 
        GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
        GL_NEAREST); 

    glTexImage2D(GL_TEXTURE_2D, 0, 3, Image.cols, Image.rows, 0, GL_BGR, 
       GL_UNSIGNED_BYTE, Image.data); 
} 

static void error_callback(int error, const char* description) 
{ 
    fputs(description, stderr); 
} 

GLuint linkShader(char* vert, char* frag) 
{ 
    GLuint v,f,p; 

    char *vs = NULL,*fs = NULL; 

    v = glCreateShader(GL_VERTEX_SHADER); 
    f = glCreateShader(GL_FRAGMENT_SHADER); 

    vs = textFileRead(vert); 
    fs = textFileRead(frag); 

    const char * ff = fs; 
    const char * vv = vs; 

    glShaderSource(v, 1, &vv,NULL); 
    glShaderSource(f, 1, &ff,NULL); 

    free(vs);free(fs); 

    glCompileShader(v); 
    glCompileShader(f); 

    p = glCreateProgram(); 
    glAttachShader(p,f); 
    glAttachShader(p,v); 

    glLinkProgram(p); 

    return p; 
} 

static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) 
{ 
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) 
     glfwSetWindowShouldClose(window, GL_TRUE); 
} 

void checkWindow(GLFWwindow* window) 
{ 
    if (!window) 
    { 
     glfwTerminate(); 
     exit(EXIT_FAILURE); 
    } 
} 

int main(void) 
{ 
    GLFWwindow* window_back; 
    GLFWwindow* window_front; 

    glfwSetErrorCallback(error_callback); 

    if (!glfwInit()) 
    { 
     exit(EXIT_FAILURE); 
    } 

    cv::Mat image_lite = cv::imread("lena.tiff"); 
    cv::Mat image_dark = cv::imread("lena.tiff"); 

    cv::flip(image_lite, image_lite, 0); 
    cv::flip(image_dark, image_dark, 0); 

    int count; 
    GLFWmonitor** monitors = glfwGetMonitors(&count); 

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); 
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); 
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); 
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); 

    if (count >= 2) 
    { 
     window_front = glfwCreateWindow(1680,1050,"Front Screen",monitors[0],NULL); 
     window_back = glfwCreateWindow(1280,800,"Back Screen",monitors[1],NULL); 
     glewInit(); 
    } 
    else 
    { 
     exit(EXIT_FAILURE); 
    } 

    checkWindow(window_front); 
    checkWindow(window_back); 

    glfwMakeContextCurrent(window_front); 
    glfwSetKeyCallback(window_front, key_callback); 

    glewExperimental = GL_TRUE; 
    GLenum err = glewInit(); 
    if(err!=GLEW_OK) 
    { 
     std::cout<<"glewInit failed, aborting."<<std::endl; 
    } 

    std::cout << glGetString(GL_RENDERER) << std::endl; 
    std::cout << glGetString(GL_VENDOR) << std::endl; 
    std::cout << glGetString(GL_VERSION) << std::endl; 
    std::cout << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl; 

    while (!glfwWindowShouldClose(window_front) && !glfwWindowShouldClose(window_back)) 
    { 

     glfwMakeContextCurrent(window_front); 
     glfwSetKeyCallback(window_front, key_callback); 

     glfwGetFramebufferSize(window_front, &width, &height); 
     ratio = width/(float) height; 
     glViewport(0,0,width,height); 

     image2texture(image_lite, tex_lite,0); 

     // GLuint prg = linkShader("toon.vert","toon.frag"); 

     glClear(GL_COLOR_BUFFER_BIT); 
     glMatrixMode(GL_PROJECTION); 
     glLoadIdentity(); 
     glOrtho(-ratio,ratio,-1.f,1.f,-1.f,1.f); 
     glMatrixMode(GL_MODELVIEW); 
     glLoadIdentity(); 

     glActiveTexture(GL_TEXTURE0); 
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
     glEnable(GL_TEXTURE_2D); 
     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
     glBindTexture(GL_TEXTURE_2D, tex_lite); 

     glBegin(GL_QUADS); 
      glTexCoord2f(0.0, 0.0); glVertex3f(-1.0,-1.0,0.0); 
      glTexCoord2f(0.0, 1.0); glVertex3f(-1.0,1.0,0.0); 
      glTexCoord2f(1.0, 1.0); glVertex3f(1.0,1.0,0.0); 
      glTexCoord2f(1.0, 0.0); glVertex3f(1.0,-1.0,0.0); 
     glEnd();  
     glFlush(); 
     glfwSwapBuffers(window_front); 
     glfwPollEvents(); 

     glfwMakeContextCurrent(window_back); 
     glfwSetKeyCallback(window_back, key_callback); 

     glfwGetFramebufferSize(window_back, &width, &height); 
     ratio = width/(float) height; 
     glViewport(0,0,width,height); 

     image2texture(image_dark, tex_dark,1); 

     glClear(GL_COLOR_BUFFER_BIT); 
     glMatrixMode(GL_PROJECTION); 
     glLoadIdentity(); 
     glOrtho(-ratio,ratio,-1.f,1.f,-1.f,1.f); 
     glMatrixMode(GL_MODELVIEW); 
     glLoadIdentity(); 

     glActiveTexture(GL_TEXTURE0); 
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
     glEnable(GL_TEXTURE_2D); 
     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
     glBindTexture(GL_TEXTURE_2D, tex_lite); 

     glBegin(GL_QUADS); 
      glTexCoord2f(0.0, 0.0); glVertex3f(-1.0,-1.0,0.0); 
      glTexCoord2f(0.0, 1.0); glVertex3f(-1.0,1.0,0.0); 
      glTexCoord2f(1.0, 1.0); glVertex3f(1.0,1.0,0.0); 
      glTexCoord2f(1.0, 0.0); glVertex3f(1.0,-1.0,0.0); 
     glEnd(); 
     glFlush(); 
     glfwSwapBuffers(window_back); 
     glfwPollEvents(); 
    } 
    glfwMakeContextCurrent(window_front); 
    glfwDestroyWindow(window_front); 
    glfwMakeContextCurrent(window_back); 
    glfwDestroyWindow(window_back); 

    glfwTerminate(); 
    exit(EXIT_SUCCESS); 
} 

Answer 1

코드가 코어 프로파일에서 완전히 유효하지 않습니다. 핵심 프로파일에서 수년 전에 "권장되지 않는"것으로 선언 된 모든 이전 기능은 실제로는 이 제거 된입니다. GL_QUADS 기본 유형은 지원되지 않으며 glBegin()/glEnd()의 직접 모드 렌더링은 지원되지 않으며 glEnable(GL_TEXTURE_2D);은 지원되지 않으며 texcoord 및 꼭지점 위치와 같은 기본 정점 속성은 지원되지 않으며 GL_TEXTURE_ENV_MODE은 지원되지 않으며 쉐이더없이 렌더링됩니다 ("고정 기능 파이프 라인"). 지원되지 않음. glMatrixMode(), glLoadIdentity, glOrtho() 및 기타 모든 행렬 및 행렬 스택 관련 기능에 대해서도 마찬가지입니다. 내부 형식 "3"은 glTexImage2D()에도 지원되지 않으므로 GL_RGB을 사용해야합니다 (이전에 사용해야 했음).

최신 핵심 프로필을 사용하려면 모든 내장 특성이없는 셰이더와 함께 프로그래밍 가능한 파이프 라인을 사용해야합니다. 대신 자신 만의 일반적인 속성을 정의하십시오. 즉시 모드가 아닌 버텍스 포인터에 대해 기하학과 VAO에 VBO를 사용해야합니다. 쿼드 프리미티브를 삼각형 기반 프리미티브로 대체해야합니다. 당신은 당신 자신의 행렬 함수를 사용하거나, 그것을위한 라이브러리를 사용해야 할 것입니다.

최신 OpenGL을 독점적으로 다루는 arcsynthesis 또는 open.gl과 같은 자습서를 볼 수 있습니다.