初学DirectX11， 留个纪恋。

　　以前学的是openGL， 最近才开始学DirectX11，写了个很垃圾的代码，怀念以前的glPushMatrix(), glPopMatrix()， glBegin(), glEnd(), 多简单啊，可惜在openGL4后面的版本中放弃了这些经典的函数，改成了跟directX差不多的自定义管线， 我觉得openGL已经被改的面目全非了，可能是openGL慢的缘故吧。openGL4.3的VAO，VBO还是不能理解。　　

写了个垃圾的程序，许多个几何体，自己写函数实现了以前glPushMatrix()，glPopMatrix()的功能。界面还是Qt写的，毕竟方便，调用API函数代码量太大。DirectX的代码真多啊，以后分装成一个类库试试。

贴一下主要的代码吧。

几何体顶点过多变成球的时候，运行很卡，我的代码效率海水很差啊。

#ifndef DWIDGET_H
#define DWIDGET_H
#include "xBasic.h"
#include <d3d11.h>
#include <DirectXMath.h>
#include "DPainter.h"
#include <QWidget>
#include <stack>

class DPainter;

class DWidget : public QWidget
{
    Q_OBJECT

public:
    DWidget(QWidget *parent = nullptr);
    ~DWidget();
    void rotateX();
    void rotateY();
    void rotateZ();

protected:
    virtual void paintEvent(QPaintEvent *event);
    virtual void resizeEvent(QResizeEvent *event);
    void mousePressEvent(QMouseEvent *event);
    virtual QPaintEngine *paintEngine() const { return nullptr; }

private:
    void updateWVP();
    void initializeD3D();
    void pushWorldMatrix();
    void multipyWorldMatrix(DirectX::XMMATRIX *matrix);
    void popWorldMatrix();
    void worldMatrixIdentity();
    void setCurrentWorldMatrix(DirectX::XMMATRIX *matrix);

    std::stack<XMFLOAT4X4> worldStack;
    DPainter *d3dPainter;
    HWND hwnd;

    ID3D11Device *device;
    ID3D11DeviceContext *context;
    IDXGISwapChain *swapChain;
    ID3D11RenderTargetView *renderTargetView;
    ID3D11VertexShader *VS;
    ID3D11PixelShader *PS;
    ID3D10Blob *VS_Buffer;
    ID3D10Blob *PS_Buffer;
    ID3D11Buffer *constantBuffer;
    ID3D11InputLayout *vertexLayout;
    ID3D11Buffer *worldBuffer;
    ID3D11Buffer *viewBuffer;
    ID3D11Buffer *projectionBuffer;
    ID3D11DepthStencilView *depthStencilView;
    ID3D11Texture2D *depthStencilBuffer;
    ID3D11DepthStencilState *depthStencilState;

    XMFLOAT4X4 world;
    XMFLOAT4X4 view;
    XMFLOAT4X4 projection;
    XMFLOAT4 eye;
    XMFLOAT4 target;
    XMFLOAT4 up;
    CPerObject WVP;

    const D3D11_INPUT_ELEMENT_DESC layout[] =
    {
        { "POSITION", , DXGI_FORMAT_R32G32B32_FLOAT, , , D3D11_INPUT_PER_VERTEX_DATA,  },
        { "COLOR", , DXGI_FORMAT_R32G32B32A32_FLOAT, , , D3D11_INPUT_PER_VERTEX_DATA,  },
    };
    int numElements = ;
};

#endif // DWIDGET_H

// cpp文件

#include "DWidget.h"
#include <qevent.h>
#include "GeometryProvider.h"

ID3D11Buffer *boolBuffer;
ID3D11DepthStencilView* pDSV;
struct ABCD
{
    bool a;
}isT;

ID3D11Buffer *cylinderVertexBuffer;
ID3D11Buffer *cylinderIndexBuffer;

DWidget::DWidget(QWidget *parent)
    : QWidget(parent)
{
    setAttribute(Qt::WA_PaintOnScreen, true);
    setAttribute(Qt::WA_NativeWindow, true);
    setAutoFillBackground(false);
    setFocusPolicy(Qt::StrongFocus);
    hwnd = (HWND)winId();
    initializeD3D();
    depthStencilBuffer = nullptr;
    depthStencilView = nullptr;
    d3dPainter = new DPainter;
    d3dPainter->context = context;
    d3dPainter->device = device;
    d3dPainter->createSphere(, );
}

DWidget::~DWidget()
{
    context->Release();
    device->Release();
}

void DWidget::rotateX()
{
    XMMATRIX tmpWord;// = XMLoadFloat4x4(&world);
    XMVECTOR anx = XMVectorSet(, , , );
    tmpWord = XMMatrixRotationAxis(anx, 0.05);
    multipyWorldMatrix(&tmpWord);
    update();
}

void DWidget::rotateY()
{
    XMMATRIX tmpWord;// = XMLoadFloat4x4(&world);
    XMVECTOR anx = XMVectorSet(, , , );
    tmpWord = XMMatrixRotationAxis(anx, 0.05);
    multipyWorldMatrix(&tmpWord);
    update();
}

void DWidget::rotateZ()
{
    XMMATRIX tmpWord;
    XMVECTOR anx = XMVectorSet(, , , );
    tmpWord = XMMatrixRotationAxis(anx, 0.01);
    multipyWorldMatrix(&tmpWord);
    update();
}

void DWidget::paintEvent(QPaintEvent * event)
{
    FLOAT bgColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
    context->ClearRenderTargetView(renderTargetView, bgColor);
    context->ClearDepthStencilView(depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0.0f);

    {
        pushWorldMatrix();
        multipyWorldMatrix(&XMMatrixScaling(0.14, 0.14, 0.14));
        multipyWorldMatrix(&XMMatrixTranslation(-, -, -));

        context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
        UINT stride = sizeof(Vertex);
        UINT offset = ;
        context->IASetVertexBuffers(, , &cylinderVertexBuffer, &stride, &offset);
        context->IASetIndexBuffer(cylinderIndexBuffer, DXGI_FORMAT_R32_UINT, );
        context->DrawIndexed(, , );

        {
            pushWorldMatrix();
            multipyWorldMatrix(&XMMatrixTranslation(, , ));
            multipyWorldMatrix(&XMMatrixScaling(0.1, 0.1, 0.1));

            d3dPainter->drawSphere();

            popWorldMatrix();
        }

        for (int i = ; i < ; i++)
        {
            for (int j = ; j <= ; j++)
            {
                for (int k = ; k < ; k++)
                {
                    pushWorldMatrix();
                    multipyWorldMatrix(&XMMatrixTranslation(i, j, k));
                    multipyWorldMatrix(&XMMatrixScaling(0.1, 0.1, 0.1));
                    d3dPainter->drawSphere();
                    popWorldMatrix();

                }
            }
        }

        popWorldMatrix();
    }//d3dPainter->drawSphere();

    swapChain->Present(, );

}

void DWidget::updateWVP()
{
    XMStoreFloat4x4(&WVP.view, XMMatrixTranspose(XMLoadFloat4x4(&view)));
    XMStoreFloat4x4(&WVP.world, XMMatrixTranspose(XMLoadFloat4x4(&world)));
    XMStoreFloat4x4(&WVP.projection, XMMatrixTranspose(XMLoadFloat4x4(&projection)));
    context->UpdateSubresource(constantBuffer, , NULL, &WVP, , );
    context->VSSetConstantBuffers(, , &constantBuffer);
    ::isT.a = ;
}

void DWidget::resizeEvent(QResizeEvent * event)
{
    int width = this->width();
    int height = this->height();
    ::xBasicChangeSize(device, context, swapChain, &renderTargetView, width, height);

    D3D11_TEXTURE2D_DESC depthStencilBufferDesc;
    ZeroMemory(&depthStencilBufferDesc, sizeof(D3D11_TEXTURE2D_DESC));
    depthStencilBufferDesc.Width = width;
    depthStencilBufferDesc.Height = height;
    depthStencilBufferDesc.MipLevels = ;
    depthStencilBufferDesc.ArraySize = ;
    depthStencilBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthStencilBufferDesc.SampleDesc.Count = ;
    depthStencilBufferDesc.SampleDesc.Quality = ;
    depthStencilBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    depthStencilBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
    depthStencilBufferDesc.CPUAccessFlags = ;
    depthStencilBufferDesc.MiscFlags = ;

    device->CreateTexture2D(&depthStencilBufferDesc, NULL, &depthStencilBuffer);

    D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
    ZeroMemory(&depthStencilDesc, sizeof(D3D11_DEPTH_STENCIL_DESC));
    depthStencilDesc.DepthEnable = true;
    depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
    depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
    depthStencilDesc.StencilEnable = true;
    depthStencilDesc.StencilReadMask = 0xFF;
    depthStencilDesc.StencilWriteMask = 0xFF;
    depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
    depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
    depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
    depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
    depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
    depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
    depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
    depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;

    device->CreateDepthStencilState(&depthStencilDesc, &depthStencilState);

    context->OMSetDepthStencilState(depthStencilState, );

    D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
    ZeroMemory(&depthStencilViewDesc, sizeof(D3D11_DEPTH_STENCIL_VIEW_DESC));
    depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
    depthStencilViewDesc.Texture2D.MipSlice = ;

    device->CreateDepthStencilView(depthStencilBuffer, &depthStencilViewDesc, &depthStencilView);
    context->OMSetRenderTargets(, &renderTargetView, depthStencilView);

    XMMATRIX tmpProjection = XMMatrixPerspectiveFovLH(XM_PIDIV2 / , (float)width / (float)height, 0.01f, 100.0f);
    XMStoreFloat4x4(&projection, tmpProjection);
}

void DWidget::mousePressEvent(QMouseEvent * event)
{
}

void DWidget::initializeD3D()
{
    ::xBasicInitializeDirectX11(hwnd, &swapChain, &device, &context, &renderTargetView);
    ::xBasicCreateShader(device, context, L"Effects.fx", &VS_Buffer, &PS_Buffer, &VS, &PS);
    ::xBasicCreateBuffer(device, D3D11_BIND_CONSTANT_BUFFER, sizeof(CPerObject), &WVP, &constantBuffer);
    ::xBasicCreateBuffer(device, D3D11_BIND_CONSTANT_BUFFER, , &::isT, &::boolBuffer);

    XMMATRIX tmpWorld = XMMatrixScaling(0.1, 0.1, 0.1) *XMMatrixTranslation( * ,  * , );;
    XMStoreFloat4x4(&world, tmpWorld);

    XMVECTOR eye = XMVectorSet(0.0f, 0.0f, -1.0f, 0.0f);
    XMVECTOR at = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
    XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
    XMStoreFloat4x4(&view, XMMatrixLookAtLH(eye, at, up));

    //Create the Input Layout
    device->CreateInputLayout(layout, , VS_Buffer->GetBufferPointer(), VS_Buffer->GetBufferSize(), &vertexLayout);

    //Set the Input Layout
    context->IASetInputLayout(vertexLayout);

    GeometryProvider provider;
    std::vector<Vertex> vertices;
    std::vector<UINT> indices;
    GeometryProvider::MeshData data;
    provider.createCylinder(data, );
    for (size_t i = ; i < data.vertices.size(); i++)
    {
        Vertex tmpV;
        tmpV.pos = data.vertices[i].position;
        tmpV.color = XMFLOAT4(rand() % , rand() % , rand() % , );
        vertices.push_back(tmpV);
    }

    for (size_t i = ; i < data.indices.size(); i++)
    {
        indices.push_back(data.indices[i]);
    }

    ::xBasicCreateBuffer(device, D3D11_BIND_VERTEX_BUFFER, vertices.size() * sizeof(Vertex), &vertices[], &cylinderVertexBuffer);
    ::xBasicCreateBuffer(device, D3D11_BIND_INDEX_BUFFER, indices.size() * sizeof(UINT), &indices[], &cylinderIndexBuffer);
}

void DWidget::pushWorldMatrix()
{
    if (worldStack.empty())
    {
        worldMatrixIdentity();
    }
    worldStack.push(worldStack.top());
}

void DWidget::multipyWorldMatrix(DirectX::XMMATRIX * matrix)
{
    if (worldStack.empty())
    {
        worldMatrixIdentity();
    }

    XMMATRIX aMatrix = XMLoadFloat4x4(&worldStack.top());
    XMMATRIX ansMatrix = *matrix * aMatrix;
    XMStoreFloat4x4(&worldStack.top(), ansMatrix);

    world = worldStack.top();
    updateWVP();
}

void DWidget::popWorldMatrix()
{
    worldStack.pop();

    world = worldStack.top();

    updateWVP();
}

void DWidget::worldMatrixIdentity()
{
    while (!worldStack.empty())
    {
        worldStack.pop();
    }

    worldStack.push(XMFLOAT4X4());

    XMStoreFloat4x4(&worldStack.top(), XMMatrixIdentity());

    world = worldStack.top();
    updateWVP();
}

void DWidget::setCurrentWorldMatrix(DirectX::XMMATRIX * matrix)
{
    if (worldStack.empty())
    {
        worldMatrixIdentity();
    }

    XMMATRIX aMatrix = XMLoadFloat4x4(&worldStack.top());
    XMMATRIX ansMatrix = *matrix * aMatrix;
    XMStoreFloat4x4(&worldStack.top(), ansMatrix);

    world = worldStack.top();
    updateWVP();
}

有些很奇葩的写法就不管了。