c++ - 使用 VAO/VBO 进行 OpenGL 模型/纹理渲染

原文 标签 c++ opengl rendering vbo vao

我正在尝试使用 Assimp 渲染带有纹理的 3D 模型.转换非常完美,所有纹理位置以及未加载的内容。我已经通过将纹理图像以 2D 的形式绘制到屏幕上来测试它们。
由于某种原因,它不会将纹理渲染到模型。
我是 OpenGL 的初学者,所以如果我解释不正确,请原谅我。
我基于代码的教程来自 here ,但我剥离了很大一部分,因为我有自己的相机/运动系统。

模型渲染如下:http://i.stack.imgur.com/5sK9K.png

而使用中的纹理看起来像这样:http://i.stack.imgur.com/sWGp7.jpg

相关渲染代码如下:

从数据文件生成纹理:

int Mesh::LoadGLTextures(const aiScene* scene){
  if (scene->HasTextures()) return -1; //yes this is correct
  /* getTexture Filenames and Numb of Textures */
  for (unsigned int m = 0; m<scene->mNumMaterials; m++){
    int texIndex = 0;

    aiReturn texFound;
    aiString path;  // filename

    while ((texFound = scene->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path)) == AI_SUCCESS){
        textureIdMap[path.data] = NULL; //fill map with textures, pointers still NULL yet
        texIndex++;
    }
  }

  int numTextures = textureIdMap.size();
  /* create and fill array with GL texture ids */
  GLuint* textureIds = new GLuint[numTextures];

  /* get iterator */
  std::map<std::string, GLuint>::iterator itr = textureIdMap.begin();

  std::string basepath = getBasePath(path);

  ALLEGRO_BITMAP *image;
  for (int i = 0; i<numTextures; i++){
    std::string filename = (*itr).first;  // get filename
    (*itr).second = textureIds[i];    // save texture id for filename in map
    itr++;                                // next texture

    std::string fileloc = basepath + filename;  /* Loading of image */
    image = al_load_bitmap(fileloc.c_str());

    if (image) /* If no error occured: */{
        GLuint texId = al_get_opengl_texture(image);

        //glGenTextures(numTextures, &textureIds[i]); /* Texture name generation */
        glBindTexture(GL_TEXTURE_2D, texId); /* Binding of texture name */
        //redefine standard texture values
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); /* We will use linear
                                                                          interpolation for magnification filter */
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); /* We will use linear
                                                                          interpolation for minifying filter */
        textureIdMap[filename] = texId;
    } else {
        /* Error occured */
        std::cout << "Couldn't load Image: " << fileloc.c_str() << "\n";
    }
  }

  //Cleanup
  delete[] textureIds;

  //return success
  return true;
}

生成 VBO/VAO:
void Mesh::genVAOsAndUniformBuffer(const aiScene *sc) {
  struct MyMesh aMesh;
  struct MyMaterial aMat;
  GLuint buffer;

  // For each mesh
  for (unsigned int n = 0; n < sc->mNumMeshes; ++n){
    const aiMesh* mesh = sc->mMeshes[n];

    // create array with faces
    // have to convert from Assimp format to array
    unsigned int *faceArray;
    faceArray = (unsigned int *)malloc(sizeof(unsigned int) * mesh->mNumFaces * 3);
    unsigned int faceIndex = 0;

    for (unsigned int t = 0; t < mesh->mNumFaces; ++t) {
        const aiFace* face = &mesh->mFaces[t];

        memcpy(&faceArray[faceIndex], face->mIndices, 3 * sizeof(unsigned int));
        faceIndex += 3;
    }
    aMesh.numFaces = sc->mMeshes[n]->mNumFaces;

    // generate Vertex Array for mesh
    glGenVertexArrays(1, &(aMesh.vao));
    glBindVertexArray(aMesh.vao);

    // buffer for faces
    glGenBuffers(1, &buffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * mesh->mNumFaces * 3, faceArray, GL_STATIC_DRAW);

    // buffer for vertex positions
    if (mesh->HasPositions()) {
        glGenBuffers(1, &buffer);
        glBindBuffer(GL_ARRAY_BUFFER, buffer);
        glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * mesh->mNumVertices, mesh->mVertices, GL_STATIC_DRAW);
        glEnableVertexAttribArray(vertexLoc);
        glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, 0, 0, 0);
    }

    // buffer for vertex normals
    if (mesh->HasNormals()) {
        glGenBuffers(1, &buffer);
        glBindBuffer(GL_ARRAY_BUFFER, buffer);
        glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * mesh->mNumVertices, mesh->mNormals, GL_STATIC_DRAW);
        glEnableVertexAttribArray(normalLoc);
        glVertexAttribPointer(normalLoc, 3, GL_FLOAT, 0, 0, 0);
    }

    // buffer for vertex texture coordinates
    if (mesh->HasTextureCoords(0)) {
        float *texCoords = (float *)malloc(sizeof(float) * 2 * mesh->mNumVertices);
        for (unsigned int k = 0; k < mesh->mNumVertices; ++k) {
            texCoords[k * 2] = mesh->mTextureCoords[0][k].x;
            texCoords[k * 2 + 1] = mesh->mTextureCoords[0][k].y;
        }

        glGenBuffers(1, &buffer);
        glEnableVertexAttribArray(texCoordLoc);
        glBindBuffer(GL_ARRAY_BUFFER, buffer);

        glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 2 * mesh->mNumVertices, texCoords, GL_STATIC_DRAW);
        glVertexAttribPointer(texCoordLoc, 2, GL_FLOAT, GL_FALSE, 0, 0);
    }

    // unbind buffers
    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    // create material uniform buffer
    aiMaterial *mtl = sc->mMaterials[mesh->mMaterialIndex];

    aiString texPath;   //contains filename of texture
    if (AI_SUCCESS == mtl->GetTexture(aiTextureType_DIFFUSE, 0, &texPath)){
        //bind texture
        unsigned int texId = textureIdMap[texPath.data];
        aMesh.texIndex = texId;
        aMat.texCount = 1;
    } else {
        aMat.texCount = 0;
    }

    float c[4];
    set_float4(c, 0.8f, 0.8f, 0.8f, 1.0f);
    aiColor4D diffuse;
    if (AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_DIFFUSE, &diffuse))
        color4_to_float4(&diffuse, c);
    memcpy(aMat.diffuse, c, sizeof(c));

    set_float4(c, 0.2f, 0.2f, 0.2f, 1.0f);
    aiColor4D ambient;
    if (AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_AMBIENT, &ambient))
        color4_to_float4(&ambient, c);
    memcpy(aMat.ambient, c, sizeof(c));

    set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f);
    aiColor4D specular;
    if (AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_SPECULAR, &specular))
        color4_to_float4(&specular, c);
    memcpy(aMat.specular, c, sizeof(c));

    set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f);
    aiColor4D emission;
    if (AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_EMISSIVE, &emission))
        color4_to_float4(&emission, c);
    memcpy(aMat.emissive, c, sizeof(c));

    float shininess = 0.0;
    unsigned int max;
    aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS, &shininess, &max);
    aMat.shininess = shininess;

    glGenBuffers(1, &(aMesh.uniformBlockIndex));
    glBindBuffer(GL_UNIFORM_BUFFER, aMesh.uniformBlockIndex);
    glBufferData(GL_UNIFORM_BUFFER, sizeof(aMat), (void *)(&aMat), GL_STATIC_DRAW);

    myMeshes.push_back(aMesh);
  }
}

渲染模型:
void Mesh::recursive_render(const aiScene *sc, const aiNode* nd){
  // draw all meshes assigned to this node
  for (unsigned int n = 0; n < nd->mNumMeshes; ++n){
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, myMeshes[nd->mMeshes[n]].texIndex);

    // bind VAO
    glBindVertexArray(myMeshes[nd->mMeshes[n]].vao);

    // draw
    glDrawElements(GL_TRIANGLES, myMeshes[nd->mMeshes[n]].numFaces * 3, GL_UNSIGNED_INT, 0);
  }

  // draw all children
  for (unsigned int n = 0; n < nd->mNumChildren; ++n){
      recursive_render(sc, nd->mChildren[n]);
  }
}

任何其他相关代码部分都可以在我的开放 github 项目中找到 https://github.com/kwek20/StrategyGame/tree/master/Strategy

Mesh.cpp 是相关的,还有 main.cpp 和 Camera.cpp。

据我了解,我很好地遵循了指南,创建了 VAO,创建了 VBO,添加了数据并启用了正确的顶点数组属性来渲染场景。

我检查了所有数据变量,一切都按计划填写

这里的任何人都可以发现我犯的错误并或解释它吗?
由于我的限制,有些链接的输入很奇怪:(

最佳答案

如果您也发布了着色器,这将有所帮助。
如果对您有帮助,我可以发布一些带有纹理的渲染代码:
为opengl生成纹理并将具有宽度和高度的灰度(UC8)图像加载到GPU中

void GLRenderer::getTexture(unsigned char * image, int width, int height)
{
    glActiveTexture(GL_TEXTURE0);
    glGenTextures(1, &mTextureID);
    glBindTexture(GL_TEXTURE_2D, mTextureID);
    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGB8, width, height);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_BGR, GL_UNSIGNED_BYTE, image);

    if (aux::checkGlErrors(__LINE__, __FILE__))assert(false);
    glBindTexture(GL_TEXTURE_2D, 0);
}

将顶点从assimp加载到GPU上
    //** buffer a obj file-style model, initialize the VAO
void GLRenderer::bufferModel(float* aVertexArray, int aNumberOfVertices, float* aNormalArray, int aNumberOfNormals, float* aUVList, int aNumberOfUVs, unsigned int* aIndexList, int aNumberOfIndices)
{
    //** just to be sure we are current
    glfwMakeContextCurrent(mWin);

    //** Buffer all data in VBOs
    glGenBuffers(1, &mVertex_buffer_object);
    glBindBuffer(GL_ARRAY_BUFFER, mVertex_buffer_object);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * aNumberOfVertices * 3, aVertexArray, GL_STATIC_DRAW);
    glGenBuffers(1, &mNormal_buffer_object);
    glBindBuffer(GL_ARRAY_BUFFER, mNormal_buffer_object);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * aNumberOfNormals * 3, aNormalArray, GL_STATIC_DRAW);
    glGenBuffers(1, &mUV_buffer_object);
    glBindBuffer(GL_ARRAY_BUFFER, mUV_buffer_object);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * aNumberOfUVs * 2, aUVList, GL_STATIC_DRAW);
    glGenBuffers(1, &mIndex_buffer_object);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndex_buffer_object);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * aNumberOfIndices, aIndexList, GL_STATIC_DRAW);

    if (aux::checkGlErrors(__LINE__, __FILE__))assert(false);

    //** VAO tells our shaders how to match up data from buffer to shader input variables
    glGenVertexArrays(1, &mVertex_array_object);
    glBindVertexArray(mVertex_array_object);

    //** vertices first
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, mVertex_buffer_object);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

    //** normals next
    if (aNumberOfNormals > 0){
    glEnableVertexAttribArray(1);
    glBindBuffer(GL_ARRAY_BUFFER, mNormal_buffer_object);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    }
    //** UVs last
    if (aNumberOfUVs > 0){
    glEnableVertexAttribArray(2);
    glBindBuffer(GL_ARRAY_BUFFER, mUV_buffer_object);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    }
    //** indexing for reusing vertices in triangle-meshes
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndex_buffer_object);


    //** check errors and store the number of vertices
    if (aux::checkGlErrors(__LINE__, __FILE__))assert(false);
    mNumVert = aNumberOfVertices;
    mNumNormals = aNumberOfNormals;
    mNumUVs = aNumberOfUVs;
    mNumIndices = aNumberOfIndices;

}

上面的代码调用如下:
//read vertices from file
std::vector<float> vertex, normal, uv;
std::vector<unsigned int> index;
//assimp-wrapping function to load obj to vectors
aux::loadObjToVectors("Resources\\vertices\\model.obj", vertex, normal, index, uv);
mPtr->bufferModel(&vertex[0], static_cast<int>(vertex.size()) / 3, &normal[0], static_cast<int>(normal.size()) / 3, &uv[0], static_cast<int>(uv.size()) / 2, &index[0], static_cast<int>(index.size()));

然后是着色器部分:
在顶点着色器中,您只需手动通过 UV 坐标层
#version 400 core
layout (location = 0) in vec3 vertexPosition_modelspace;
layout (location = 1) in vec3 vertexNormal_modelspace;
layout (location = 2) in vec2 vertexUV;

out vec2 UV;

[... in main then ...]
UV = vertexUV;

在片段着色器中,您将值分配给像素:
#版本 400 核心
在 vec2 紫外线中;
统一采样器2D纹理采样器;
布局(位置 = 0)输出 vec4 输出颜色;
[...主要然后...]
//你可能也想在这里计算光照,所以这是获取内部纹理的最简单方法
outColor = vec4(texture2D(textureSampler, UV).rgb, cosAngle);
//您还可以使用以下方法检查 UV 坐标是否正确绑定(bind):
outColor = vec4(UV.x, UV.y,1,1);
//然后检查生成图像中的像素值(例如,将其渲染到 PBO,然后将其下载到 CPU 上)

在渲染循环中还要确保所有制服都正确绑定(bind)(尤其是与纹理相关的),并且纹理处于事件状态且已绑定(bind)
if (mTextureID != -1) {
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, mTextureID); 
}

GLint textureLocation = glGetUniformLocation(mShaderProgram, "textureSampler");
glUniform1i(textureLocation, 0);
//**set the poligon mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
//**drawElements because of indexing
glDrawElements(GL_TRIANGLES, mNumIndices, GL_UNSIGNED_INT, 0);

我希望我能帮助你!
亲切的问候,
VdoP

关于c++ - 使用 VAO/VBO 进行 OpenGL 模型/纹理渲染,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/31244785/

相关文章:

javascript - React 应用程序在发出 socketio 消息后变得缓慢渲染

c++ - Boost.Asio 的可扩展性

c++ - 是否有任何正当理由需要一种方法将R值引用作为输入?

c++ - 基于鼠标选择Opengl拖动对象

c++ - "R6025 - pure virtual call"在显示列表、OpenGL、C++

opengl - GPU 如何同时支持 OpenGL 和 DirectX API 执行?

audio - WASAPI呈现保存的音频文件

c++ - PostMessage : How to post a message to a process that does not have a window?

c++ - 如何在 vector 中搜索结构项?

c# - 解决上下颠倒的渲染?