OpenGL: Was könnte die Ursache für den Fehler "ERROR :: SHADER :: PROGRAM :: LINKING_FAILED" sein?

Question

Schließlich habe ich festgestellt, dass es das Problem der relativen Dateipfad ist. Die Fragment-Code-Datei und die Vertex-Code-Datei wurden nicht mit meinem relativen Dateipfad gefunden. Also wurde kein Code an den Shader gesendet. Ich habe relative Dateipfad mit absoluter Pfad geändert, das Projekt hat gut funktioniert.

-------------------------------- Folgendes sind weitere Details zu meinem Projekt ------- --------------------------------

• Xcode Version: 6.1 (6A1052c)

• iOS-Version: OS XE Capitan 10.11.6 (15G31)

• GFX Karte: Intel Iris 1536 MB

• Code of 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 of 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); 
  } 
  

--------------------------- ------- Folgendes ist meine ursprüngliche Frage -------------------------------------- ---------

ich ein Problem mit OpenGL Programmierung erfüllt, ist die Ausgabe der Konsole wie folgt aus:

Das Protokoll ist leer.

Ich habe meinen Code mehrmals überprüft und wusste wirklich nicht, was die Ursache sein könnte.

Also kann mir jemand sagen, was die Ursache sein könnte?

Es folgt mein Shader-Code:

#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

Schließlich fand ich, dass es das Problem der relativen Dateipfad ist. Die Fragment-Code-Datei und die Vertex-Code-Datei wurden nicht mit meinem relativen Dateipfad gefunden. Also wurde kein Code an den Shader gesendet. Ich habe relative Dateipfad mit absolutem Pfad geändert, das Projekt hat gut funktioniert.