OpenGL, Vertex Shader

Question

'da tekdüzen ilan edildikten sonra oluşturulmuyor Modern OpenGL (4.1) ile yeniden oynuyorum ve gölgeleme alanlarına adım atıncaya kadar her şey yolunda gitti.

Ancak gölgelendirme ile bir şey yapmadan önce, köşe gölgelendiricisiyle bazı sorunlarım var.

Program gerçekten çok basit, sadece bir OBJ dosyası ve aynı zamanda örgü dokusunu okur. Bu şeyleri kendi tamponlarına koyup çiziyorum. İlk başta her şeyi mükemmel bir şekilde çiziyordu, ancak daha sonra köşe gölgelendiricisinde ve BAM'de daha fazla uniform değişken ekledim! Hiçbir şey çizilmez. Komik olan şu: ekstra üniformalardan birine yorum yaptığım anda, her şey tekrar işleniyor.

Gerçekten burada neler olduğunu anlamıyorum, ben üniforma herhangi bir sınır extrapolating sandım, ama sadece 3 mat4 üniformalar ve ben googled kadarıyla, en az 1024 [source] var.

Her neyse, Google sorgudan çıkmış fikirlerim yok, bu yüzden yardımınıza geliyorum. Şimdiden teşekkürler!

Ah, MacOSX El Kaptan ve çevre bazı bilgiler kullanıyorum (glGetString var): Versiyon: 4.1 ATI-1.40.16 Renderer: AMD Radeon HD 6750M OpenGL Motor

bazıları kod içermez sadece İçerik oluşturma ve Shader derlemesidir. Not: uniform mat4 mM;'u silersem mükemmel çalışır. Aksi takdirde, "Konum -> -1" yazdırmayı tutar (herhangi bir üniforma bulamadığını söyler). Gerçekten neler olduğunu bilmiyorum.

Not: Ayrıca, hala iyi olmayan bazı şeyler kodunu çözmeye çalışıyorum, korkunç kod için lütfen unutmayın.

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

düzenleme:

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

Ve değiştirdi:

olarak ben şu vertex shader çalıştı önerdi

takip etme satırlar

glUseProgram(shaderProgram); 
    std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mP") << std::endl; 
    std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mV") << std::endl; 
    std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mM") << std::endl; 

    glUniformMatrix4fv(
     glGetUniformLocation(shaderProgram, "mP"), 
     1, GL_FALSE, &projection[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); 

Ve yine de, hiçbir şey göremiyorum ve her üniform için yalnızca "Konum -> -1" değerini döndürür. Köşe gölgelendirici kodunuzda

Answer 1

mM ve mV kullanılmaz. Derleme sırasında çıkarılacağına inanıyorum, bu yüzden glGetUniformLocation() ile konumlarını almaya çalıştığınızda bu bilgi mevcut değil. Gölgelendirici kodunuzda mM ve mV ile bir şeyler yapmaya çalışın.