OpenGLシェーダがコンパイルされない

Question

OpenGLプロジェクトのシェーダはコンパイルされません。私はCLionを使ってUbuntu 16.04 LTSを持っています。解決策が見つからなかったので、ここで質問します。ここで

は私errorlistです：

#include <iostream> 

// GLEW 
#define GLEW_STATIC 
#include <GL/glew.h> 

// GLFW 
#include <GLFW/glfw3.h> 

// Other includes 
#include "Shader.h" 

// Window dimensions 
const GLuint WIDTH = 800, HEIGHT = 600; 

// The MAIN function, from here we start the application and run the game loop 
int main() 
{ 
    // Init GLFW 
    glfwInit(); 

    // Set all the required options for GLFW 
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); 
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); 
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); 
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); 

    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); 

    // Create a GLFWwindow object that we can use for GLFW's functions 
    GLFWwindow *window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr); 

    int screenWidth, screenHeight; 
    glfwGetFramebufferSize(window, &screenWidth, &screenHeight); 

    if (nullptr == window) 
    { 
     std::cout << "Failed to create GLFW window" << std::endl; 
     glfwTerminate(); 

     return EXIT_FAILURE; 
    } 

    glfwMakeContextCurrent(window); 

    // Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions 
    glewExperimental = GL_TRUE; 
    // Initialize GLEW to setup the OpenGL Function pointers 
    if (GLEW_OK != glewInit()) 
    { 
     std::cout << "Failed to initialize GLEW" << std::endl; 
     return EXIT_FAILURE; 
    } 

    // Define the viewport dimensions 
    glViewport(0, 0, screenWidth, screenHeight); 

    // Build and compile our shader program 
    Shader ourShader("core.vs", "core.frag"); 


    // Set up vertex data (and buffer(s)) and attribute pointers 
    GLfloat vertices[] = 
      { 
        // Positions   // Colors 
        0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, // Bottom Right 
        -0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, // Bottom Left 
        0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f // Top 
      }; 
    GLuint VBO, VAO; 
    glGenVertexArrays(1, &VAO); 
    glGenBuffers(1, &VBO); 
    // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s). 
    glBindVertexArray(VAO); 

    glBindBuffer(GL_ARRAY_BUFFER, VBO); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 

    // Position attribute 
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid *) 0); 
    glEnableVertexAttribArray(0); 
    // Color attribute 
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid *)(3 * sizeof(GLfloat))); 
    glEnableVertexAttribArray(1); 

    glBindVertexArray(0); // Unbind VAO 

    // Game loop 
    while (!glfwWindowShouldClose(window)) 
    { 
     // Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions 
     glfwPollEvents(); 

     // Render 
     // Clear the colorbuffer 
     glClearColor(0.2f, 0.3f, 0.3f, 1.0f); 
     glClear(GL_COLOR_BUFFER_BIT); 

     // Draw the triangle 
     ourShader.Use(); 
     glBindVertexArray(VAO); 
     glDrawArrays(GL_TRIANGLES, 0, 3); 
     glBindVertexArray(0); 

     // Swap the screen buffers 
     glfwSwapBuffers(window); 
    } 

    // Properly de-allocate all resources once they've outlived their purpose 
    glDeleteVertexArrays(1, &VAO); 
    glDeleteBuffers(1, &VBO); 

    // Terminate GLFW, clearing any resources allocated by GLFW. 
    glfwTerminate(); 

    return EXIT_SUCCESS; 
} 

は、shader.hコード：

ATTENTION: default value of option force_s3tc_enable overridden by environment. 
ERROR::SHADER::VERTEX::COMPILATION_FAILED 
0:1(1): error: syntax error, unexpected $end 

ERROR::SHADER::FRAGMENT::COMPILATION_FAILED 
0:1(1): error: syntax error, unexpected $end 

ERROR::SHADER::PROGRAM::LINKING_FAILED 
error: linking with uncompiled shadererror: linking with uncompiled shader 

は、ここに私のmain.cppにコードだ

#ifndef SHADER_H 
#define SHADER_H 

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

#include <GL/glew.h> 
#include <cstring> 

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); 
     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); 
     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); 
     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); 
    } 
}; 

#endif 

は、ここに私のcore.vsです：

#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.0f); 
    ourColor = color; 
    // We swap the y-axis by substracing our coordinates from 1. This is done because most images have the top y-axis inversed with OpenGL's top y-axis. 
    // TexCoord = texCoord; 
    TexCoord = vec2(texCoord.x, 1.0 - texCoord.y); 
} 

...とcore.frag：

#version 330 core 
in vec3 ourColor; 
in vec2 TexCoord; 

out vec4 color; 

// Texture samplers 
uniform sampler2D ourTexture1; 

void main() 
{ 
// Linearly interpolate between both textures (second texture is only slightly combined) 
color = texture(ourTexture1, TexCoord); 
} 

私も自分のCMakeLists.txtを添付しました。希望する：

cmake_minimum_required(VERSION 3.9) 
project(STUDY_GL) 

set(CMAKE_CXX_STANDARD 11) 

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -pthread -fpermissive") 

find_package (OpenGL REQUIRED) 
find_package (GLUT REQUIRED) 
find_package (glfw3 REQUIRED) 
find_library (glew REQUIRED) 
find_library (glad REQUIRED) 


include_directories(${/usr/include/GLFW/}) 
include_directories(${/usr/include/GL/}) 


file(GLOB SOURCE_FILES 
     *.cpp 
     *.h 
     ) 

add_executable(main.cpp ${SOURCE_FILES} Shader.h) 

target_link_libraries (main.cpp ${OPENGL_LIBRARIES} ${GLUT_LIBRARIES} ${GLFW3_LIBRARIES} -lGL -lglfw -lglut -lGLEW) 

プロジェクト内にSOIL2ディレクトリがあります。ここにはlinkがあります。

Answer 1

通常、コードは正常ですが、std::ifstream::openに失敗するとフェイルビット状態フラグがセットされるため、std::ifstream::failbitをstd::ios::exceptionsに渡す必要があります。

vShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit); 
fShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit); 
try 
{ 
    vShaderFile.open(vertexPath); 
    fShaderFile.open(fragmentPath); 
    ..... 
} 
catch (std::ifstream::failure e) 
{ 
    std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl; 
} 

あなたの作業ディレクトリが適切ではないと確信しています。デバッグの理由からシェーダファイルへの絶対パスを使用してください。
シェーダソースファイルにアクセスできず、コードで例外がスローされない場合は、空の文字列をコンパイルしようとします。これにより、エラーメッセージが表示されます。ところで

、あなたがあなたの質問に投稿されたコードスニペットで任意のテクスチャを使用していないので、あなたはフラグメントシェーダを次のように変更すればいい：

// color = texture(ourTexture1, TexCoord); <--- skip 
color = vec4(ourColor,1.0);    <--- add 

Answer 2

をご覧のエラーは通常起こりソース文字列の長さを指定せずに最後にヌルターミネータのないシェーダソースがglShaderSourceに渡されたときです。一般的なファイルには通常、ヌルターミネータが含まれていないため、OpenGLはソース文字列の最後を読み取ることになります。

解決策は、シェーダソース文字列の正確な長さを渡すことです。