OpenGL渲染时必要数据的简单总结，Assimp数据结构&模型文件导入

渲染时必要数据：

• shader是   最终执行渲染的程序，检查shader的input接口，可以得到渲染所需数据：
  • vertexShader: 具体代码详见 > UV坐标，2D贴图，冯氏光照模型和材质
    • layout (location = 0) in vec3 vertexPos           
    • layout (location = 1) in vec3 Normal;        
    • layout (location = 2) in vec2 TexCoords;
      • 来自 vertexArrayBuffer，以顶点为单位，一次仅汇入一个顶点的相关数据

• • • uniform mat4 modelTransMatrix
    • uniform mat4 viewTransMatrix
    • uniform mat4 projectionTransMatrix
      • 直接来自 [外部代码] ，通过：glUniform1i(glGetUniformLocation(shaderID, name.c_str()), value);
      • 此处使用 的glUniform1i，仅支持灌入一个int值，如需灌入mat4，则需使用：

• • • • • glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
        • 不同于单一int值，Matrix4是聚合值，需要给出首地址。

• • • • 向shaderID标识的shaderProgram中的  名为name.c_str()的uniform栏位灌入值。

• • fragmentShader: 具体代码详见 > UV坐标，2D贴图，冯氏光照模型和材质

• • • in vec3 FragPos > 经变换后的 vertexPos，来自vertexShader
    • in vec3 Normal > 经变换 [防止缩放后走形] 后的 Normal，来自vertexShader
    • in vec2 TexCoord > 来自vertexShader的UV值，因为UV值来自vertexArrayBuffer，所以只能先由vertexShader代为缓冲。
    • uniform vec3 viewPos > 摄像机在 [世界空间坐标系] 中的坐标。

• • • uniform Material material;
    • struct Material {

          sampler2D diffuse;

          sampler2D specular;    

          float shininess;

      };
    • 本次所绘制片元的材质，如果此片元没有specular材质，则无需装填specular
    • 相应的，若specular默认为空，则【specular光照渲染值 = 0】不生效。

• • • • 当一个网格拥有多个贴图时(多个片元共用一个贴图，可以是共取贴图的不同部分)
      • 需要的specular&diffuseTexture，就不止一个，当然，shininess也可能会有不同。
        • struct Material {
        •        sampler2D diffuse;
        • 　　sampler2D diffuse2;
        •        sampler2D ...
        • 　   sampler2D specular;
        • 　　float shininess;
        • 　　sampler2D specular2;
        • 　　float shininess;
        •        ...
        • };
      • 但本次仅考虑一组的情况。

• • • uniform Light light;
      • struct Light {

            vec3 position;

        
        

            vec3 ambient;

            vec3 diffuse;

            vec3 specular;

        };
      • 此片元受到的光照，无论此片元是否有 specularTexture，都应装填 specularLight(vec3)
      • 因为，虚拟现实与真实世界>理应是一样  光源是的公用的，仅在材质上做区分即可。

 

Assimp数据结构：

• 如图：

　　

• Assimp数据结构解释：
  • Scene | aiScene* > 指向场景内全部数据的指针

• • • mRootNode | aiNode* > 场景内所有节点的父节点的  指针 

• • • • mChildren | aiNode** > 子节点指针  的聚合体
        • mChildren* (其中一个子节点指针)

• • • • • • mChildren | aiNode** >子节点指针的聚合体
            • mChildren* > 其中一个子节点指针
            • 。。。
          • mMeshes | unsigned int*

• • • • mMeshes | unsigned int* 每个子节点指针  对应网格的 [线性索引]。
        • 使用这个索引对应在Scene -> mMeshes内查找 该节点层级所包含的网格数据  的地址。

• • • mMeshes | aiMesh** > 网格数据指针  的聚合体。　
      • aiMesh：
        • mVertices | aiVector3D*(aiVector3t<float>*) 
        • mNormals | aiVector3D*(aiVector3t<float>*) 
        • mTextureCoords | aiVector3D*(aiVector3t<float>*) 
          • 因为存在 3D贴图，所以预置 3个维度：UVT
          • 2D贴图时，仅前两个分量有值，载入时，也仅使用前两个分量。
        • mFaces | aiFace*
          • 顶点索引。
          • mIndices | unsigned int*
          • mNumIndices | unsigned int
        • mMaterialIndex > 材质信息索引，来自Scene > mMaterials

• • •  mMaterials | aiMaterial** > 材质信息指针 的聚合体
      • aiMaterial:
        • mNumAllocated | unsigned int
        • mNumProperties | unsigned int
        • mProperties | aiMaterialProperty**
          • aiMateralProperty:
            • mData | char*
            • mDataLength | unsigned int
            • mIndex | unsigned int > 索引
            • mKey | aiString
            • mSemantic | unsigned int  > 贴图文件
            • mType | aiPropertyTypeInfo > 贴图文件类型

 

• 使用Assimp加载数据：

• // read file via ASSIMP
  Assimp::Importer importer;
  const aiScene* scene = importer.ReadFile(
      /*-------模型文件路径-------*/
      path, 
      /*-------aiPostProcessSteps(enums)--------*/
      /*此标志存在的目的是：如果模型文件成功加载，则按照以下flags执行操作*/
      aiProcess_Triangulate          //将所有的索引模式，都转化为三角形片元模式
      | aiProcess_GenSmoothNormals   //为所有顶点创建平滑法线，如果源文件中已经存在法线，则忽略此标志 
      | aiProcess_FlipUVs            //沿Y轴翻转所有UV坐标，主要是为了防止贴图方向加载出错，如果方向正确，则不要使用此flags
      | aiProcess_CalcTangentSpace   //为导入的网格计算切线和双切线，此处暂时还未用到，洒家也不懂，以后再说吧。
  
  );
  
  // check for errors
  if(!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) // if is Not Zero
  {
      cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << endl;
      return;
  }

   

• aiPostProcessSteps的详细信息见 AssimpDoc_AiPostProcessSteps

• 加载Assimp数据到代码文件中：
  • 自定义vertexDatapack_Single：用以封装单个顶点的相关数据

  • struct Vertex {
        glm::vec3 Position;
        glm::vec3 Normal;
        glm::vec2 TexCoords;
    };

 

• • 自定义textureDatapack_Single：用以封装单个贴图的相关数据

  • struct Texture {
        unsigned int id;    //textureID
        string type;        //Specular | Diffuse
    };

  • 自定义mesh类型：

  •     class Mesh {
        public:
            /*  网格数据  */
            vector<Vertex> vertices;
            vector<unsigned int> indices;
            vector<Texture> textures;
            /*  函数  */
            Mesh(vector<Vertex> vertices, vector<unsigned int> indices, vector<Texture> textures);
            void Draw(Shader shader);
        private:
            /*  渲染数据  */
            unsigned int VAO, VBO, EBO;
            /*  函数  */
            void setupMesh();
        };
    
        Mesh(vector<Vertex> vertices, vector<unsigned int> indices, vector<Texture> textures)
        {
            this->vertices = vertices;
            this->indices = indices;
            this->textures = textures;
    
            setupMesh();
        }
    
        void setupMesh()
        {
            glGenVertexArrays(1, &VAO);
            glGenBuffers(1, &VBO);
            glGenBuffers(1, &EBO);
    
            glBindVertexArray(VAO);
    
            glBindBuffer(GL_ARRAY_BUFFER, VBO);
            glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);  
    
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), 
                         &indices[0], GL_STATIC_DRAW);
    
            // 顶点位置
            glEnableVertexAttribArray(0);   
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
            // 顶点法线
            glEnableVertexAttribArray(1);   
            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal));
            // 顶点纹理坐标
            glEnableVertexAttribArray(2);   
            glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords));
    
            glBindVertexArray(0);
        }
    
        void Draw(Shader shader) 
        {
            unsigned int diffuseNr = 1;
            unsigned int specularNr = 1;
            for(unsigned int i = 0; i < textures.size(); i++)
            {
                glActiveTexture(GL_TEXTURE0 + i); // 在绑定之前激活相应的纹理单元
                
                // 获取纹理序号（diffuse_textureN 中的 N）
                string number;
                string name = textures[i].type;
                if(name == "texture_diffuse")
                    number = std::to_string(diffuseNr++);
                else if(name == "texture_specular")
                    number = std::to_string(specularNr++);
    
                shader.setFloat(("material." + name + number).c_str(), i);
                glBindTexture(GL_TEXTURE_2D, textures[i].id);
            }
            glActiveTexture(GL_TEXTURE0);
    
            // 绘制网格
            glBindVertexArray(VAO);
            glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
            glBindVertexArray(0);
        }

  • mesh是model中的一个层级，可视为 [子model] 是模型文件的最小单位。
  • 你也可以认为model就是一个巨型mesh，而此mesh可以分块绘制。
  • 此处的mesh仅考虑自身仅包含 specularTexture | diffuseTexture 的情况。

• • 自定义model类型：

  •     class Model 
        {
            public:
                /*  函数   */
                Model(char *path)
                {
                    loadModel(path);
                }
                void Draw(Shader shader);   
            private:
                vector<Texture> textures_loaded;
                /*  模型数据  */
                vector<Mesh> meshes;
                string directory;
                /*  函数   */
                void loadModel(string path);
                void processNode(aiNode *node, const aiScene *scene);
                Mesh processMesh(aiMesh *mesh, const aiScene *scene);
                vector<Texture> loadMaterialTextures(aiMaterial *mat, aiTextureType type, 
                                                     string typeName);
        };
    
        Mesh processMesh(aiMesh *mesh, const aiScene *scene)
        {
            // data to fill
            vector<Vertex> vertices;
            vector<unsigned int> indices;
            vector<Texture> textures;
    
            // walk through each of the mesh's vertices
            for(unsigned int i = 0; i < mesh->mNumVertices; i++)
            {
                Vertex vertex;
                glm::vec3 vector; 
                // positions
                vector.x = mesh->mVertices[i].x;
                vector.y = mesh->mVertices[i].y;
                vector.z = mesh->mVertices[i].z;
                vertex.Position = vector;
                // normals
                if (mesh->HasNormals())
                {
                    vector.x = mesh->mNormals[i].x;
                    vector.y = mesh->mNormals[i].y;
                    vector.z = mesh->mNormals[i].z;
                    vertex.Normal = vector;
                }
                // texture coordinates
                if(mesh->mTextureCoords[0]) // does the mesh contain texture coordinates?
                {
                    glm::vec2 vec;
                    // a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't 
                    // use models where a vertex can have multiple texture coordinates so we always take the first set (0).
                    vec.x = mesh->mTextureCoords[0][i].x; 
                    vec.y = mesh->mTextureCoords[0][i].y;
                    vertex.TexCoords = vec;
                    // tangent
                    vector.x = mesh->mTangents[i].x;
                    vector.y = mesh->mTangents[i].y;
                    vector.z = mesh->mTangents[i].z;
                    vertex.Tangent = vector;
                    // bitangent
                    vector.x = mesh->mBitangents[i].x;
                    vector.y = mesh->mBitangents[i].y;
                    vector.z = mesh->mBitangents[i].z;
                    vertex.Bitangent = vector;
                }
                else
                    vertex.TexCoords = glm::vec2(0.0f, 0.0f);
    
                vertices.push_back(vertex);
            }
            // now wak through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices.
            for(unsigned int i = 0; i < mesh->mNumFaces; i++)
            {
                aiFace face = mesh->mFaces[i];
                // retrieve all indices of the face and store them in the indices vector
                for(unsigned int j = 0; j < face.mNumIndices; j++)
                    indices.push_back(face.mIndices[j]);        
            }
            // process materials
            aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];    
            // we assume a convention for sampler names in the shaders. Each diffuse texture should be named
            // as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER. 
            // Same applies to other texture as the following list summarizes:
            // diffuse: texture_diffuseN
            // specular: texture_specularN
            // normal: texture_normalN
    
            // 1. diffuse maps
            vector<Texture> diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse");
            textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
            // 2. specular maps
            vector<Texture> specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular");
            textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
            // 3. normal maps
            std::vector<Texture> normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal");
            textures.insert(textures.end(), normalMaps.begin(), normalMaps.end());
            // 4. height maps
            std::vector<Texture> heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height");
            textures.insert(textures.end(), heightMaps.begin(), heightMaps.end());
            
            // return a mesh object created from the extracted mesh data
            return Mesh(vertices, indices, textures);
        }
    
        // checks all material textures of a given type and loads the textures if they're not loaded yet.
        // the required info is returned as a Texture struct.
        vector<Texture> loadMaterialTextures(aiMaterial *mat, aiTextureType type, string typeName)
        {
            vector<Texture> textures;
            for(unsigned int i = 0; i < mat->GetTextureCount(type); i++)
            {
                aiString str;
                mat->GetTexture(type, i, &str);
                // check if texture was loaded before and if so, continue to next iteration: skip loading a new texture
                bool skip = false;
                for(unsigned int j = 0; j < textures_loaded.size(); j++)
                {
                    if(std::strcmp(textures_loaded[j].path.data(), str.C_Str()) == 0)
                    {
                        textures.push_back(textures_loaded[j]);
                        skip = true; // a texture with the same filepath has already been loaded, continue to next one. (optimization)
                        break;
                    }
                }
                if(!skip)
                {   // if texture hasn't been loaded already, load it
                    Texture texture;
                    texture.id = TextureFromFile(str.C_Str(), this->directory);
                    texture.type = typeName;
                    texture.path = str.C_Str();
                    textures.push_back(texture);
                    textures_loaded.push_back(texture);  // store it as texture loaded for entire model, to ensure we won't unnecesery load duplicate textures.
                }
            }
            return textures;
        }
    };
    
    
    unsigned int TextureFromFile(const char *path, const string &directory, bool gamma)
    {
        string filename = string(path);
        filename = directory + '/' + filename;
    
        unsigned int textureID;
        glGenTextures(1, &textureID);
    
        int width, height, nrComponents;
        unsigned char *data = stbi_load(filename.c_str(), &width, &height, &nrComponents, 0);
        if (data)
        {
            GLenum format;
            if (nrComponents == 1)
                format = GL_RED;
            else if (nrComponents == 3)
                format = GL_RGB;
            else if (nrComponents == 4)
                format = GL_RGBA;
    
            glBindTexture(GL_TEXTURE_2D, textureID);
            glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
            glGenerateMipmap(GL_TEXTURE_2D);
    
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    
            stbi_image_free(data);
        }
        else
        {
            std::cout << "Texture failed to load at path: " << path << std::endl;
            stbi_image_free(data);
        }
    
        return textureID;
    }

  • 加载贴图时，尚考虑了 法线贴图 和  高程贴图(高程纹理)，但这些都暂时未使用。