2016-03-21 6 views
-1

私は近代OpenGL(4.1)でもう一度遊んでいましたが、シェーディングレルムに入るまではすべてうまくいきました。Vertex Shaderでユニフォームを宣言してからOpenGLがレンダリングされない

しかし、シェーディングで何かをレンダリングする前に、頂点シェーダにいくつか問題がありました。

プログラムは本当にシンプルで、OBJファイルとメッシュのテクスチャを読み込むだけです。私はそれらのものをそれぞれのバッファーに入れ、それを描きます。最初はすべてを完全に描画していましたが、その後、頂点シェーダとBAMに変数uniformを2つ追加しました!何も描かれません。面白いことは、私が余分な制服をコメントしたら、すべてが再びレンダリングされるということです。私は本当にここで何が起こっているのか理解していない

、私は制服のいずれかの制限を外挿すると思ったが、それはわずか3 mat4制服であり、私はGoogleで何から、私は少なくとも1024 [source]を持っています。

とにかく、私はグーグル・クエリーの中でアイデアがないので、私はあなたの助けに来ています。 ありがとうございます!

ああ、私はMacOSXのエルキャプテンと環境のいくつかの情報を使用しています(glGetStringから得た): バージョン:4.1 ATI-1.40.16 レンダラ:AMDのRadeon HD 6750MのOpenGLエンジン

の一部をコードが含まれていないのは、コンテキストの作成とシェーダのコンパイルだけです。 uniform mat4 mM;を削除すると完全に機能することに注意してください。それ以外の場合は、 "Location - > -1"(均一ではありません)という印字を続けます。 私は実際に何が起こっているのか分かりません。

P .:まだまだひどいコードは気にしないでください。まだまだ良いコードを見つけようとしています。

vertexShader.gs:

#version 410 
layout(location = 0) in vec3 vPosition; 
layout(location = 1) in vec2 vTex; 

out vec2 texCoord; 

uniform mat4 mM; 
uniform mat4 mV; 
uniform mat4 mvp; 

void main() { 
    texCoord = vTex; 

    gl_Position = mvp * vec4(vPosition, 1.0f); 
} 

MAIN.CPP

#include <iostream> 
#include <string> 
#include <vector> 

#include <OpenGl/gl.h> 
//#define GLFW_INCLUDE_GLCOREARB 
#include <GLFW/glfw3.h> 

#include <glm/glm.hpp> 
#include <glm/gtc/matrix_transform.hpp> 

#include "picg.h" 
#include "shader.h" 
#include "tiny_obj_loader.h" 
#define STB_IMAGE_IMPLEMENTATION 
#include "stb_image.h" 

void matrices(GLfloat xAngle, GLfloat yAngle); 

glm::mat4 projection, view, model, rotations; 
glm::mat4 mvp; 
glm::vec3 light; 

GLuint vao, vbo, ibo, tbo; 
GLuint texture; 
GLuint shaderProgram; 

const GLfloat angle = 1.0f; 

GLfloat cYAngle; 
GLfloat cXAngle; 
GLfloat scale = 1.0f; 

GLfloat points[] = { 
    -0.7f, +0.7f, +0.7f, 
    -0.7f, -0.7f, +0.7f, 
    +0.7f, -0.7f, +0.7f, 
    +0.7f, +0.7f, +0.7f 
}; 

GLuint indices[] = { 
    0, 1, 2, 3, 0, 2 
}; 

int main() { 
    GLFWwindow * window = create_context("Fish club", 600, 600); 
    initGL(); 

    GLubyte vertexShader = shaderFromFile("vertexShader.gs", GL_VERTEX_SHADER); 
    GLubyte fragmentShader = shaderFromFile("fragmentShader.gs", GL_FRAGMENT_SHADER); 

    projection = glm::perspective(glm::radians(+45.f), 1024.f/768.f, 0.1f, 600.0f); 

    view = glm::lookAt(
      glm::vec3(+0.0f,+0.0f,+5.0f), 
      glm::vec3(+0.0f,+0.0f,+0.0f), 
      glm::vec3(+0.0f,+1.0f,+0.0f) 
    ); 

    model = glm::mat4(1.0f); 
    model = glm::scale(model, glm::vec3(90.0f)); 
    mvp = projection * view * model; 

    light = glm::vec3(0.0f, 1.0f, 1.0f); 

    std::vector<tinyobj::shape_t> shapes; 
    std::vector<tinyobj::material_t> materials; 

    std::string err; 
    if (!tinyobj::LoadObj(shapes, materials, err, "res/GOLDFISH.obj")) { 
     throw std::runtime_error(std::string("Error loading OBJ file:\n") + err); 
    } 

    std::cout << "Shapes: " << shapes.size() << std::endl 
       << "Materials: " << materials.size() << std::endl 
       << "Positions: " << shapes[0].mesh.positions.size() << std::endl 
       << "Normals: " << shapes[0].mesh.normals.size() << std::endl 
       << "TexCoords: " << shapes[0].mesh.texcoords.size() << std::endl; 

    shaderProgram = glCreateProgram(); 
    glAttachShader(shaderProgram, vertexShader); 
    glAttachShader(shaderProgram, fragmentShader); 
    glLinkProgram(shaderProgram); 

    int width, height, numComponents; 
    unsigned char * imageData = stbi_load("res/GOLDFISH.bmp", 
            &width, &height, &numComponents, 4); 

    glGenTextures(1, &texture); 
    glBindTexture(GL_TEXTURE_2D, texture); 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 

     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 

     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 
       width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 
       imageData); 
    glBindTexture(GL_TEXTURE_2D, NULL); 

    stbi_image_free(imageData); 

    GLsizei vertex_buffer_size = 0; 
    for (int i = 0 ; i < shapes.size(); ++i) { 
     vertex_buffer_size += sizeof(float) * shapes[i].mesh.positions.size(); 
    } 
    glGenBuffers(1, &vbo); 
    glBindBuffer(GL_ARRAY_BUFFER, vbo); 
     glBufferData(GL_ARRAY_BUFFER, vertex_buffer_size, NULL, GL_STATIC_DRAW); 
     for (int i = 0, offset = 0 ; i < shapes.size() ; ++i) { 
      glBufferSubData(GL_ARRAY_BUFFER, offset, 
        sizeof(float) * shapes[i].mesh.positions.size(), 
        &shapes[i].mesh.positions[0]); 

      offset += sizeof(float) * shapes[i].mesh.positions.size(); 
     } 
    glBindBuffer(GL_ARRAY_BUFFER, NULL); 

    GLsizei index_buffer_size = 0; 
    GLsizei index_size = 0; 
    for (int i = 0 ; i < shapes.size() ; ++i) { 
     index_buffer_size += sizeof(float) * shapes[i].mesh.indices.size(); 
     index_size += shapes[i].mesh.indices.size(); 
    } 
    glGenBuffers(1, &ibo); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); 
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, index_buffer_size, NULL, GL_STATIC_DRAW); 
     for (int i = 0, offset = 0 ; i < shapes.size() ; ++i) { 
      glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, 
        sizeof(unsigned int) * shapes[i].mesh.indices.size(), 
        &shapes[i].mesh.indices[0]); 

      offset += sizeof(unsigned int) * shapes[i].mesh.indices.size(); 
     } 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL); 

    GLsizei texcoord_buffer_size = 0; 
    for (int i = 0 ; i < shapes.size() ; ++i) { 
     texcoord_buffer_size += sizeof(float) * shapes[i].mesh.texcoords.size(); 
    } 
    glGenBuffers(1, &tbo); 
    glBindBuffer(GL_ARRAY_BUFFER, tbo); 
     glBufferData(GL_ARRAY_BUFFER, texcoord_buffer_size, NULL, GL_STATIC_DRAW); 

     for (int i = 0, offset = 0 ; i < shapes.size() ; ++i) { 
      glBufferSubData(GL_ARRAY_BUFFER, offset, 
        sizeof(float) * shapes[i].mesh.texcoords.size(), 
        &shapes[i].mesh.texcoords[0]); 
      offset += sizeof(float) * shapes[i].mesh.texcoords.size(); 
     } 
    glBindBuffer(GL_ARRAY_BUFFER, NULL); 

    glGenVertexArrays(1, &vao); 
    glBindVertexArray(vao); 
     glBindBuffer(GL_ARRAY_BUFFER, vbo); 
      glEnableVertexAttribArray(0); 
      glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL); 
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); 
     glBindBuffer(GL_ARRAY_BUFFER, tbo); 
      glEnableVertexAttribArray(1); 
      glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, NULL); 
    glBindVertexArray(NULL); 

    glBindBuffer(GL_ARRAY_BUFFER, NULL); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL); 

    while (!glfwWindowShouldClose(window)) { 
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

     cYAngle += 0.1f; 

     matrices(cXAngle, cYAngle); 

     glUseProgram(shaderProgram); 
      std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mV") << std::endl; 
      std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mM") << std::endl; 
      std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mvp") << std::endl; 
      glUniformMatrix4fv(
        glGetUniformLocation(shaderProgram, "mvp"), 
        1, GL_FALSE, &mvp[0][0]); 

      glUniformMatrix4fv(
        glGetUniformLocation(shaderProgram, "mV"), 
        1, GL_FALSE, &view[0][0]); 
      glUniformMatrix4fv(
        glGetUniformLocation(shaderProgram, "mM"), 
        1, GL_FALSE, &model[0][0]); 

      glActiveTexture(GL_TEXTURE0); 
      glBindTexture(GL_TEXTURE_2D, texture); 
      glUniform1i(glGetUniformLocation(shaderProgram, "textureSampler"), 0); 

      glBindVertexArray(vao); 
       glDrawElements(GL_TRIANGLES, index_buffer_size, GL_UNSIGNED_INT, NULL); 
      glBindVertexArray(NULL); 
     glUseProgram(NULL); 

     glfwPollEvents(); 
     glfwSwapBuffers(window); 
    } 

    glfwTerminate(); 

    return 0; 
} 

void matrices(GLfloat xAngle, GLfloat yAngle) { 
    model = glm::mat4(1.0f); 
    model = glm::rotate(model, glm::radians(xAngle), glm::vec3(+1.0f, +0.0f, +0.0f)); 
    model = glm::rotate(model, glm::radians(yAngle), glm::vec3(+0.0f, +1.0f, +0.0f)); 
    model = glm::scale(model, glm::vec3(40.0f)); 

    mvp = projection * view * model; 
} 

編集:

#version 410 
layout(location = 0) in vec3 vPosition; 
layout(location = 1) in vec2 vTex; 

out vec2 texCoord; 

uniform mat4 mM; 
uniform mat4 mV; 
uniform mat4 mP; 

void main() { 
    texCoord = vTex; 

    gl_Position = mP * mV * mM * vec4(vPosition, 1.0f); 
} 

と変更された:

としては、私は、次の頂点シェーダを試してみまし提案以下また、私は何も見ることができず、すべてのユニフォームに対して "Location - > -1"を返します。

答えて

1

mMおよびmVは、頂点シェーダコードでは使用されません。コンパイル時に削除されると考えられますので、glGetUniformLocation()でその場所を取得しようとすると、この情報は利用できません。シェーダコードにmMmVを使って何かをしてみてください。

+0

Hey!答えをありがとう。 私も '' 'mvp''の一様性を取り除いて3つの行列をシェーダに送り、そこで乗算を行いましたが、それでもうまくいかず、' 'glGetUniformLocation'''すべてのユニフォームに対して-1を返します。 –

関連する問題