OpenGL: Quelle est la cause de l'erreur "ERROR :: SHADER :: PROGRAM :: LINKING_FAILED"?

Question

Enfin, j'ai trouvé que c'est le problème du chemin de fichier relatif. Le fichier de code de fragment et le fichier de code de sommet ne sont pas trouvés avec mon chemin de fichier relatif. Donc, aucun code n'a été envoyé au shader. J'ai changé le chemin relatif du fichier avec le chemin absolu, le projet a bien fonctionné.

-------------------------------- Voici plus de détails sur mon projet ------- --------------------------------

• version Xcode: 6.1 (6A1052c)

• iOS version: OS XE Capitan 10.11.6 (15G31)

• carte GFX: Intel Iris 1536 MB

• code de vertex shader:

  #version 330 core 
  layout (location = 0) in vec3 position; 
  layout (location = 1) in vec3 color; 
  layout (location = 2) in vec2 texCoord; 
  
  out vec3 ourColor; 
  out vec2 TexCoord; 
  
  void main() 
  { 
      gl_Position = vec4(position, 1.0); 
      ourColor = color; 
      TexCoord = vec2(texCoord.x , 1.0 - texCoord.y); 
  } 
  

• Code de fragment shader:

  #version 330 core 
  in vec3 ourColor; 
  in vec2 TexCoord; 
  
  out vec4 color; 
  
  uniform sampler2D ourTexture1; 
  
  void main() 
  { 
      color = texture(ourTexture1,TexCoord) * vec4(ourColor,1.0); 
  } 
  

--------------------------- ------- Voici ma question originale -------------------------------------- ---------

j'ai rencontré un problème avec la programmation OpenGL, la sortie de la console est comme ceci:

Le journal est vide.

J'ai vérifié mon code plusieurs fois et je ne savais pas vraiment quelle pouvait être la cause.

Alors quelqu'un peut-il me dire quelle peut être la cause?

Après mon code de shaders:

#include <string> 
#include <fstream> 
#include <sstream> 
#include <iostream> 

#include <GL/glew.h> 

class Shader 
{ 
public: 
GLuint Program; 

// Constructor generates the shader on the fly 
Shader(const GLchar *vertexPath, const GLchar *fragmentPath) 
{ 
    // 1. Retrieve the vertex/fragment source code from filePath 
    std::string vertexCode; 
    std::string fragmentCode; 
    std::ifstream vShaderFile; 
    std::ifstream fShaderFile; 
    // ensures ifstream objects can throw exceptions: 
    vShaderFile.exceptions (std::ifstream::badbit); 
    fShaderFile.exceptions (std::ifstream::badbit); 
    try 
    { 
     // Open files 
     vShaderFile.open(vertexPath); 
     fShaderFile.open(fragmentPath); 
     std::stringstream vShaderStream, fShaderStream; 
     // Read file's buffer contents into streams 
     vShaderStream << vShaderFile.rdbuf(); 
     fShaderStream << fShaderFile.rdbuf(); 
     // close file handlers 
     vShaderFile.close(); 
     fShaderFile.close(); 
     // Convert stream into string 
     vertexCode = vShaderStream.str(); 
     fragmentCode = fShaderStream.str(); 
    } 
    catch (std::ifstream::failure e) 
    { 
     std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl; 
    } 
    const GLchar *vShaderCode = vertexCode.c_str(); 
    const GLchar *fShaderCode = fragmentCode.c_str(); 
    // 2. Compile shaders 
    GLuint vertex, fragment; 
    GLint success; 
    GLchar infoLog[512]; 

    // Vertex Shader 
    vertex = glCreateShader(GL_VERTEX_SHADER); 
    glShaderSource(vertex, 1, &vShaderCode, NULL); 
    glCompileShader(vertex); 
    // Print compile errors if any 
    glGetShaderiv(vertex, GL_COMPILE_STATUS, &success); 
    std::cout <<"Vertex::" << success << std::endl; 
    if (!success) 
    { 
     glGetShaderInfoLog(vertex, 512, NULL, infoLog); 
     std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl; 
    } 

    // Fragment Shader 
    fragment = glCreateShader(GL_FRAGMENT_SHADER); 
    glShaderSource(fragment, 1, &fShaderCode, NULL); 
    glCompileShader(fragment); 
    // Print compile errors if any 
    glGetShaderiv(fragment, GL_COMPILE_STATUS, &success); 
    std::cout <<"Fragment::" << success << std::endl; 
    if (!success) 
    { 
     glGetShaderInfoLog(fragment, 512, NULL, infoLog); 
     std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl; 
    } 

    // Shader Program 
    this->Program = glCreateProgram(); 
    glAttachShader(this->Program, vertex); 
    glAttachShader(this->Program, fragment); 
    glLinkProgram(this->Program); 
    // Print linking errors if any 
    glGetProgramiv(this->Program, GL_LINK_STATUS, &success); 
    std::cout <<"linking::" << success << std::endl; 

    if (!success) 
    { 
     glGetProgramInfoLog(this->Program, 512, NULL, infoLog); 
     std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl; 
    } 
    // Delete the shaders as they're linked into our program now and no longer necessery 
    glDeleteShader(vertex); 
    glDeleteShader(fragment); 

} 
// Uses the current shader 
void Use() 
{ 
    glUseProgram(this->Program); 
} 

}; 

Answer 1

Enfin, je trouve que c'est la question de chemin de fichier relatif. Le fichier de code de fragment et le fichier de code de vertex ne sont pas trouvés avec mon chemin de fichier relatif. Donc, aucun code n'a été envoyé au shader. J'ai changé le chemin de fichier relatif avec le chemin absolu, le projet a bien fonctionné.