C++小项目：directx11图形程序（七）：modelclass

模型类是世界空间中的表示物体的类，那么他的所做的事就是加载模型，移动模型，渲染模型

modelclass.h

#pragma once

#include <d3d11.h>
#include <d3dcompiler.h>
#include <D3DX11.h>
#include <xnamath.h>
#include<fstream>
using namespace std;
#pragma comment(lib,"d3dx11.lib")
#pragma comment(lib,"d3d11.lib")
#pragma comment(lib,"d3dcompiler.lib")
class modelclass
{
public:
    modelclass();
    ~modelclass();

    void Render(ID3D11DeviceContext* context,XMMATRIX& viewmatrix, XMMATRIX& promatrix, D3D11_PRIMITIVE_TOPOLOGY geometry,
        ID3D11VertexShader* vertexshader, ID3D11PixelShader* pixelshader);
    bool Initialize(ID3D11Device *device, LPCWSTR model, LPCWSTR texture);
    void Setposition(float x, float y, float z);
    void RotationAxis(XMVECTOR axis, float angle);
    void Shutdown();

private:
    bool Loadmodel(LPCWSTR file);
    bool Loadtexture(LPCWSTR file, ID3D11Device* device);

    struct vertex
    {
        XMFLOAT3 pos;
        XMFLOAT2 tex;
    };
    
    struct constantBuffer
    {
        XMMATRIX world;
        XMMATRIX view;
        XMMATRIX pro;
    };

    ID3D11Buffer *m_vertexBuffer, *m_indexBuffer;
    ID3D11Buffer *m_constantBuffer;
    int m_vertexCount, m_indexCount;
    ID3D11ShaderResourceView* m_Texture;
    ID3D11SamplerState *m_samplerstate;
    vertex* m_vertexlist;
    XMMATRIX m_worldMatrix;
};

他的公共方法如前所述：Render()渲染模型，Initialize()初始化（加载模型），Setposition()移动模型，RotationAxis()绕轴旋转。

两个私有数据结构，顶点和常量缓存，分别是用来构造顶点缓存和常量缓存的。

私有成员：顶点缓存，索引缓存，常量缓存，顶点个数，索引个数，纹理源视图，取样器状态，顶点列表，及世界变换矩阵。

modelclass.cpp

#include "modelclass.h"


modelclass::modelclass()
{
    m_worldMatrix = XMMatrixIdentity();
}


modelclass::~modelclass()
{
}


bool modelclass::Initialize(ID3D11Device* device,LPCWSTR model,LPCWSTR texture)
{
    HRESULT hr = S_OK;
    bool m=Loadmodel(model);
    bool t=Loadtexture(texture,device);    

    D3D11_BUFFER_DESC bd;
    ZeroMemory(&bd, sizeof(bd));
    bd.Usage = D3D11_USAGE_DEFAULT;
    bd.ByteWidth = sizeof(vertex)* m_vertexCount;
    bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    bd.CPUAccessFlags = 0;
    D3D11_SUBRESOURCE_DATA InitData;
    InitData.pSysMem = m_vertexlist;
    hr = device->CreateBuffer(&bd, &InitData, &m_vertexBuffer);
    if (FAILED(hr))
    {
        return false;
    }


    WORD *indices = new WORD[m_indexCount];
    for (int i = 0; i < m_indexCount; i++)
    {
        indices[i] = i;
    }    
    D3D11_BUFFER_DESC bd1;
    ZeroMemory(&bd1, sizeof(bd1));
    bd1.Usage = D3D11_USAGE_DEFAULT;
    bd1.ByteWidth = sizeof(WORD)* m_indexCount;      
    bd1.BindFlags = D3D11_BIND_INDEX_BUFFER;
    bd1.CPUAccessFlags = 0;
    D3D11_SUBRESOURCE_DATA InitData1;
    InitData1.pSysMem = indices;
    hr = device->CreateBuffer(&bd1, &InitData1, &m_indexBuffer);    
    if (FAILED(hr))
    {
        return false;
    }


    D3D11_BUFFER_DESC bd2;
    ZeroMemory(&bd2, sizeof(bd2));
    bd2.Usage = D3D11_USAGE_DEFAULT;
    bd2.ByteWidth = sizeof(constantBuffer);
    bd2.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    bd2.CPUAccessFlags = 0;
    hr = device->CreateBuffer(&bd2, NULL, &m_constantBuffer);
    if (FAILED(hr))
    {
        return false;
    }


    D3D11_SAMPLER_DESC sampDesc;
    ZeroMemory(&sampDesc, sizeof(sampDesc));
    sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
    sampDesc.MinLOD = 0;
    sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
    device->CreateSamplerState(&sampDesc, &m_samplerstate);

    delete[] indices;
    indices = 0;

    return true;
}


bool modelclass::Loadmodel(LPCWSTR file)
{
    ifstream fin;
    char input;
    
    fin.open(file);
    if (fin.fail())
    {
        return false;
    }

    fin.get(input);
    while (input != ':')
    {
        fin.get(input);
    }

    fin >> m_vertexCount;
    
    m_indexCount = m_vertexCount;

    m_vertexlist = new vertex[m_vertexCount];
    if (!m_vertexlist)
    {
        return false;
    }

    fin.get(input);
    while (input != ':')
    {
        fin.get(input);
    }
    fin.get(input);
    fin.get(input);

    for (int i = 0; i<m_vertexCount; i++)
    {
        fin >> m_vertexlist[i].pos.x >> m_vertexlist[i].pos.y >> m_vertexlist[i].pos.z;
        fin >> m_vertexlist[i].tex.x >> m_vertexlist[i].tex.y;        
    }

    fin.close();
    return true;
}


bool modelclass::Loadtexture(LPCWSTR file,ID3D11Device* device)
{
    D3DX11CreateShaderResourceViewFromFile(device, file, NULL, NULL, &m_Texture, NULL);
    return true;
}


void modelclass::Render(ID3D11DeviceContext* context, XMMATRIX& viewmatrix, XMMATRIX& pro, D3D11_PRIMITIVE_TOPOLOGY geometry,
    ID3D11VertexShader* vertexshader,ID3D11PixelShader* pixelshader)
{
    UINT stride = sizeof(vertex);
    UINT offset = 0;
    context->IASetVertexBuffers(0,1,&m_vertexBuffer,&stride,&offset);
    context->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R16_UINT, 0);
    context->IASetPrimitiveTopology(geometry);

    constantBuffer cb;
    XMMATRIX worldmatrix = m_worldMatrix;
    XMMATRIX promatrix = pro;
    cb.world = XMMatrixTranspose(worldmatrix);
    cb.view = XMMatrixTranspose(viewmatrix);
    cb.pro = XMMatrixTranspose(promatrix);

    context->UpdateSubresource(m_constantBuffer, 0, NULL, &cb, 0, 0);

    context->VSSetShader(vertexshader, NULL, 0);
    context->VSSetConstantBuffers(0, 1, &m_constantBuffer);
    context->PSSetShader(pixelshader, NULL, 0);

    context->PSSetShaderResources(0, 1, &m_Texture);
    context->PSSetSamplers(0, 1, &m_samplerstate);
    context->DrawIndexed(m_vertexCount, 0, 0);    
}


void modelclass::Setposition(float x, float y, float z)
{
    m_worldMatrix = XMMatrixTranslation(x, y, z);
}


void modelclass::RotationAxis(XMVECTOR axis, float angle)
{
    m_worldMatrix *= XMMatrixRotationAxis(axis, angle);
}


void modelclass::Shutdown()
{
    if (m_samplerstate)
    {
        m_samplerstate->Release();
    }
    if (m_constantBuffer)
    {
        m_constantBuffer->Release();
    }
    if (m_indexBuffer)
    {
        m_indexBuffer->Release();
    }
    if (m_vertexBuffer)
    {
        m_vertexBuffer->Release();
    }
    if (m_Texture)
    {
        m_Texture->Release();
    }
    if (m_vertexlist)
    {
        delete[] m_vertexlist;
        m_vertexlist = 0;
    }
}

initialize():

• 调用私有方法加载模型和纹理。加载完模型后，顶点列表，顶点个数已经有值了；加载完纹理后，纹理资源视图也有值了。
• 填充顶点缓存描述数据结构，将顶点列表填充到源数据数据结构的pSysmem字段，然后根据顶点描述数据结构和源数据数据结构创建顶点缓存
• for循环填充索引，填充索引缓存描述数据结构，填充源数据数据结构，创建索引缓存
• 填充常量缓存描述数据结构，并创建常量缓存
• 填充取样器描述数据结构，并创建取样器状态

私有方法Loadmodel():

从磁盘读取一个文件，该文件包含顶点信息，顶点个数该文件如下

Vertex Count: 6

Data:

-1.0 -1.0 0.0 0.0 1.0
-1.0 1.0 0.0 0.0 0.0
1.0 -1.0 0.0 1.0 1.0
-1.0 1.0 0.0 0.0 0.0
1.0 1.0 0.0 1.0 0.0
1.0 -1.0 0.0 1.0 1.0

这是一个txt文件，有6个顶点，每个顶点有3个位置坐标信息和2个纹理坐标信息。

这个方法很简单，就不多做叙述了。

Render():

• 设置创建好的顶点缓存
• 设置创建好的索引缓存
• 设置图形绘制方式
• 将世界转换矩阵，观察矩阵，投影矩阵填充在常量缓存里的各个字段中，并更新常量缓存
• 设置顶点着色器
• 设置常量缓存
• 设置像素着色器
• 设置纹理源
• 设置取样器的取样方式
• 绘制各个顶点

Setposition(),RotationAxis():

这两个方法只是作用于世界转换矩阵，没什么好说的，他们就是用来将模型翻转或平移的