d3d12龍書閱讀----繪製幾何體（下）

dyccyber發表於2024-05-10

d3d12龍書閱讀----繪製幾何體（下）

本節在上一節的基礎上，對整個繪製過程進行最佳化，將繪製單個幾何體的內容擴充到了多個幾何體，同時對根簽名進行了進一步地探索。

幀資源

在之前繪製每幀的結尾，我們都要使用flushingcommandqueue方法，要一直等待gpu執行完所有命令，才會繼續繪製下一幀，此時cpu處於空閒時間，同時，在繪製每一幀的初始階段，gpu要等待cpu提交命令，此時gpu處於空閒時間
解決上述問題的一種方法是：
構建以cpu每幀都要更新的資源為陣列元素的環形陣列，這些資源被稱為幀資源，一般迴圈陣列由3個幀資源元素構成
當gpu在處理上一幀的命令時，cpu可以為下一幀更新資源，並構建並提交相應的命令列表，如果環形陣列有三個元素，則令cpu比gpu提前處理兩幀，這樣可以確保gpu持續工作
幀資源定義：

針對每個物體/幾何體的常量緩衝區定義
目前儲存的是每個物體的世界矩陣即模型矩陣將物體從區域性座標系轉換到世界座標系代表著物體的位置

struct ObjectConstants
{
    DirectX::XMFLOAT4X4 World = MathHelper::Identity4x4();
};
針對每次渲染過程（rendering pass）所要用到的資料
比如 觀察矩陣 投影矩陣 時間 等等
struct PassConstants
{
    DirectX::XMFLOAT4X4 View = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 InvView = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 Proj = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 InvProj = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 ViewProj = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 InvViewProj = MathHelper::Identity4x4();
    DirectX::XMFLOAT3 EyePosW = { 0.0f, 0.0f, 0.0f };
    float cbPerObjectPad1 = 0.0f;
    DirectX::XMFLOAT2 RenderTargetSize = { 0.0f, 0.0f };
    DirectX::XMFLOAT2 InvRenderTargetSize = { 0.0f, 0.0f };
    float NearZ = 0.0f;
    float FarZ = 0.0f;
    float TotalTime = 0.0f;
    float DeltaTime = 0.0f;
};
頂點定義
struct Vertex
{
    DirectX::XMFLOAT3 Pos;
    DirectX::XMFLOAT4 Color;
};

儲存cpu為一幀構建命令列表所需資源
struct FrameResource
{
public:
    
    FrameResource(ID3D12Device* device, UINT passCount, UINT objectCount);
    FrameResource(const FrameResource& rhs) = delete;
    FrameResource& operator=(const FrameResource& rhs) = delete;
    ~FrameResource();

    每一幀都要有自己的命令分配器
    因為當上一幀的gpu還在處理命令時 我們不能重置命令分配器
    Microsoft::WRL::ComPtr<ID3D12CommandAllocator> CmdListAlloc;

    同理 每個幀資源也要有自己的常量緩衝區
    std::unique_ptr<UploadBuffer<PassConstants>> PassCB = nullptr;
    std::unique_ptr<UploadBuffer<ObjectConstants>> ObjectCB = nullptr;

    圍欄點可以幫助檢測 gpu是否仍然使用著幀資源
    UINT64 Fence = 0;
};

可以看到我們在幀資源中將常量緩衝區分為pass 與 object，這是基於資源的更新頻率對常量資源進行分組，每次渲染過程我們都要更新pass緩衝區，而對於object來說，只有當發生變化的時候才需要更新，具體程式碼我們待會再看。

回到cpu與gpu的同步上來，首先建立初始化幀資源陣列：

void ShapesApp::BuildFrameResources()
{
    for(int i = 0; i < gNumFrameResources; ++i)
    {
        mFrameResources.push_back(std::make_unique<FrameResource>(md3dDevice.Get(),
            1, (UINT)mAllRitems.size()));
            其中1代表著一個幀資源1個pass緩衝區 第二個是所有渲染物體的數目
    }
}

cpu端更新第n幀：

void ShapesApp::Update(const GameTimer& gt)
{
    OnKeyboardInput(gt);
	UpdateCamera(gt);

    迴圈幀資源陣列
    mCurrFrameResourceIndex = (mCurrFrameResourceIndex + 1) % gNumFrameResources;
    mCurrFrameResource = mFrameResources[mCurrFrameResourceIndex].get();

    等待gpu完成圍欄點之前的所有命令
    if(mCurrFrameResource->Fence != 0 && mFence->GetCompletedValue() < mCurrFrameResource->Fence)
    {
        HANDLE eventHandle = CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);
        ThrowIfFailed(mFence->SetEventOnCompletion(mCurrFrameResource->Fence, eventHandle));
        WaitForSingleObject(eventHandle, INFINITE);
        CloseHandle(eventHandle);
    }
    更新常量緩衝區
	UpdateObjectCBs(gt);
	UpdateMainPassCB(gt);
}

繪製第n幀：

void ShapesApp::draw(const GameTimer& gt){
新增圍欄值 將命令標記到此圍欄點
mCurrFrameResource->Fence = ++mCurrentFence;

向命令佇列中新增一條設定新圍欄點的命令
由於這條命令要交給gpu處理，所以gpu處理完signal之前的所有命令之前，它不會設定新的圍欄點
mCommandQueue->Signal(mFence.Get(), mCurrentFence);
}

其實這種方法也有著缺陷，如果gpu處理命令的速度大於cpu提交命令列表的速度，則還是要等待cpu，理想的情況是cpu處理幀的速度大於gpu，這樣cpu可以有空閒時間來處理遊戲邏輯的其它部分，此方法的最大好處是cpu可以持續向gpu提供資料

渲染項

渲染項是一個輕量型結構用於儲存繪製物體所需要資料：

struct RenderItem
{
	RenderItem() = default;

    世界矩陣
    XMFLOAT4X4 World = MathHelper::Identity4x4();

	// 一個髒標記用於記錄是否需要更新物體緩衝區 因為每個幀資源都有各自獨立的物體緩衝區 所以髒標記的數目要設定和幀資源數目一致
	int NumFramesDirty = gNumFrameResources;

	// 當前渲染項對應object緩衝區索引
	UINT ObjCBIndex = -1;

    該渲染項參與繪製的幾何體
	MeshGeometry* Geo = nullptr;

    //圖元拓撲型別
    D3D12_PRIMITIVE_TOPOLOGY PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;

    // DrawIndexedInstanced 方法的引數
    UINT IndexCount = 0;
    UINT StartIndexLocation = 0;
    int BaseVertexLocation = 0;
};

渲染項的具體使用之後介紹

渲染過程中用到的常量資料

我們需要更新hlsl中用到的cbuffer：

cbuffer cbPerObject : register(b0)
{
	float4x4 gWorld; 
};

cbuffer cbPass : register(b1)
{
    float4x4 gView;
    float4x4 gInvView;
    float4x4 gProj;
    float4x4 gInvProj;
    float4x4 gViewProj;
    float4x4 gInvViewProj;
    float3 gEyePosW;
    float cbPerObjectPad1;
    float2 gRenderTargetSize;
    float2 gInvRenderTargetSize;
    float gNearZ;
    float gFarZ;
    float gTotalTime;
    float gDeltaTime;
};

更新object緩衝區與 pass緩衝區這裡利用了前一節介紹的uploadbuffer的方法從cpu端更新資料：

void ShapesApp::UpdateObjectCBs(const GameTimer& gt)
{
	auto currObjectCB = mCurrFrameResource->ObjectCB.get();
	for(auto& e : mAllRitems)
	{
		每個幀資源都需要更新物體緩衝區
		if(e->NumFramesDirty > 0)
		{
			XMMATRIX world = XMLoadFloat4x4(&e->World);

			ObjectConstants objConstants;
			XMStoreFloat4x4(&objConstants.World, XMMatrixTranspose(world));

			currObjectCB->CopyData(e->ObjCBIndex, objConstants);

			// Next FrameResource need to be updated too.
			e->NumFramesDirty--;
		}
	}
}

void ShapesApp::UpdateMainPassCB(const GameTimer& gt)
{
	XMMATRIX view = XMLoadFloat4x4(&mView);
	XMMATRIX proj = XMLoadFloat4x4(&mProj);

	XMMATRIX viewProj = XMMatrixMultiply(view, proj);
	XMMATRIX invView = XMMatrixInverse(&XMMatrixDeterminant(view), view);
	XMMATRIX invProj = XMMatrixInverse(&XMMatrixDeterminant(proj), proj);
	XMMATRIX invViewProj = XMMatrixInverse(&XMMatrixDeterminant(viewProj), viewProj);

	XMStoreFloat4x4(&mMainPassCB.View, XMMatrixTranspose(view));
	XMStoreFloat4x4(&mMainPassCB.InvView, XMMatrixTranspose(invView));
	XMStoreFloat4x4(&mMainPassCB.Proj, XMMatrixTranspose(proj));
	XMStoreFloat4x4(&mMainPassCB.InvProj, XMMatrixTranspose(invProj));
	XMStoreFloat4x4(&mMainPassCB.ViewProj, XMMatrixTranspose(viewProj));
	XMStoreFloat4x4(&mMainPassCB.InvViewProj, XMMatrixTranspose(invViewProj));
	mMainPassCB.EyePosW = mEyePos;
	mMainPassCB.RenderTargetSize = XMFLOAT2((float)mClientWidth, (float)mClientHeight);
	mMainPassCB.InvRenderTargetSize = XMFLOAT2(1.0f / mClientWidth, 1.0f / mClientHeight);
	mMainPassCB.NearZ = 1.0f;
	mMainPassCB.FarZ = 1000.0f;
	mMainPassCB.TotalTime = gt.TotalTime();
	mMainPassCB.DeltaTime = gt.DeltaTime();

	auto currPassCB = mCurrFrameResource->PassCB.get();
	currPassCB->CopyData(0, mMainPassCB);
}

繪製多種幾何體

在這裡就不再介紹柱體球體正方體的過程設計到一些幾何知識
直接進入幾何體的繪製階段

建立頂點與索引緩衝區

將所有幾何體的頂點緩衝區與索引緩衝區，合成一個大的頂點緩衝區與索引緩衝區，之後使用drawindexinstanced方法繪製需要記錄每個幾何體起始索引索引數以及起始頂點

void ShapesApp::BuildShapeGeometry()
{
    GeometryGenerator geoGen;
	GeometryGenerator::MeshData box = geoGen.CreateBox(1.5f, 0.5f, 1.5f, 3);
	GeometryGenerator::MeshData grid = geoGen.CreateGrid(20.0f, 30.0f, 60, 40);
	GeometryGenerator::MeshData sphere = geoGen.CreateSphere(0.5f, 20, 20);
	GeometryGenerator::MeshData cylinder = geoGen.CreateCylinder(0.5f, 0.3f, 3.0f, 20, 20);

	// 計算各幾何體的起始頂點
	UINT boxVertexOffset = 0;
	UINT gridVertexOffset = (UINT)box.Vertices.size();
	UINT sphereVertexOffset = gridVertexOffset + (UINT)grid.Vertices.size();
	UINT cylinderVertexOffset = sphereVertexOffset + (UINT)sphere.Vertices.size();

	// 儲存起始索引
	UINT boxIndexOffset = 0;
	UINT gridIndexOffset = (UINT)box.Indices32.size();
	UINT sphereIndexOffset = gridIndexOffset + (UINT)grid.Indices32.size();
	UINT cylinderIndexOffset = sphereIndexOffset + (UINT)sphere.Indices32.size();

    定義各子網格結構體
	SubmeshGeometry boxSubmesh;
	boxSubmesh.IndexCount = (UINT)box.Indices32.size();
	boxSubmesh.StartIndexLocation = boxIndexOffset;
	boxSubmesh.BaseVertexLocation = boxVertexOffset;

	SubmeshGeometry gridSubmesh;
	gridSubmesh.IndexCount = (UINT)grid.Indices32.size();
	gridSubmesh.StartIndexLocation = gridIndexOffset;
	gridSubmesh.BaseVertexLocation = gridVertexOffset;

	SubmeshGeometry sphereSubmesh;
	sphereSubmesh.IndexCount = (UINT)sphere.Indices32.size();
	sphereSubmesh.StartIndexLocation = sphereIndexOffset;
	sphereSubmesh.BaseVertexLocation = sphereVertexOffset;

	SubmeshGeometry cylinderSubmesh;
	cylinderSubmesh.IndexCount = (UINT)cylinder.Indices32.size();
	cylinderSubmesh.StartIndexLocation = cylinderIndexOffset;
	cylinderSubmesh.BaseVertexLocation = cylinderVertexOffset;

    將各頂點 各索引合併
    子網格合併為一個大的meshgeometry
	auto totalVertexCount =
		box.Vertices.size() +
		grid.Vertices.size() +
		sphere.Vertices.size() +
		cylinder.Vertices.size();

	std::vector<Vertex> vertices(totalVertexCount);

	UINT k = 0;
	for(size_t i = 0; i < box.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = box.Vertices[i].Position;
        vertices[k].Color = XMFLOAT4(DirectX::Colors::DarkGreen);
	}

	for(size_t i = 0; i < grid.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = grid.Vertices[i].Position;
        vertices[k].Color = XMFLOAT4(DirectX::Colors::ForestGreen);
	}

	for(size_t i = 0; i < sphere.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = sphere.Vertices[i].Position;
        vertices[k].Color = XMFLOAT4(DirectX::Colors::Crimson);
	}

	for(size_t i = 0; i < cylinder.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = cylinder.Vertices[i].Position;
		vertices[k].Color = XMFLOAT4(DirectX::Colors::SteelBlue);
	}

	std::vector<std::uint16_t> indices;
	indices.insert(indices.end(), std::begin(box.GetIndices16()), std::end(box.GetIndices16()));
	indices.insert(indices.end(), std::begin(grid.GetIndices16()), std::end(grid.GetIndices16()));
	indices.insert(indices.end(), std::begin(sphere.GetIndices16()), std::end(sphere.GetIndices16()));
	indices.insert(indices.end(), std::begin(cylinder.GetIndices16()), std::end(cylinder.GetIndices16()));

    const UINT vbByteSize = (UINT)vertices.size() * sizeof(Vertex);
    const UINT ibByteSize = (UINT)indices.size()  * sizeof(std::uint16_t);

	auto geo = std::make_unique<MeshGeometry>();
	geo->Name = "shapeGeo";

	ThrowIfFailed(D3DCreateBlob(vbByteSize, &geo->VertexBufferCPU));
	CopyMemory(geo->VertexBufferCPU->GetBufferPointer(), vertices.data(), vbByteSize);

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	geo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);

	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

	geo->VertexByteStride = sizeof(Vertex);
	geo->VertexBufferByteSize = vbByteSize;
	geo->IndexFormat = DXGI_FORMAT_R16_UINT;
	geo->IndexBufferByteSize = ibByteSize;

	geo->DrawArgs["box"] = boxSubmesh;
	geo->DrawArgs["grid"] = gridSubmesh;
	geo->DrawArgs["sphere"] = sphereSubmesh;
	geo->DrawArgs["cylinder"] = cylinderSubmesh;

	mGeometries[geo->Name] = std::move(geo);
}

定義具體渲染項

在完成構建幾何體之後我們根據上一步建立的meshgeometry 來提取submeshgeometry 然後裡面的資訊根據需要建立相應的渲染項並填寫相應的內容

void ShapesApp::BuildRenderItems()
{
	auto boxRitem = std::make_unique<RenderItem>();
	XMStoreFloat4x4(&boxRitem->World, XMMatrixScaling(2.0f, 2.0f, 2.0f)*XMMatrixTranslation(0.0f, 0.5f, 0.0f));
	boxRitem->ObjCBIndex = 0;
	boxRitem->Geo = mGeometries["shapeGeo"].get();
	boxRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
	boxRitem->IndexCount = boxRitem->Geo->DrawArgs["box"].IndexCount;
	boxRitem->StartIndexLocation = boxRitem->Geo->DrawArgs["box"].StartIndexLocation;
	boxRitem->BaseVertexLocation = boxRitem->Geo->DrawArgs["box"].BaseVertexLocation;
	mAllRitems.push_back(std::move(boxRitem));

    auto gridRitem = std::make_unique<RenderItem>();
    gridRitem->World = MathHelper::Identity4x4();
	gridRitem->ObjCBIndex = 1;
	gridRitem->Geo = mGeometries["shapeGeo"].get();
	gridRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
    gridRitem->IndexCount = gridRitem->Geo->DrawArgs["grid"].IndexCount;
    gridRitem->StartIndexLocation = gridRitem->Geo->DrawArgs["grid"].StartIndexLocation;
    gridRitem->BaseVertexLocation = gridRitem->Geo->DrawArgs["grid"].BaseVertexLocation;
	mAllRitems.push_back(std::move(gridRitem));

	UINT objCBIndex = 2;
	for(int i = 0; i < 5; ++i)
	{
		auto leftCylRitem = std::make_unique<RenderItem>();
		auto rightCylRitem = std::make_unique<RenderItem>();
		auto leftSphereRitem = std::make_unique<RenderItem>();
		auto rightSphereRitem = std::make_unique<RenderItem>();

		XMMATRIX leftCylWorld = XMMatrixTranslation(-5.0f, 1.5f, -10.0f + i*5.0f);
		XMMATRIX rightCylWorld = XMMatrixTranslation(+5.0f, 1.5f, -10.0f + i*5.0f);

		XMMATRIX leftSphereWorld = XMMatrixTranslation(-5.0f, 3.5f, -10.0f + i*5.0f);
		XMMATRIX rightSphereWorld = XMMatrixTranslation(+5.0f, 3.5f, -10.0f + i*5.0f);

		XMStoreFloat4x4(&leftCylRitem->World, rightCylWorld);
		leftCylRitem->ObjCBIndex = objCBIndex++;
		leftCylRitem->Geo = mGeometries["shapeGeo"].get();
		leftCylRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
		leftCylRitem->IndexCount = leftCylRitem->Geo->DrawArgs["cylinder"].IndexCount;
		leftCylRitem->StartIndexLocation = leftCylRitem->Geo->DrawArgs["cylinder"].StartIndexLocation;
		leftCylRitem->BaseVertexLocation = leftCylRitem->Geo->DrawArgs["cylinder"].BaseVertexLocation;
        此處省略
		
	}

	for(auto& e : mAllRitems)
		mOpaqueRitems.push_back(e.get());
}

定義常量緩衝區檢視

之後由於我們現在有3個pass常量緩衝區 3n個object常量緩衝區總共3n+3個常量緩衝區所以就需要 3n+3個cbv 同時也要擴充描述符堆的大小：

void ShapesApp::BuildDescriptorHeaps()
{
    UINT objCount = (UINT)mOpaqueRitems.size();

    UINT numDescriptors = (objCount+1) * gNumFrameResources;
    mPassCbvOffset = objCount * gNumFrameResources;

    D3D12_DESCRIPTOR_HEAP_DESC cbvHeapDesc;
    cbvHeapDesc.NumDescriptors = numDescriptors;
    cbvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
    cbvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
    cbvHeapDesc.NodeMask = 0;
    ThrowIfFailed(md3dDevice->CreateDescriptorHeap(&cbvHeapDesc,
        IID_PPV_ARGS(&mCbvHeap)));
}

void ShapesApp::BuildConstantBufferViews()
{
    UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));

    UINT objCount = (UINT)mOpaqueRitems.size();

    每個幀資源中的每個object都需要一個cbv
    for(int frameIndex = 0; frameIndex < gNumFrameResources; ++frameIndex)
    {
        auto objectCB = mFrameResources[frameIndex]->ObjectCB->Resource();
        for(UINT i = 0; i < objCount; ++i)
        {
            D3D12_GPU_VIRTUAL_ADDRESS cbAddress = objectCB->GetGPUVirtualAddress();

            // 每個物體的偏移
            cbAddress += i*objCBByteSize;

            // 計算在描述符堆中的偏移
            int heapIndex = frameIndex*objCount + i;
            auto handle = CD3DX12_CPU_DESCRIPTOR_HANDLE(mCbvHeap->GetCPUDescriptorHandleForHeapStart());
            handle.Offset(heapIndex, mCbvSrvUavDescriptorSize);

            D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
            cbvDesc.BufferLocation = cbAddress;
            cbvDesc.SizeInBytes = objCBByteSize;

            md3dDevice->CreateConstantBufferView(&cbvDesc, handle);
        }
    }

    UINT passCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(PassConstants));
    每個幀資源都要一個pass 描述符
    for(int frameIndex = 0; frameIndex < gNumFrameResources; ++frameIndex)
    {
        auto passCB = mFrameResources[frameIndex]->PassCB->Resource();
        D3D12_GPU_VIRTUAL_ADDRESS cbAddress = passCB->GetGPUVirtualAddress();

        計算偏移
        int heapIndex = mPassCbvOffset + frameIndex;
        auto handle = CD3DX12_CPU_DESCRIPTOR_HANDLE(mCbvHeap->GetCPUDescriptorHandleForHeapStart());
        handle.Offset(heapIndex, mCbvSrvUavDescriptorSize);

        D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
        cbvDesc.BufferLocation = cbAddress;
        cbvDesc.SizeInBytes = passCBByteSize;
        
        md3dDevice->CreateConstantBufferView(&cbvDesc, handle);
    }
}

繪製

最後一步是繪製每個渲染項：

void ShapesApp::DrawRenderItems(ID3D12GraphicsCommandList* cmdList, const std::vector<RenderItem*>& ritems)
{
    UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));
 
	auto objectCB = mCurrFrameResource->ObjectCB->Resource();

    for(size_t i = 0; i < ritems.size(); ++i)
    {
        auto ri = ritems[i];

        cmdList->IASetVertexBuffers(0, 1, &ri->Geo->VertexBufferView());
        cmdList->IASetIndexBuffer(&ri->Geo->IndexBufferView());
        cmdList->IASetPrimitiveTopology(ri->PrimitiveType);

        
        UINT cbvIndex = mCurrFrameResourceIndex*(UINT)mOpaqueRitems.size() + ri->ObjCBIndex;
        auto cbvHandle = CD3DX12_GPU_DESCRIPTOR_HANDLE(mCbvHeap->GetGPUDescriptorHandleForHeapStart());
        cbvHandle.Offset(cbvIndex, mCbvSrvUavDescriptorSize);

        cmdList->SetGraphicsRootDescriptorTable(0, cbvHandle);

        cmdList->DrawIndexedInstanced(ri->IndexCount, 1, ri->StartIndexLocation, ri->BaseVertexLocation, 0);
    }
}

細探根簽名

根簽名由一系列根引數構成根引數主要有以下三種型別

我們可以建立出任意組合的根簽名只要不超過64 DWORD大小根常量使用方便無需使用相應的常量緩衝區與 cbv堆，但是假如我們使用根常量儲存mvp矩陣，16個float元素需要16個DWORD 即需要16個根常量大幅消耗了根簽名的空間所以在使用時我們要靈活組合

根簽名結構體定義：

typedef struct D3D12_ROOT_PARAMETER
    {
    D3D12_ROOT_PARAMETER_TYPE ParameterType;
    union 
        {
        D3D12_ROOT_DESCRIPTOR_TABLE DescriptorTable;
        D3D12_ROOT_CONSTANTS Constants;
        D3D12_ROOT_DESCRIPTOR Descriptor;
        } 	;
    D3D12_SHADER_VISIBILITY ShaderVisibility;
    } 	D3D12_ROOT_PARAMETER;

其中ParameterType的定義是根引數的型別，包括描述符表，根常量，cbv根描述符，srv根描述符，uav根描述符：

ShaderVisibility代表著著色器可見性：

建立 DescriptorTable Constants Descriptor

DescriptorTable :
描述符表的定義可以藉助CD3DX12_DESCRIPTOR_RANGE的init方法

struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE
{
    CD3DX12_DESCRIPTOR_RANGE() { }
    explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o) :
        D3D12_DESCRIPTOR_RANGE(o)
    {}
    CD3DX12_DESCRIPTOR_RANGE(
        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
        UINT numDescriptors,
        UINT baseShaderRegister,
        UINT registerSpace = 0,
        UINT offsetInDescriptorsFromTableStart =
        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
    {
        Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
    }
    
    inline void Init(
        D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
        UINT numDescriptors,
        UINT baseShaderRegister,
        UINT registerSpace = 0,
        UINT offsetInDescriptorsFromTableStart =
        D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
    {
        Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
    }
}

其中D3D12_DESCRIPTOR_RANGE_TYPE rangeType定義為：

numDescriptors代表著範圍內描述符的數量
baseShaderRegister：

然後使用InitAsDescriptorTable建立：

 CD3DX12_DESCRIPTOR_RANGE cbvTable0;
 cbvTable0.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);

 CD3DX12_DESCRIPTOR_RANGE cbvTable1;
 cbvTable1.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 1);

CD3DX12_ROOT_PARAMETER slotRootParameter[2];
 slotRootParameter[0].InitAsDescriptorTable(1, &cbvTable0);
 slotRootParameter[1].InitAsDescriptorTable(1, &cbvTable1);

根描述符與根常量的定義可以直接使用如下方法建立：

static inline void InitAsConstants(
    _Out_ D3D12_ROOT_PARAMETER &rootParam,
    UINT num32BitValues,
    UINT shaderRegister,
    UINT registerSpace = 0,
    D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
{
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
}

static inline void InitAsConstantBufferView(
    _Out_ D3D12_ROOT_PARAMETER &rootParam,
    UINT shaderRegister,
    UINT registerSpace = 0,
    D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
{
    rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
    rootParam.ShaderVisibility = visibility;
    CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
}

例子：

不同型別的根簽名繫結著色器暫存器

將不同型別的根簽名繫結著色器暫存器需要使用不同的命令：

根常量：ID3D12GraphicsCommandList：：SetComputeRoot32BitConstants
https://learn.microsoft.com/zh-cn/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-setcomputeroot32bitconstants
根描述符：ID3D12GraphicsCommandList：：SetComputeRootConstantBufferView
https://learn.microsoft.com/zh-cn/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-setcomputerootconstantbufferview
描述符表：ID3D12GraphicsCommandList：：SetComputeRootDescriptorTable
https://learn.microsoft.com/zh-cn/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-setcomputerootdescriptortable
其中根常量與根描述符都不需要涉及描述符堆

d3d12龍書閱讀----繪製幾何體（上）
2024-03-27
3D
d3d12龍書閱讀----繪製幾何體（上）課後習題
2024-05-19
3D
d3d12龍書閱讀----d3d渲染流水線
2024-03-16
3D
d3d12龍書閱讀----Direct3D的初始化
2024-03-12
3D
CSS繪製各種幾何形狀
2019-02-16
CSS
CSS繪製各種幾何圖形形狀效果
2018-07-14
CSS
16.原始碼閱讀（View的繪製-androidapi-26）
2018-05-26
原始碼ViewAndroidAPI
繪製流程圖的軟體下載
2019-09-17
流程圖
如何閱讀一本書——分析閱讀Pre
2020-07-29
Flutter繪製-08-龍捲風效果
2021-03-25
Flutter
《快速閱讀術》讀書筆記
2017-09-12
筆記
Mac書籤閱讀寫作助手，量身定做筆記，體驗輕鬆閱讀
2020-08-06
Mac筆記
基於 WebGL 的 CSG 構造實體幾何書架
2020-04-06
Web
電子書閱讀 App
2018-10-07
APP
如何閱讀Cookbook技術書——如果我要把一本幾百上千頁的書從頭讀到尾，應該怎樣有效閱讀。
2016-02-15
磨刀不誤閱讀工 |《如何閱讀一本書》之基礎閱讀和檢視閱讀
2017-05-19
《如何有效閱讀一本書》讀書筆記
2024-06-14
筆記
spring原始碼閱讀環境(幾分鐘下載包)
2020-02-07
Spring原始碼
Python中OpenCV劃線、畫圓、橢圓、新增文字等幾何圖形繪製操作
2018-09-21
PythonOpenCV
世界讀書日 | 機器學習必讀書籍一覽表（附閱讀地址）
2018-04-23
機器學習
DX12龍書 01 - 向量在幾何學和數學中的表示以及運算定義
2020-10-11
《如何閱讀一本書》讀書筆記完整版
2016-06-29
筆記
WPF繪圖（一）：幾何（Geometry）與形狀（Shape）
2023-10-19
繪圖
canvas 繪製立體圓環
2019-02-05
Canvas
閱讀分享《三體》
2018-10-24
如何閱讀技術類書籍
2019-09-10
Clearview for Mac電子書閱讀工具
2021-01-05
ViewMac
Python 閱讀書目推薦
2016-05-05
Python
android 之view的測量和繪製（群英傳讀書筆記1）
2016-04-26
AndroidView筆記
three.js 幾何體（二）
2020-07-11
JS
three.js 幾何體（三）
2020-07-12
JS
【前端幫幫忙】第3期使用CSS的border屬性繪製各種幾何形狀
2019-02-22
前端CSS
基於HTML5 Canvas的CSG構造實體幾何書架
2017-11-08
HTMLCanvas
JB的閱讀之旅-軟體測試52講（下）
2019-04-18
如何閱讀系列2---<高效閱讀術>經理人月刊NO.82 讀書筆記
2015-03-04
筆記
Mac電子書閱讀工具——Clearview for Mac
2020-06-03
MacView
OmniReader Pro for Mac(圖書閱讀器)
2023-10-10
Mac
筆記.如何閱讀一本書
2018-01-09
筆記

d3d12龍書閱讀----繪製幾何體（下）

d3d12龍書閱讀----繪製幾何體（下）

幀資源

渲染項

渲染過程中用到的常量資料

繪製多種幾何體

建立頂點與索引緩衝區

定義具體渲染項

定義常量緩衝區檢視

繪製

細探根簽名

建立 DescriptorTable Constants Descriptor

不同型別的根簽名繫結著色器暫存器

相關文章