前言

一个模型通常是由三个部分组成：网格、纹理、材质。在一开始的时候，我们是通过Geometry类来生成简单几何体的网格。但现在我们需要寻找合适的方式去表述一个复杂的网格，而且包含网格的文件类型多种多样，对应的描述方式也存在着差异。这一章我们主要研究obj格式文件的读取。

纹理映射回顾

DirectX11 With Windows SDK完整目录

Github项目源码

.obj格式

.obj格式是Alias|Wavefront公司推出的一种模型文件格式，通常以文本形式进行描述，因此你可以按记事本来打开查看里面的内容。通过市面上的一些常见的建模软件如3dsMax，Maya等都可以导出.obj文件。一些游戏引擎如Unity3d也支持导入.obj格式的模型。该文件可以直接描述多边形、法向量、纹理坐标等等信息。

.obj文件结构简述

.obj文件内部的每一行具体含义取决于开头以空格、制表符分隔的关键字是什么。这里只根据当前项目需要的部分来描述关键字

顶点数据：

元素：

组合：

材质：

.mtl文件结构简述

.mtl文件内部描述方式和.obj文件一样，但里面使用的关键字有所不同

材质描述：

简单示例

现在要通过.obj文件来描述一个平面正方形草丛。ground.obj文件如下：

mtllib ground.mtl

v -10.0 -1.0 -10.0
v -10.0 -1.0 10.0
v 10.0 -1.0 10.0
v 10.0 -1.0 -10.0

vn 0.0 0.0 -1.0

vt 0.0 0.0
vt 0.0 5.0
vt 5.0 5.0
vt 5.0 0.0

g Square
usemtl TestMat
f 1/1/1 2/2/1 3/3/1
f 3/3/1 4/4/1 1/1/1
# 2 faces

其中根据v的先后出现顺序，对应的索引为1到4。若索引值为3，则对应第3行v对应的顶点

注意: 索引的初始值在.obj中为1，而不是0！

而诸如1/1/1这样的三索引对应的含义为：顶点坐标索引/纹理坐标索引/法向量索引

若写成1//1，则表明不使用纹理坐标，但现在在我们的项目中不允许缺少上面任何一种索引

这样在一个f里面出现顶点坐标索引/纹理坐标索引/法向量索引的次数说明了该面的顶点数目，目前我们也仅考虑支持三角形面

一个模型最少需要包含一个组或一个对象

注意：.obj纹理坐标是基于笛卡尔坐标系的，即(0.3, 0.7)对应的是实际的纹理坐标(0.3, 0.3)，即需要做(x, 1.0 – y)的变换

而.mtl文件的描述如下

newmtl TestMat
    d 1.0000
    Ns 10.0000
    Ka 0.8000 0.8000 0.8000
    Kd 0.3000 0.3000 0.3000
    Ks 0.0000 0.0000 0.0000
    map_Ka grass.dds
    map_Kd grass.dds

漫反射和环境光反射都将使用同一种纹理。

使用自定义二进制数据格式提升读取效率

使用文本类型的.obj格式文件进行读取的话必然要面临一个比较严重的问题：模型网格的面数较多会导致文本量极大，直接读取.obj的效率会非常低下。通常推荐在第一次读取.obj文件导入到程序后，再将读取好的顶点等信息以二进制文件的形式合理安排内容布局并保存，然后下次运行的时候读取该二进制文件来获取模型信息，可以大幅度加快读取速度，并且节省了一定的内存空间。

现在来说明下当前项目下自定义二进制格式.mbo的字节布局：

// [Part数目] 4字节
// [AABB盒顶点vMax] 12字节
// [AABB盒顶点vMin] 12字节
// [Part
//   [环境光材质文件名]520字节
//   [漫射光材质文件名]520字节
//   [材质]64字节
//   [顶点数]4字节
//   [索引数]4字节
//   [顶点]32*顶点数 字节
//   [索引]2(或4)*索引数 字节，取决于顶点数是否不超过65535
// ]
// ...

这里将.obj中的一个组或一个对象定义为.mbo格式中的一个模型部分，然后顶点使用的是VertexPosNormalTex类型，大小为32字节。索引使用WORD或DWORD类型，若当前Part不同的顶点数超过65535，则必须使用DWORD类型来存储索引。

环境光/漫射光材质文件名使用的是wchar_t[MAX_PATH]的数组，大小为2*260字节。

但要注意一开始从.obj导出的顶点数组是没有经过处理（包含重复顶点），需要通过一定的操作分离出顶点数组和索引数组才能传递给.mbo格式。

ObjReader–读取.obj/.mbo格式模型

ObjReader.h中包含了ObjReader类和MtlReader类：

#ifndef OBJREADER_H
#define OBJREADER_H

#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <unordered_map>
#include <map>
#include <algorithm>
#include <locale>
#include <filesystem>
#include "Vertex.h"
#include "LightHelper.h"


class MtlReader;

class ObjReader
{
public:
    struct ObjPart
    {
        Material material;                          // 材质
        std::vector<VertexPosNormalTex> vertices;   // 顶点集合
        std::vector<WORD> indices16;                // 顶点数不超过65535时使用
        std::vector<DWORD> indices32;               // 顶点数超过65535时使用
        std::wstring texStrA;                       // 环境光纹理文件名，需为相对路径，且在mbo必须占260字节
        std::wstring texStrD;                       // 漫射光纹理文件名，需为相对路径，在mbo必须占260字节
    };

    // 指定.mbo文件的情况下，若.mbo文件存在，优先读取该文件
    // 否则会读取.obj文件
    // 若.obj文件被读取，且提供了.mbo文件的路径，则会根据已经读取的数据创建.mbo文件
    bool Read(const wchar_t* mboFileName, const wchar_t* objFileName);
    
    bool ReadObj(const wchar_t* objFileName);
    bool ReadMbo(const wchar_t* mboFileName);
    bool WriteMbo(const wchar_t* mboFileName);
public:
    std::vector<ObjPart> objParts;
    DirectX::XMFLOAT3 vMin, vMax;                   // AABB盒双顶点
private:
    void AddVertex(const VertexPosNormalTex& vertex, DWORD vpi, DWORD vti, DWORD vni);

    // 缓存有v/vt/vn字符串信息
    std::unordered_map<std::wstring, DWORD> vertexCache;
};

class MtlReader
{
public:
    bool ReadMtl(const wchar_t* mtlFileName);


public:
    std::map<std::wstring, Material> materials;
    std::map<std::wstring, std::wstring> mapKaStrs;
    std::map<std::wstring, std::wstring> mapKdStrs;
};


#endif

ObjReader.cpp定义如下：

#include "ObjReader.h"

using namespace DirectX;
using namespace std::experimental;
bool ObjReader::Read(const wchar_t * mboFileName, const wchar_t * objFileName)
{
    if (mboFileName && filesystem::exists(mboFileName))
    {
        return ReadMbo(mboFileName);
    }
    else if (objFileName && filesystem::exists(objFileName))
    {
        bool status = ReadObj(objFileName);
        if (status && mboFileName)
            return WriteMbo(mboFileName);
        return status;
    }

    return false;
}

bool ObjReader::ReadObj(const wchar_t * objFileName)
{
    objParts.clear();
    vertexCache.clear();

    MtlReader mtlReader;

    std::vector<XMFLOAT3>   positions;
    std::vector<XMFLOAT3>   normals;
    std::vector<XMFLOAT2>   texCoords;

    XMVECTOR vecMin = g_XMInfinity, vecMax = g_XMNegInfinity;

    std::wifstream wfin(objFileName);
    // 切换中文
    std::locale china("chs");
    wfin.imbue(china);
    for (;;)
    {
        std::wstring wstr;
        if (!(wfin >> wstr))
            break;

        if (wstr[0] == '#')
        {
            //
            // 忽略注释所在行
            //
            while (!wfin.eof() && wfin.get() != '\n')
                continue;
        }
        else if (wstr == L"o" || wstr == L"g")
        {
            // 
            // 对象名(组名)
            //
            objParts.emplace_back(ObjPart());
            // 提供默认材质
            objParts.back().material.Ambient = XMFLOAT4(0.2f, 0.2f, 0.2f, 1.0f);
            objParts.back().material.Diffuse = XMFLOAT4(0.8f, 0.8f, 0.8f, 1.0f);
            objParts.back().material.Specular = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);

            vertexCache.clear();
        }
        else if (wstr == L"v")
        {
            //
            // 顶点位置
            //
            XMFLOAT3 pos;
            wfin >> pos.x >> pos.y >> pos.z;
            positions.push_back(pos);
            XMVECTOR vecPos = XMLoadFloat3(&pos);
            vecMax = XMVectorMax(vecMax, vecPos);
            vecMin = XMVectorMin(vecMin, vecPos);
        }
        else if (wstr == L"vt")
        {
            //
            // 顶点纹理坐标
            //

            // 注意obj使用的是笛卡尔坐标系，而不是纹理坐标系
            float u, v;
            wfin >> u >> v;
            v = 1.0f - v;
            texCoords.emplace_back(XMFLOAT2(u, v));
        }
        else if (wstr == L"vn")
        {
            //
            // 顶点法向量
            //
            float x, y, z;
            wfin >> x >> y >> z;
            normals.emplace_back(XMFLOAT3(x, y, z));
        }
        else if (wstr == L"mtllib")
        {
            //
            // 指定某一文件的材质
            //
            std::wstring mtlFile;
            wfin >> mtlFile;
            // 去掉前后空格
            size_t beg = 0, ed = mtlFile.size();
            while (iswspace(mtlFile[beg]))
                beg++;
            while (ed > beg && iswspace(mtlFile[ed - 1]))
                ed--;
            mtlFile = mtlFile.substr(beg, ed - beg);
            // 获取路径
            std::wstring dir = objFileName;
            size_t pos;
            if ((pos = dir.find_last_of('/')) == std::wstring::npos &&
                (pos = dir.find_last_of('\\')) == std::wstring::npos)
            {
                pos = 0;
            }
            else
            {
                pos += 1;
            }
                

            mtlReader.ReadMtl((dir.erase(pos) + mtlFile).c_str());
        }
        else if (wstr == L"usemtl")
        {
            //
            // 使用之前指定文件内部的某一材质
            //
            std::wstring mtlName;
            std::getline(wfin, mtlName);
            // 去掉前后空格
            size_t beg = 0, ed = mtlName.size();
            while (iswspace(mtlName[beg]))
                beg++;
            while (ed > beg && iswspace(mtlName[ed - 1]))
                ed--;
            mtlName = mtlName.substr(beg, ed - beg);

            objParts.back().material = mtlReader.materials[mtlName];
            objParts.back().texStrA = mtlReader.mapKaStrs[mtlName];
            objParts.back().texStrD = mtlReader.mapKdStrs[mtlName];
        }
        else if (wstr == L"f")
        {
            //
            // 几何面
            //
            VertexPosNormalTex vertex;
            DWORD vpi, vni, vti;
            wchar_t ignore;

            // 确定
            // 顶点位置索引/纹理坐标索引/法向量索引
            wfin >> vpi >> ignore >> vti >> ignore >> vni;
            vertex.pos = positions[vpi - 1];
            vertex.normal = normals[vni - 1];
            vertex.tex = texCoords[vti - 1];
            AddVertex(vertex, vpi, vti, vni);

            wfin >> vpi >> ignore >> vti >> ignore >> vni;
            vertex.pos = positions[vpi - 1];
            vertex.normal = normals[vni - 1];
            vertex.tex = texCoords[vti - 1];
            AddVertex(vertex, vpi, vti, vni);

            wfin >> vpi >> ignore >> vti >> ignore >> vni;
            vertex.pos = positions[vpi - 1];
            vertex.normal = normals[vni - 1];
            vertex.tex = texCoords[vti - 1];
            AddVertex(vertex, vpi, vti, vni);

            while (iswblank(wfin.peek()))
                wfin.get();
            // 几何面顶点数可能超过了3，不支持该格式
            if (wfin.peek() != '\n')
                return false;
        }
    }

    // 顶点数不超过WORD的最大值的话就使用16位WORD存储
    for (auto& part : objParts)
    {
        if (part.vertices.size() < 65535)
        {
            for (auto& i : part.indices32)
            {
                part.indices16.push_back((WORD)i);
            }
            part.indices32.clear();
        }
    }

    XMStoreFloat3(&vMax, vecMax);
    XMStoreFloat3(&vMin, vecMin);

    return true;
}

bool ObjReader::ReadMbo(const wchar_t * mboFileName)
{
    // [Part数目] 4字节
    // [AABB盒顶点vMax] 12字节
    // [AABB盒顶点vMin] 12字节
    // [Part
    //   [环境光材质文件名]520字节
    //   [漫射光材质文件名]520字节
    //   [材质]64字节
    //   [顶点数]4字节
    //   [索引数]4字节
    //   [顶点]32*顶点数 字节
    //   [索引]2(或4)*索引数 字节，取决于顶点数是否不超过65535
    // ]
    // ...
    std::ifstream fin(mboFileName, std::ios::in | std::ios::binary);
    if (!fin.is_open())
        return false;

    UINT parts = (UINT)objParts.size();
    // [Part数目] 4字节
    fin.read(reinterpret_cast<char*>(&parts), sizeof(UINT));
    objParts.resize(parts);

    // [AABB盒顶点vMax] 12字节
    fin.read(reinterpret_cast<char*>(&vMax), sizeof(XMFLOAT3));
    // [AABB盒顶点vMin] 12字节
    fin.read(reinterpret_cast<char*>(&vMin), sizeof(XMFLOAT3));


    for (UINT i = 0; i < parts; ++i)
    {
        wchar_t filePath[MAX_PATH];
        // [环境光材质文件名]520字节
        fin.read(reinterpret_cast<char*>(filePath), MAX_PATH * sizeof(wchar_t));
        objParts[i].texStrA = filePath;
        // [漫射光材质文件名]520字节
        fin.read(reinterpret_cast<char*>(filePath), MAX_PATH * sizeof(wchar_t));
        objParts[i].texStrD = filePath;
        // [材质]64字节
        fin.read(reinterpret_cast<char*>(&objParts[i].material), sizeof(Material));
        UINT vertexCount, indexCount;
        // [顶点数]4字节
        fin.read(reinterpret_cast<char*>(&vertexCount), sizeof(UINT));
        // [索引数]4字节
        fin.read(reinterpret_cast<char*>(&indexCount), sizeof(UINT));
        // [顶点]32*顶点数 字节
        objParts[i].vertices.resize(vertexCount);
        fin.read(reinterpret_cast<char*>(objParts[i].vertices.data()), vertexCount * sizeof(VertexPosNormalTex));

        if (vertexCount > 65535)
        {
            // [索引]4*索引数 字节
            objParts[i].indices32.resize(indexCount);
            fin.read(reinterpret_cast<char*>(objParts[i].indices32.data()), indexCount * sizeof(DWORD));
        }
        else
        {
            // [索引]2*索引数 字节
            objParts[i].indices16.resize(indexCount);
            fin.read(reinterpret_cast<char*>(objParts[i].indices16.data()), indexCount * sizeof(WORD));
        }
    }

    fin.close();

    return true;
}

bool ObjReader::WriteMbo(const wchar_t * mboFileName)
{
    // [Part数目] 4字节
    // [AABB盒顶点vMax] 12字节
    // [AABB盒顶点vMin] 12字节
    // [Part
    //   [环境光材质文件名]520字节
    //   [漫射光材质文件名]520字节
    //   [材质]64字节
    //   [顶点数]4字节
    //   [索引数]4字节
    //   [顶点]32*顶点数 字节
    //   [索引]2(或4)*索引数 字节，取决于顶点数是否不超过65535
    // ]
    // ...
    std::ofstream fout(mboFileName, std::ios::out | std::ios::binary);
    UINT parts = (UINT)objParts.size();
    // [Part数目] 4字节
    fout.write(reinterpret_cast<const char*>(&parts), sizeof(UINT));

    // [AABB盒顶点vMax] 12字节
    fout.write(reinterpret_cast<const char*>(&vMax), sizeof(XMFLOAT3));
    // [AABB盒顶点vMin] 12字节
    fout.write(reinterpret_cast<const char*>(&vMin), sizeof(XMFLOAT3));

    // [Part
    for (UINT i = 0; i < parts; ++i)
    {
        wchar_t filePath[MAX_PATH];
        wcscpy_s(filePath, objParts[i].texStrA.c_str());
        // [环境光材质文件名]520字节
        fout.write(reinterpret_cast<const char*>(filePath), MAX_PATH * sizeof(wchar_t));
        wcscpy_s(filePath, objParts[i].texStrD.c_str());
        // [漫射光材质文件名]520字节
        fout.write(reinterpret_cast<const char*>(filePath), MAX_PATH * sizeof(wchar_t));
        // [材质]64字节
        fout.write(reinterpret_cast<const char*>(&objParts[i].material), sizeof(Material));
        UINT vertexCount = (UINT)objParts[i].vertices.size();
        // [顶点数]4字节
        fout.write(reinterpret_cast<const char*>(&vertexCount), sizeof(UINT));

        UINT indexCount;
        if (vertexCount > 65535)
        {
            indexCount = (UINT)objParts[i].indices32.size();
            // [索引数]4字节
            fout.write(reinterpret_cast<const char*>(&indexCount), sizeof(UINT));
            // [顶点]32*顶点数 字节
            fout.write(reinterpret_cast<const char*>(objParts[i].vertices.data()), vertexCount * sizeof(VertexPosNormalTex));
            // [索引]2(或4)*索引数 字节，取决于顶点数是否不超过65535
            fout.write(reinterpret_cast<const char*>(objParts[i].indices32.data()), indexCount * sizeof(DWORD));
        }
        else
        {
            indexCount = (UINT)objParts[i].indices16.size();
            // [索引数]4字节
            fout.write(reinterpret_cast<const char*>(&indexCount), sizeof(UINT));
            // [顶点]32*顶点数 字节
            fout.write(reinterpret_cast<const char*>(objParts[i].vertices.data()), vertexCount * sizeof(VertexPosNormalTex));
            //   [索引]2(或4)*索引数 字节，取决于顶点数是否不超过65535
            fout.write(reinterpret_cast<const char*>(objParts[i].indices16.data()), indexCount * sizeof(WORD));
        }
    }
    // ]
    fout.close();

    return true;
}

void ObjReader::AddVertex(const VertexPosNormalTex& vertex, DWORD vpi, DWORD vti, DWORD vni)
{
    std::wstring idxStr = std::to_wstring(vpi) + L"/" + std::to_wstring(vti) + L"/" + std::to_wstring(vni);

    // 寻找是否有重复顶点
    auto it = vertexCache.find(idxStr);
    if (it != vertexCache.end())
    {
        objParts.back().indices32.push_back(it->second);
    }
    else
    {
        objParts.back().vertices.push_back(vertex);
        DWORD pos = objParts.back().vertices.size() - 1;
        vertexCache[idxStr] = pos;
        objParts.back().indices32.push_back(pos);
    }
}



bool MtlReader::ReadMtl(const wchar_t * mtlFileName)
{
    materials.clear();
    mapKaStrs.clear();
    mapKdStrs.clear();


    std::wifstream wfin(mtlFileName);
    std::locale china("chs");
    wfin.imbue(china);


    if (!wfin.is_open())
        return false;

    std::wstring wstr;
    std::wstring currMtl;
    for (;;)
    {
        if (!(wfin >> wstr))
            break;

        if (wstr[0] == '#')
        {
            //
            // 忽略注释所在行
            //
            while (wfin.get() != '\n')
                continue;
        }
        else if (wstr == L"newmtl")
        {
            //
            // 新材质
            //

            std::getline(wfin, currMtl);
            // 去掉前后空格
            size_t beg = 0, ed = currMtl.size();
            while (iswspace(currMtl[beg]))
                beg++;
            while (ed > beg && iswspace(currMtl[ed - 1]))
                ed--;
            currMtl = currMtl.substr(beg, ed - beg);
        }
        else if (wstr == L"Ka")
        {
            //
            // 环境光反射颜色
            //
            XMFLOAT4& ambient = materials[currMtl].Ambient;
            wfin >> ambient.x >> ambient.y >> ambient.z;
            if (ambient.w == 0.0f)
                ambient.w = 1.0f;
        }
        else if (wstr == L"Kd")
        {
            //
            // 漫射光反射颜色
            //
            XMFLOAT4& diffuse = materials[currMtl].Diffuse;
            wfin >> diffuse.x >> diffuse.y >> diffuse.z;
            if (diffuse.w == 0.0f)
                diffuse.w = 1.0f;
        }
        else if (wstr == L"Ks")
        {
            //
            // 镜面光反射颜色
            //
            XMFLOAT4& specular = materials[currMtl].Specular;
            wfin >> specular.x >> specular.y >> specular.z;
        }
        else if (wstr == L"Ns")
        {
            //
            // 镜面系数
            //
            wfin >> materials[currMtl].Specular.w;
        }
        else if (wstr == L"d" || wstr == L"Tr")
        {
            //
            // d为不透明度 Tr为透明度
            //
            float alpha;
            wfin >> alpha;
            if (wstr == L"Tr")
                alpha = 1.0f - alpha;
            materials[currMtl].Ambient.w = alpha;
            materials[currMtl].Diffuse.w = alpha;
        }
        else if (wstr == L"map_Ka" || wstr == L"map_Kd")
        {
            //
            // map_Ka为环境光反射使用的纹理，map_Kd为漫反射使用的纹理
            //
            std::wstring fileName;
            std::getline(wfin, fileName);
            // 去掉前后空格
            size_t beg = 0, ed = fileName.size();
            while (iswspace(fileName[beg]))
                beg++;
            while (ed > beg && iswspace(fileName[ed - 1]))
                ed--;
            fileName = fileName.substr(beg, ed - beg);

            // 追加路径
            std::wstring dir = mtlFileName;
            size_t pos;
            if ((pos = dir.find_last_of('/')) == std::wstring::npos &&
                (pos = dir.find_last_of('\\')) == std::wstring::npos)
                pos = 0;
            else
                pos += 1;

            if (wstr == L"map_Ka")
                mapKaStrs[currMtl] = dir.erase(pos) + fileName;
            else
                mapKdStrs[currMtl] = dir.erase(pos) + fileName;
        }
    }

    return true;
}

其中AddVertex方法用于去除重复的顶点，并构建索引数组。

在改为读取.mbo文件后，原本读取.obj需要耗时3s，现在可以降到2ms以内，大幅提升了读取效率。其关键点就在于要构造连续性的二进制数据以减少读取次数，并剔除掉原本读取.obj时的各种词法分析部分（在该部分也浪费了大量的时间）。

由于ObjReader类对.obj格式的文件要求比较严格，如果出现不能正确加载的现象，请检查是否出现下面这些情况，否则需要自行修改.obj/.mtl文件，或者给ObjReader实现更多的功能：

1. 使用了/将下一行的内容连接在一起表示一行
2. 存在索引为负数
3. 使用了类似1//2这样的顶点（即不包含纹理坐标的顶点）
4. 使用了绝对路径的文件引用
5. 相对路径使用了.和..两种路径格式
6. 若.mtl材质文件不存在，则内部会使用默认材质值
7. 若.mtl内部没有指定纹理文件引用，需要另外自行加载纹理
8. 网格只能以三角形构造，即一个f的顶点数只能为3

GameObject类的改进

因为下一章还会讲到硬件实例化，所以GameObject类在后期还会有所改动，现在只放出声明部分：

class GameObject
{
public:
    // 使用模板别名(C++11)简化类型名
    template <class T>
    using ComPtr = Microsoft::WRL::ComPtr<T>;

    struct GameObjectPart
    {
        Material material;
        ComPtr<ID3D11ShaderResourceView> texA;
        ComPtr<ID3D11ShaderResourceView> texD;
        ComPtr<ID3D11Buffer> vertexBuffer;
        ComPtr<ID3D11Buffer> indexBuffer;
        UINT vertexCount;
        UINT indexCount;
        DXGI_FORMAT indexFormat;
    };

    GameObject();

    // 获取位置
    DirectX::XMFLOAT3 GetPosition() const;
    // 获取子模型
    const GameObjectPart& GetPart(size_t pos) const;
    // 获取包围盒
    void GetBoundingBox(DirectX::BoundingBox& box) const;
    void GetBoundingBox(DirectX::BoundingBox& box, DirectX::FXMMATRIX worldMatrix) const;
    //
    // 设置模型
    //
    
    void SetModel(ComPtr<ID3D11Device> device, const ObjReader& model);
    
    //
    // 设置网格
    //

    void SetMesh(ComPtr<ID3D11Device> device, const Geometry::MeshData& meshData);
    void SetMesh(ComPtr<ID3D11Device> device, const std::vector<VertexPosNormalTex>& vertices, const std::vector<WORD> indices);
    void SetMesh(ComPtr<ID3D11Device> device, const std::vector<VertexPosNormalTex>& vertices, const std::vector<DWORD> indices);
    
    //
    // 设置纹理
    //

    void SetTexture(ComPtr<ID3D11ShaderResourceView> texture);
    void SetTexture(ComPtr<ID3D11ShaderResourceView> texA, ComPtr<ID3D11ShaderResourceView> texD);
    void SetTexture(size_t partIndex, ComPtr<ID3D11ShaderResourceView> texture);
    void SetTexture(size_t partIndex, ComPtr<ID3D11ShaderResourceView> texA, ComPtr<ID3D11ShaderResourceView> texD);
    
    //
    // 设置材质
    //

    void SetMaterial(const Material& material);
    void SetMaterial(size_t partIndex, const Material& material);
    
    //
    // 设置矩阵
    //

    void SetWorldMatrix(const DirectX::XMFLOAT4X4& world);
    void SetWorldMatrix(DirectX::FXMMATRIX world);
    void SetTexTransformMatrix(const DirectX::XMFLOAT4X4& texTransform);
    void SetTexTransformMatrix(DirectX::FXMMATRIX texTransform);


    // 绘制对象
    void Draw(ComPtr<ID3D11DeviceContext> deviceContext);

private:
    void SetMesh(ComPtr<ID3D11Device> device, const VertexPosNormalTex* vertices, UINT vertexCount,
        const void * indices, UINT indexCount, DXGI_FORMAT indexFormat);

private:
    DirectX::XMFLOAT4X4 mWorldMatrix;                           // 世界矩阵
    DirectX::XMFLOAT4X4 mTexTransform;                          // 纹理变换矩阵
    std::vector<GameObjectPart> mParts;                         // 模型的各个部分
    DirectX::BoundingBox mBoundingBox;                          // 模型的AABB盒
};

剩余一些不是很重大的变动就不放出来了，比如BasicObjectFX类和对应的hlsl的变动，可以查看源码（文首文末都有）。

模型加载演示

这里我选用了之前合作项目时设计师完成的房屋模型，经过ObjReader加载后实装到GameObject以进行绘制。效果如下：

DirectX11 With Windows SDK完整目录

Github项目源码