因为本案例只是获取了模型的顶点，法线，uv，纹理。因为我们还没研究光照暂时先拿到这些去研究Phong Lighting Model着色已经足够，到研究漫反射和镜面反射贴图再来完善。

大型模型都是有很多个mesh对象构成如learnOpengl中说到一栋别墅，会有游泳池，石柱等这些小的模型组装出来的，而这些小的模型就叫做mesh对象，。因此先来写mesh对象
MyMesh .h

#pragma once
#include"vector"
#include "MyShader.h"
#include"Camera.h"
using namespace std;
struct Vertex
{
    QVector3D Position;
    QVector3D Normal;
    QVector2D TexCoords;
};
struct Texture {
    GLint id;
    QString type;
    QString path;
};
class MyMesh : protected QOpenGLFunctions_4_3_Core
{
public:
    vector<Vertex> vertices;//顶点属性向量
    vector<GLuint>indices;//索引向量
    vector<Texture>textures;//纹理属性向量
//一个网格对象需要顶点，索引和纹理，这是一般建模软件的结构建模网格的数据结构
    MyMesh(vector<Vertex> vertices, vector<GLuint> indices, vector<Texture> texture);
    void init(QOpenGLShaderProgram* shaderProgram);
    void draw(Camera camera);
    void setLocation(float x,float y,float z);
private:
    float locationX=0.0f, locationY=0.0f, locationZ=-7.0f;
    QMatrix4x4 mv;
    QOpenGLShaderProgram* shaderProgram;
    QOpenGLVertexArrayObject vao;
    QOpenGLBuffer vbo,ebo;
    GLuint vPosition,normal,uv, mv_loc;
};

MyMesh.cpp

#include "stdafx.h"
#include "MyMesh.h"
MyMesh::MyMesh(vector<Vertex> vertices, vector<GLuint> indices, vector<Texture> textures): ebo(QOpenGLBuffer::IndexBuffer)
{
    this->vertices = vertices;
    this->indices = indices;
    this->textures = textures;
}
void MyMesh::init(QOpenGLShaderProgram* shaderProgram)
{
    initializeOpenGLFunctions();
    this->shaderProgram = shaderProgram;
    shaderProgram->bind();
    vao.create();
    vbo.create();
    ebo.create();
    vao.bind();
    vbo.bind();
    vbo.setUsagePattern(QOpenGLBuffer::StaticDraw);
    vbo.allocate(&vertices[0], this->vertices.size() * sizeof(Vertex));
    // 设置顶点坐标指针
    vPosition = shaderProgram->attributeLocation("vPosition");
    shaderProgram->setAttributeBuffer(vPosition, GL_FLOAT, 0, 3, sizeof(Vertex));
    glEnableVertexAttribArray(vPosition);
    // 设置法线指针
    normal= shaderProgram->attributeLocation("normal");
    shaderProgram->setAttributeBuffer("normal", GL_FLOAT, offsetof(Vertex, Normal), 3, sizeof(Vertex));//shader变量索引，参数类型，偏移量，元素大小，步长
    glEnableVertexAttribArray(normal);
    // 设置顶点的纹理坐标
    uv = shaderProgram->attributeLocation("uv");
    shaderProgram->setAttributeBuffer(uv, GL_FLOAT, offsetof(Vertex, TexCoords), 2, sizeof(Vertex));
    glEnableVertexAttribArray(uv);
    ebo.bind();
    ebo.setUsagePattern(QOpenGLBuffer::StaticDraw);
    ebo.allocate(&this->indices[0], this->indices.size() * sizeof(GLuint));
    vao.release();
    ebo.release();
    vbo.release();
    shaderProgram->release();
    vertices.clear();
}
void MyMesh::draw(Camera camera) {
    shaderProgram->bind();
    mv_loc = shaderProgram->uniformLocation("mv_matrix");
    //构建视图矩阵
    QMatrix4x4 m;
    m.translate(locationX, locationY, locationZ);
    QMatrix4x4 v;
    v.lookAt(QVector3D(camera.location.x, camera.location.y, camera.location.z),
        QVector3D(camera.viewPoint.x, camera.viewPoint.y, camera.viewPoint.z),
        QVector3D(camera.worldY.x, camera.worldY.y, camera.worldY.z));
    mv = v * m;
    shaderProgram->setUniformValue(mv_loc, mv);
    vao.bind();
    glDrawElements(GL_TRIANGLES, this->indices.size(), GL_UNSIGNED_INT, 0);
    vao.release();
    shaderProgram->release();
}
void MyMesh::setLocation(float x, float y, float z) {
    locationX = x;
    locationY = y;
    locationZ = z;
}

之所以选择结构体，是因为c++的结构体类型中的变量是连续的，因此很容易知道他的大小如：

struct Vertex
{
QVector3D Position;
QVector3D Normal;
QVector2D TexCoords;
};
他的大小就是sizeof(Vertex);
offsetof(Vertex, TexCoords)函数能自动运算出变量间的偏移量。第一个参数是结构体名，第二个参数是哪一个变量名，返回要便宜的量。

接着就可以获取模型数据了。

Model.h

#include "assimp/scene.h"
#include "assimp/postprocess.h"
#include "MyMesh.h"
#include"iostream"
using namespace std;
class Model
{
public:
    /*  成员函数   */
    Model();
    ~Model();
    void draw(Camera camera);
    void init(string path, QOpenGLShaderProgram* shaderProgram);
    void setModelLocation(QVector3D location);
private:
    ///*  模型数据  */
    vector<MyMesh*> meshes;
    QString directory;
    QOpenGLShaderProgram* shaderProgram;
    ///*  私有成员函数   */
    void loadModel(string path);
    void processNode(aiNode* node, const aiScene* scene);
    MyMesh* processMesh(aiMesh* mesh, const aiScene* scene);
   vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, QString typeName);
};

Model.cpp

#include "stdafx.h"
#include "Model.h"
Model::Model(){
   
}
Model::~Model() {
    meshes.clear();
}
void Model::init(string path, QOpenGLShaderProgram* shaderProgram) {
    this->shaderProgram = shaderProgram;
    loadModel(path);
}
void Model::setModelLocation(QVector3D location) {
    for (GLuint i = 0; i < this->meshes.size(); i++)
    {
        this->meshes[i]->setLocation(location.x(), location.y(), location.z());
    }
}
void Model::draw(Camera camera)
{
    for (GLuint i = 0; i < this->meshes.size(); i++)
    {
        this->meshes[i]->draw(camera);
    }
}
void Model::loadModel(string path)
{
    Assimp::Importer import;
    const aiScene* scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);

    if (!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
    {
        qDebug() << "ERROR::ASSIMP::" << import.GetErrorString() << endl;
        return;
    }
    this->directory =QString::fromStdString(path.substr(0, path.find_last_of('/')));
    //qDebug() <<"directory:"<< directory;//全路径
    this->processNode(scene->mRootNode, scene);
}
void Model::processNode(aiNode* node, const aiScene* scene)
{
    // 添加当前节点中的所有Mesh
    //qDebug() << "mNumMeshes:"<<node->mNumMeshes;
    for (GLuint i = 0; i < node->mNumMeshes; i++)
    {
        aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
        this->meshes.push_back(this->processMesh(mesh, scene));
    }
    // 递归处理该节点的子孙节点
    //qDebug() << "mNumChildren:" << node->mNumChildren;
    for (GLuint i = 0; i < node->mNumChildren; i++)
    {
        this->processNode(node->mChildren[i], scene);
    }
}
MyMesh* Model::processMesh(aiMesh* mesh, const aiScene* scene)
{
    vector<Vertex> vertices;
    vector<GLuint> indices;
    vector<Texture> textures;
    //qDebug() << "mNumVertices:" << mesh->mNumVertices;
    for (GLuint i = 0; i < mesh->mNumVertices; i++)
    {
        Vertex vertex;
        // 处理顶点坐标、法线和纹理坐标
        vertex.Position.setX(mesh->mVertices[i].x);
        vertex.Position.setY(mesh->mVertices[i].y);
        vertex.Position.setZ(mesh->mVertices[i].z);
        vertex.Normal.setX(mesh->mNormals[i].x);
        vertex.Normal.setY(mesh->mNormals[i].y);
        vertex.Normal.setZ(mesh->mNormals[i].z);
        if (mesh->mTextureCoords[0]) // Does the mesh contain texture coordinates?
        {
            vertex.TexCoords.setX(mesh->mTextureCoords[0][i].x);
            vertex.TexCoords.setY(mesh->mTextureCoords[0][i].y);
        }
        else { vertex.TexCoords.setX(0.0);
        vertex.TexCoords.setY(0.0);}
        vertices.push_back(vertex);
    }

    // 处理顶点索引
    //qDebug() << "mNumFaces:" << mesh->mNumFaces;
    for (GLuint i = 0; i < mesh->mNumFaces; i++)
    {
        aiFace face = mesh->mFaces[i];
        
        for (GLuint j = 0; j < face.mNumIndices; j++)
        {
            indices.push_back(face.mIndices[j]);
        }
    }

     //处理材质
    if(mesh->mMaterialIndex >= 0)
    {
        aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
        vector<Texture> diffuseMats = this->loadMaterialTextures(material,
            aiTextureType_DIFFUSE, "texture_diffuse");
        textures.insert(textures.end(), diffuseMats.begin(), diffuseMats.end());//把区间[start,end]插入到迭代器的指定位置
        vector<Texture> specularMats = this->loadMaterialTextures(material,
            aiTextureType_SPECULAR, "texture_specular");
        textures.insert(textures.end(), specularMats.begin(), specularMats.end());
    }

    MyMesh* myMesh = new  MyMesh( vertices, indices, textures);
    myMesh->init(shaderProgram);
    return myMesh;
}

vector<Texture> Model::loadMaterialTextures(aiMaterial* mat, aiTextureType type, QString typeName)
{
    vector<Texture> textures;
    if (mat->GetTextureCount(type) == 0) {//没有纹理我们也创建一个空的，避免纹理不更新，被上次的覆盖。
        cout<< typeName <<":no find texture"<<endl;
        Texture texture;
        texture.id = 0;
        texture.type = typeName;
        texture.fileName = "no";
        textures.push_back(texture);
        return textures;
    }
    for (GLuint i = 0; i < mat->GetTextureCount(type); i++)
    {
        aiString folderPath;
        mat->GetTexture(type, i, &folderPath);
        qDebug() << "folderPath:" << folderPath.C_Str();
        GLboolean skip = false;
        for (GLuint j = 0; j < textures.size(); j++)
        {
            if (textures[j].path == folderPath.C_Str())
            {
                textures.push_back(textures[j]);
                skip = true;
                break;
            }
        }
        if (!skip)
        {   // 如果纹理没有被加载过，加载之
            Texture texture;
            QString fileName = this->directory;
            fileName += '/';
            fileName += folderPath.C_Str();
            qDebug() << fileName;
            QOpenGLTexture loadTexture(QImage(fileName).mirrored());
            texture.id = loadTexture.textureId();
            texture.type = typeName;
            texture.path = folderPath.C_Str();
            textures.push_back(texture);
        }
    }
    return textures;
}

前面一章说的比较清楚对于节点中的内容，这里就不解释了

使用

Model model;
MyShader shaderModel;
//注意我们前面写好的着色器类，添加新的着色器就ok了 
shaderModel.creatShader(":/QtGuiApplication1/Resources/config/shaderMode.vs",":/QtGuiApplication1/Resources/config/shaderMode.fs");
  QString fileName = QDir::currentPath();//当前工作路径
    fileName += "/Resources/model/Sphere.obj";
    mt.init(shaderModel.getShader());
    model.init(fileName.toStdString(), shaderModel.getShader());
    model.setModelLocation(QVector3D(-2.0,0.0,-4.0));

 model.draw(camera);

这时我们按照前面章节讲的添加一个新的着色器，且只包含顶点，和颜色（红色）。
效果：

image.png
出现了球体，因为模型里没有没有纹理贴图数据，所以我给了个红色在shader中。
球体模型，单独的纹理提取
链接：https://pan.baidu.com/s/1Z2Rft6otGfYLcr7bBt6KCw
提取码：jsdd
复制这段内容后打开百度网盘手机App，操作更方便哦
修改着色器代码：
shaderMode.vs

#version 430 
uniform mat4 mv_matrix;
uniform mat4 proj_matrix;
in vec3 vPosition;
in vec3 normal;
in vec2 uv;
out vec2 texcoord;
void main(void)
{
gl_Position=proj_matrix*mv_matrix*vec4(vPosition,1.0);
texcoord=uv;
}

shaderMode.fs

#version 430 
out vec4 color;
uniform mat4 mv_matrix;
uniform mat4 proj_matrix;
uniform sampler2D textureID;
in vec2 texcoord;
void main(void) 
{
color =texture(textureID,texcoord) ;
}

然后我们自己添加一张纹理：
myMesh.h添加

QOpenGLTexture texture;

.cpp中启用这张纹理：（注意初始化在构造函数列表中了）

#include "stdafx.h"
#include "MyMesh.h"
MyMesh::MyMesh(vector<Vertex> vertices, vector<GLuint> indices, vector<Texture> textures): ebo(QOpenGLBuffer::IndexBuffer), texture(QImage("./Resources/model/earth.bmp"))
{
    this->vertices = vertices;
    this->indices = indices;
    this->textures = textures;
}
void MyMesh::init(QOpenGLShaderProgram* shaderProgram)
{
    initializeOpenGLFunctions();
    this->shaderProgram = shaderProgram;
    shaderProgram->bind();
    vao.create();
    vbo.create();
    ebo.create();
    vao.bind();
    vbo.bind();
    vbo.setUsagePattern(QOpenGLBuffer::StaticDraw);
    vbo.allocate(&vertices[0], this->vertices.size() * sizeof(Vertex));
    // 设置顶点坐标指针
    vPosition = shaderProgram->attributeLocation("vPosition");
    shaderProgram->setAttributeBuffer(vPosition, GL_FLOAT, 0, 3, sizeof(Vertex));
    glEnableVertexAttribArray(vPosition);
    // 设置法线指针
    normal= shaderProgram->attributeLocation("normal");
    shaderProgram->setAttributeBuffer("normal", GL_FLOAT, offsetof(Vertex, Normal), 3, sizeof(Vertex));//shader变量索引，参数类型，偏移量，元素大小，步长
    glEnableVertexAttribArray(normal);
    // 设置顶点的纹理坐标
    uv = shaderProgram->attributeLocation("uv");
    shaderProgram->setAttributeBuffer(uv, GL_FLOAT, offsetof(Vertex, TexCoords), 2, sizeof(Vertex));
    glEnableVertexAttribArray(uv);
    ebo.bind();
    ebo.setUsagePattern(QOpenGLBuffer::StaticDraw);
    ebo.allocate(&this->indices[0], this->indices.size() * sizeof(GLuint));
    vao.release();
    ebo.release();
    vbo.release();
    shaderProgram->release();
    vertices.clear();
}
void MyMesh::draw(Camera camera) {
    shaderProgram->bind();
    texture.bind(texture.textureId());
    shaderProgram->setUniformValue("textureID", texture.textureId());
    mv_loc = shaderProgram->uniformLocation("mv_matrix");
    //构建视图矩阵
    QMatrix4x4 m;
    m.translate(locationX, locationY, locationZ);
    QMatrix4x4 v;
    v.lookAt(QVector3D(camera.location.x, camera.location.y, camera.location.z),
        QVector3D(camera.viewPoint.x, camera.viewPoint.y, camera.viewPoint.z),
        QVector3D(camera.worldY.x, camera.worldY.y, camera.worldY.z));
    mv = v * m;
    shaderProgram->setUniformValue(mv_loc, mv);
    vao.bind();
    glDrawElements(GL_TRIANGLES, this->indices.size(), GL_UNSIGNED_INT, 0);
    vao.release();
    texture.release();
    shaderProgram->release();
}
void MyMesh::setLocation(float x, float y, float z) {
    locationX = x;
    locationY = y;
    locationZ = z;
}

效果：

image.png

这时我们shader中有了法线就可以研究冯氏（Phong）光照模型了。

目录

VSC++2019+QT+OpenGL
QT+OpenGL一之绘制立方体（三角形图元）
QT+OpenGL二之纹理贴图
QT+OpenGL三之矩阵简解
QT+OpenGL四之相机的移动和旋转
QT+OpenGL五之绘制不同的模型（vao,vbo机制）
QT+OpenGL六之天空盒
QT+OpenGL七之使用EBO
QT+OPenGL八之模型准备
QT+OPenGL九之模型解码
QT+OPenGL十之光照模型
QT+OPenGL十一之漫反射和镜面反射贴图
QT+OPenGL十二之定向光
QT+OPenGL十三之真正的点光源和聚光灯
QT+OPenGL十四之多光源混合的问题
QT+OPenGL十五之深度缓冲区
QT+OPenGL十六之模板缓冲区
QT+OPenGL十七帧缓冲区（离屏渲染）
QT+OPenGL十八抗锯齿
QT+OPenGL十九镜面反射效率调整
QT+OPenGL二十Gamma校正