经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C++ » 查看文章
d3d12龙书阅读----绘制几何体（下）
来源：cnblogs　　作者：dyccyber　　时间：2024/5/11 8:53:25　　对本文有异议

d3d12龙书阅读----绘制几何体（下）

本节在上一节的基础上，对整个绘制过程进行优化，将绘制单个几何体的内容拓展到了多个几何体，同时对根签名进行了进一步地探索。

帧资源

在之前绘制每帧的结尾，我们都要使用flushingcommandqueue方法，要一直等待gpu执行完所有命令，才会继续绘制下一帧，此时cpu处于空闲时间，同时，在绘制每一帧的初始阶段，gpu要等待cpu提交命令，此时gpu处于空闲时间
解决上述问题的一种方法是：
构建以cpu每帧都要更新的资源为数组元素的环形数组，这些资源被称为帧资源，一般循环数组由3个帧资源元素构成
当gpu在处理上一帧的命令时，cpu可以为下一帧更新资源，并构建并提交相应的命令列表，如果环形数组有三个元素，则令cpu比gpu提前处理两帧，这样可以确保gpu持续工作
帧资源定义：

针对每个物体/几何体的常量缓冲区定义
目前存储的是每个物体的世界矩阵 即 模型矩阵 将物体从局部坐标系转换到世界坐标系 代表着物体的位置

  1. struct ObjectConstants
  2. {
  3.     DirectX::XMFLOAT4X4 World = MathHelper::Identity4x4();
  4. };
  5. 针对每次渲染过程（rendering pass）所要用到的数据
  6. 比如 观察矩阵 投影矩阵 时间 等等
  7. struct PassConstants
  8. {
  9.     DirectX::XMFLOAT4X4 View = MathHelper::Identity4x4();
  10.     DirectX::XMFLOAT4X4 InvView = MathHelper::Identity4x4();
  11.     DirectX::XMFLOAT4X4 Proj = MathHelper::Identity4x4();
  12.     DirectX::XMFLOAT4X4 InvProj = MathHelper::Identity4x4();
  13.     DirectX::XMFLOAT4X4 ViewProj = MathHelper::Identity4x4();
  14.     DirectX::XMFLOAT4X4 InvViewProj = MathHelper::Identity4x4();
  15.     DirectX::XMFLOAT3 EyePosW = { 0.0f, 0.0f, 0.0f };
  16.     float cbPerObjectPad1 = 0.0f;
  17.     DirectX::XMFLOAT2 RenderTargetSize = { 0.0f, 0.0f };
  18.     DirectX::XMFLOAT2 InvRenderTargetSize = { 0.0f, 0.0f };
  19.     float NearZ = 0.0f;
  20.     float FarZ = 0.0f;
  21.     float TotalTime = 0.0f;
  22.     float DeltaTime = 0.0f;
  23. };
  24. 顶点定义
  25. struct Vertex
  26. {
  27.     DirectX::XMFLOAT3 Pos;
  28.     DirectX::XMFLOAT4 Color;
  29. };
  31. 存储cpu为一帧构建命令列表所需资源
  32. struct FrameResource
  33. {
  34. public:
  35.     
  36.     FrameResource(ID3D12Device* device, UINT passCount, UINT objectCount);
  37.     FrameResource(const FrameResource& rhs) = delete;
  38.     FrameResource& operator=(const FrameResource& rhs) = delete;
  39.     ~FrameResource();
  41.     每一帧都要有自己的命令分配器
  42.     因为当上一帧的gpu还在处理命令时 我们不能重置命令分配器
  43.     Microsoft::WRL::ComPtr<ID3D12CommandAllocator> CmdListAlloc;
  45.     同理 每个帧资源也要有自己的常量缓冲区
  46.     std::unique_ptr<UploadBuffer<PassConstants>> PassCB = nullptr;
  47.     std::unique_ptr<UploadBuffer<ObjectConstants>> ObjectCB = nullptr;
  49.     围栏点可以帮助检测 gpu是否仍然使用着帧资源
  50.     UINT64 Fence = 0;
  51. };

可以看到我们在帧资源中将常量缓冲区分为pass 与 object， 这是基于资源的更新频率对常量资源进行分组，每次渲染过程我们都要更新pass缓冲区，而对于object来说，只有当发生变化的时候才需要更新，具体代码我们待会再看。

回到cpu与gpu的同步上来，首先创建初始化帧资源数组：

  1. void ShapesApp::BuildFrameResources()
  2. {
  3.     for(int i = 0; i < gNumFrameResources; ++i)
  4.     {
  5.         mFrameResources.push_back(std::make_unique<FrameResource>(md3dDevice.Get(),
  6.             1, (UINT)mAllRitems.size()));
  7.             其中1代表着一个帧资源1个pass缓冲区 第二个是所有渲染物体的数目
  8.     }
  9. }

cpu端更新第n帧：

  1. void ShapesApp::Update(const GameTimer& gt)
  2. {
  3.     OnKeyboardInput(gt);
  4. 	UpdateCamera(gt);
  6.     循环帧资源数组
  7.     mCurrFrameResourceIndex = (mCurrFrameResourceIndex + 1) % gNumFrameResources;
  8.     mCurrFrameResource = mFrameResources[mCurrFrameResourceIndex].get();
  10.     等待gpu完成围栏点之前的所有命令
  11.     if(mCurrFrameResource->Fence != 0 && mFence->GetCompletedValue() < mCurrFrameResource->Fence)
  12.     {
  13.         HANDLE eventHandle = CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);
  14.         ThrowIfFailed(mFence->SetEventOnCompletion(mCurrFrameResource->Fence, eventHandle));
  15.         WaitForSingleObject(eventHandle, INFINITE);
  16.         CloseHandle(eventHandle);
  17.     }
  18.     更新常量缓冲区
  19. 	UpdateObjectCBs(gt);
  20. 	UpdateMainPassCB(gt);
  21. }

绘制第n帧：

  1. void ShapesApp::draw(const GameTimer& gt){
  2. 添加围栏值 将命令标记到此围栏点
  3. mCurrFrameResource->Fence = ++mCurrentFence;
  5. 向命令队列中添加一条设置新围栏点的命令
  6. 由于这条命令要交给gpu处理，所以gpu处理完signal之前的所有命令之前，它不会设置新的围栏点
  7. mCommandQueue->Signal(mFence.Get(), mCurrentFence);
  8. }

其实这种方法也有着缺陷，如果gpu处理命令的速度大于cpu提交命令列表的速度，则还是要等待cpu，理想的情况是cpu处理帧的速度大于gpu，这样cpu可以有空闲时间来处理游戏逻辑的其它部分，此方法的最大好处是cpu可以持续向gpu提供数据

渲染项

渲染项是一个轻量型结构 用于存储绘制物体所需要数据：

  1. struct RenderItem
  2. {
  3. 	RenderItem() = default;
  5.     世界矩阵
  6.     XMFLOAT4X4 World = MathHelper::Identity4x4();
  8. 	// 一个脏标记用于记录是否需要更新物体缓冲区 因为每个帧资源都有各自独立的物体缓冲区 所以脏标记的数目要设置和帧资源数目一致
  9. 	int NumFramesDirty = gNumFrameResources;
  11. 	// 当前渲染项对应object缓冲区索引
  12. 	UINT ObjCBIndex = -1;
  14.     该渲染项参与绘制的几何体
  15. 	MeshGeometry* Geo = nullptr;
  17.     //图元拓扑类型
  18.     D3D12_PRIMITIVE_TOPOLOGY PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
  20.     // DrawIndexedInstanced 方法的参数
  21.     UINT IndexCount = 0;
  22.     UINT StartIndexLocation = 0;
  23.     int BaseVertexLocation = 0;
  24. };

渲染项的具体使用之后介绍

渲染过程中用到的常量数据

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

  1. cbuffer cbPerObject : register(b0)
  2. {
  3. 	float4x4 gWorld; 
  4. };
  6. cbuffer cbPass : register(b1)
  7. {
  8.     float4x4 gView;
  9.     float4x4 gInvView;
  10.     float4x4 gProj;
  11.     float4x4 gInvProj;
  12.     float4x4 gViewProj;
  13.     float4x4 gInvViewProj;
  14.     float3 gEyePosW;
  15.     float cbPerObjectPad1;
  16.     float2 gRenderTargetSize;
  17.     float2 gInvRenderTargetSize;
  18.     float gNearZ;
  19.     float gFarZ;
  20.     float gTotalTime;
  21.     float gDeltaTime;
  22. };

更新object缓冲区 与 pass缓冲区 这里利用了前一节介绍的uploadbuffer的方法 从cpu端更新数据：

  1. void ShapesApp::UpdateObjectCBs(const GameTimer& gt)
  2. {
  3. 	auto currObjectCB = mCurrFrameResource->ObjectCB.get();
  4. 	for(auto& e : mAllRitems)
  5. 	{
  6. 		每个帧资源都需要更新物体缓冲区
  7. 		if(e->NumFramesDirty > 0)
  8. 		{
  9. 			XMMATRIX world = XMLoadFloat4x4(&e->World);
  11. 			ObjectConstants objConstants;
  12. 			XMStoreFloat4x4(&objConstants.World, XMMatrixTranspose(world));
  14. 			currObjectCB->CopyData(e->ObjCBIndex, objConstants);
  16. 			// Next FrameResource need to be updated too.
  17. 			e->NumFramesDirty--;
  18. 		}
  19. 	}
  20. }
  22. void ShapesApp::UpdateMainPassCB(const GameTimer& gt)
  23. {
  24. 	XMMATRIX view = XMLoadFloat4x4(&mView);
  25. 	XMMATRIX proj = XMLoadFloat4x4(&mProj);
  27. 	XMMATRIX viewProj = XMMatrixMultiply(view, proj);
  28. 	XMMATRIX invView = XMMatrixInverse(&XMMatrixDeterminant(view), view);
  29. 	XMMATRIX invProj = XMMatrixInverse(&XMMatrixDeterminant(proj), proj);
  30. 	XMMATRIX invViewProj = XMMatrixInverse(&XMMatrixDeterminant(viewProj), viewProj);
  32. 	XMStoreFloat4x4(&mMainPassCB.View, XMMatrixTranspose(view));
  33. 	XMStoreFloat4x4(&mMainPassCB.InvView, XMMatrixTranspose(invView));
  34. 	XMStoreFloat4x4(&mMainPassCB.Proj, XMMatrixTranspose(proj));
  35. 	XMStoreFloat4x4(&mMainPassCB.InvProj, XMMatrixTranspose(invProj));
  36. 	XMStoreFloat4x4(&mMainPassCB.ViewProj, XMMatrixTranspose(viewProj));
  37. 	XMStoreFloat4x4(&mMainPassCB.InvViewProj, XMMatrixTranspose(invViewProj));
  38. 	mMainPassCB.EyePosW = mEyePos;
  39. 	mMainPassCB.RenderTargetSize = XMFLOAT2((float)mClientWidth, (float)mClientHeight);
  40. 	mMainPassCB.InvRenderTargetSize = XMFLOAT2(1.0f / mClientWidth, 1.0f / mClientHeight);
  41. 	mMainPassCB.NearZ = 1.0f;
  42. 	mMainPassCB.FarZ = 1000.0f;
  43. 	mMainPassCB.TotalTime = gt.TotalTime();
  44. 	mMainPassCB.DeltaTime = gt.DeltaTime();
  46. 	auto currPassCB = mCurrFrameResource->PassCB.get();
  47. 	currPassCB->CopyData(0, mMainPassCB);
  48. }

绘制多种几何体

在这里就不再介绍柱体 球体 正方体的过程 设计到一些几何知识
直接进入几何体的绘制阶段

创建顶点与索引缓冲区

将所有几何体的顶点缓冲区 与 索引缓冲区，合成一个大的顶点缓冲区与 索引缓冲区，之后使用drawindexinstanced方法绘制 需要记录每个几何体起始索引 索引数 以及起始顶点

  1. void ShapesApp::BuildShapeGeometry()
  2. {
  3.     GeometryGenerator geoGen;
  4. 	GeometryGenerator::MeshData box = geoGen.CreateBox(1.5f, 0.5f, 1.5f, 3);
  5. 	GeometryGenerator::MeshData grid = geoGen.CreateGrid(20.0f, 30.0f, 60, 40);
  6. 	GeometryGenerator::MeshData sphere = geoGen.CreateSphere(0.5f, 20, 20);
  7. 	GeometryGenerator::MeshData cylinder = geoGen.CreateCylinder(0.5f, 0.3f, 3.0f, 20, 20);
  9. 	// 计算各几何体的起始顶点
  10. 	UINT boxVertexOffset = 0;
  11. 	UINT gridVertexOffset = (UINT)box.Vertices.size();
  12. 	UINT sphereVertexOffset = gridVertexOffset + (UINT)grid.Vertices.size();
  13. 	UINT cylinderVertexOffset = sphereVertexOffset + (UINT)sphere.Vertices.size();
  15. 	// 存储起始索引
  16. 	UINT boxIndexOffset = 0;
  17. 	UINT gridIndexOffset = (UINT)box.Indices32.size();
  18. 	UINT sphereIndexOffset = gridIndexOffset + (UINT)grid.Indices32.size();
  19. 	UINT cylinderIndexOffset = sphereIndexOffset + (UINT)sphere.Indices32.size();
  21.     定义各子网格结构体
  22. 	SubmeshGeometry boxSubmesh;
  23. 	boxSubmesh.IndexCount = (UINT)box.Indices32.size();
  24. 	boxSubmesh.StartIndexLocation = boxIndexOffset;
  25. 	boxSubmesh.BaseVertexLocation = boxVertexOffset;
  27. 	SubmeshGeometry gridSubmesh;
  28. 	gridSubmesh.IndexCount = (UINT)grid.Indices32.size();
  29. 	gridSubmesh.StartIndexLocation = gridIndexOffset;
  30. 	gridSubmesh.BaseVertexLocation = gridVertexOffset;
  32. 	SubmeshGeometry sphereSubmesh;
  33. 	sphereSubmesh.IndexCount = (UINT)sphere.Indices32.size();
  34. 	sphereSubmesh.StartIndexLocation = sphereIndexOffset;
  35. 	sphereSubmesh.BaseVertexLocation = sphereVertexOffset;
  37. 	SubmeshGeometry cylinderSubmesh;
  38. 	cylinderSubmesh.IndexCount = (UINT)cylinder.Indices32.size();
  39. 	cylinderSubmesh.StartIndexLocation = cylinderIndexOffset;
  40. 	cylinderSubmesh.BaseVertexLocation = cylinderVertexOffset;
  42.     将各顶点 各索引合并
  43.     子网格合并为一个大的meshgeometry
  44. 	auto totalVertexCount =
  45. 		box.Vertices.size() +
  46. 		grid.Vertices.size() +
  47. 		sphere.Vertices.size() +
  48. 		cylinder.Vertices.size();
  50. 	std::vector<Vertex> vertices(totalVertexCount);
  52. 	UINT k = 0;
  53. 	for(size_t i = 0; i < box.Vertices.size(); ++i, ++k)
  54. 	{
  55. 		vertices[k].Pos = box.Vertices[i].Position;
  56.         vertices[k].Color = XMFLOAT4(DirectX::Colors::DarkGreen);
  57. 	}
  59. 	for(size_t i = 0; i < grid.Vertices.size(); ++i, ++k)
  60. 	{
  61. 		vertices[k].Pos = grid.Vertices[i].Position;
  62.         vertices[k].Color = XMFLOAT4(DirectX::Colors::ForestGreen);
  63. 	}
  65. 	for(size_t i = 0; i < sphere.Vertices.size(); ++i, ++k)
  66. 	{
  67. 		vertices[k].Pos = sphere.Vertices[i].Position;
  68.         vertices[k].Color = XMFLOAT4(DirectX::Colors::Crimson);
  69. 	}
  71. 	for(size_t i = 0; i < cylinder.Vertices.size(); ++i, ++k)
  72. 	{
  73. 		vertices[k].Pos = cylinder.Vertices[i].Position;
  74. 		vertices[k].Color = XMFLOAT4(DirectX::Colors::SteelBlue);
  75. 	}
  77. 	std::vector<std::uint16_t> indices;
  78. 	indices.insert(indices.end(), std::begin(box.GetIndices16()), std::end(box.GetIndices16()));
  79. 	indices.insert(indices.end(), std::begin(grid.GetIndices16()), std::end(grid.GetIndices16()));
  80. 	indices.insert(indices.end(), std::begin(sphere.GetIndices16()), std::end(sphere.GetIndices16()));
  81. 	indices.insert(indices.end(), std::begin(cylinder.GetIndices16()), std::end(cylinder.GetIndices16()));
  83.     const UINT vbByteSize = (UINT)vertices.size() * sizeof(Vertex);
  84.     const UINT ibByteSize = (UINT)indices.size()  * sizeof(std::uint16_t);
  86. 	auto geo = std::make_unique<MeshGeometry>();
  87. 	geo->Name = "shapeGeo";
  89. 	ThrowIfFailed(D3DCreateBlob(vbByteSize, &geo->VertexBufferCPU));
  90. 	CopyMemory(geo->VertexBufferCPU->GetBufferPointer(), vertices.data(), vbByteSize);
  92. 	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
  93. 	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);
  95. 	geo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
  96. 		mCommandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);
  98. 	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
  99. 		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);
  101. 	geo->VertexByteStride = sizeof(Vertex);
  102. 	geo->VertexBufferByteSize = vbByteSize;
  103. 	geo->IndexFormat = DXGI_FORMAT_R16_UINT;
  104. 	geo->IndexBufferByteSize = ibByteSize;
  106. 	geo->DrawArgs["box"] = boxSubmesh;
  107. 	geo->DrawArgs["grid"] = gridSubmesh;
  108. 	geo->DrawArgs["sphere"] = sphereSubmesh;
  109. 	geo->DrawArgs["cylinder"] = cylinderSubmesh;
  111. 	mGeometries[geo->Name] = std::move(geo);
  112. }

定义具体渲染项

在完成构建几何体之后 我们根据上一步创建的meshgeometry 来提取submeshgeometry 然后 里面的信息 根据需要创建相应的渲染项 并填写相应的内容

  1. void ShapesApp::BuildRenderItems()
  2. {
  3. 	auto boxRitem = std::make_unique<RenderItem>();
  4. 	XMStoreFloat4x4(&boxRitem->World, XMMatrixScaling(2.0f, 2.0f, 2.0f)*XMMatrixTranslation(0.0f, 0.5f, 0.0f));
  5. 	boxRitem->ObjCBIndex = 0;
  6. 	boxRitem->Geo = mGeometries["shapeGeo"].get();
  7. 	boxRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
  8. 	boxRitem->IndexCount = boxRitem->Geo->DrawArgs["box"].IndexCount;
  9. 	boxRitem->StartIndexLocation = boxRitem->Geo->DrawArgs["box"].StartIndexLocation;
  10. 	boxRitem->BaseVertexLocation = boxRitem->Geo->DrawArgs["box"].BaseVertexLocation;
  11. 	mAllRitems.push_back(std::move(boxRitem));
  13.     auto gridRitem = std::make_unique<RenderItem>();
  14.     gridRitem->World = MathHelper::Identity4x4();
  15. 	gridRitem->ObjCBIndex = 1;
  16. 	gridRitem->Geo = mGeometries["shapeGeo"].get();
  17. 	gridRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
  18.     gridRitem->IndexCount = gridRitem->Geo->DrawArgs["grid"].IndexCount;
  19.     gridRitem->StartIndexLocation = gridRitem->Geo->DrawArgs["grid"].StartIndexLocation;
  20.     gridRitem->BaseVertexLocation = gridRitem->Geo->DrawArgs["grid"].BaseVertexLocation;
  21. 	mAllRitems.push_back(std::move(gridRitem));
  23. 	UINT objCBIndex = 2;
  24. 	for(int i = 0; i < 5; ++i)
  25. 	{
  26. 		auto leftCylRitem = std::make_unique<RenderItem>();
  27. 		auto rightCylRitem = std::make_unique<RenderItem>();
  28. 		auto leftSphereRitem = std::make_unique<RenderItem>();
  29. 		auto rightSphereRitem = std::make_unique<RenderItem>();
  31. 		XMMATRIX leftCylWorld = XMMatrixTranslation(-5.0f, 1.5f, -10.0f + i*5.0f);
  32. 		XMMATRIX rightCylWorld = XMMatrixTranslation(+5.0f, 1.5f, -10.0f + i*5.0f);
  34. 		XMMATRIX leftSphereWorld = XMMatrixTranslation(-5.0f, 3.5f, -10.0f + i*5.0f);
  35. 		XMMATRIX rightSphereWorld = XMMatrixTranslation(+5.0f, 3.5f, -10.0f + i*5.0f);
  37. 		XMStoreFloat4x4(&leftCylRitem->World, rightCylWorld);
  38. 		leftCylRitem->ObjCBIndex = objCBIndex++;
  39. 		leftCylRitem->Geo = mGeometries["shapeGeo"].get();
  40. 		leftCylRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
  41. 		leftCylRitem->IndexCount = leftCylRitem->Geo->DrawArgs["cylinder"].IndexCount;
  42. 		leftCylRitem->StartIndexLocation = leftCylRitem->Geo->DrawArgs["cylinder"].StartIndexLocation;
  43. 		leftCylRitem->BaseVertexLocation = leftCylRitem->Geo->DrawArgs["cylinder"].BaseVertexLocation;
  44.         此处省略
  45. 		
  46. 	}
  48. 	for(auto& e : mAllRitems)
  49. 		mOpaqueRitems.push_back(e.get());
  50. }

定义常量缓冲区视图

之后由于我们现在有3个pass常量缓冲区 3n个object常量缓冲区 总共3n+3个常量缓冲区 所以就需要 3n+3个cbv 同时也要拓展描述符堆的大小：

  1. void ShapesApp::BuildDescriptorHeaps()
  2. {
  3.     UINT objCount = (UINT)mOpaqueRitems.size();
  5.     UINT numDescriptors = (objCount+1) * gNumFrameResources;
  6.     mPassCbvOffset = objCount * gNumFrameResources;
  8.     D3D12_DESCRIPTOR_HEAP_DESC cbvHeapDesc;
  9.     cbvHeapDesc.NumDescriptors = numDescriptors;
  10.     cbvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
  11.     cbvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
  12.     cbvHeapDesc.NodeMask = 0;
  13.     ThrowIfFailed(md3dDevice->CreateDescriptorHeap(&cbvHeapDesc,
  14.         IID_PPV_ARGS(&mCbvHeap)));
  15. }
  1. void ShapesApp::BuildConstantBufferViews()
  2. {
  3.     UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));
  5.     UINT objCount = (UINT)mOpaqueRitems.size();
  7.     每个帧资源中的每个object都需要一个cbv
  8.     for(int frameIndex = 0; frameIndex < gNumFrameResources; ++frameIndex)
  9.     {
  10.         auto objectCB = mFrameResources[frameIndex]->ObjectCB->Resource();
  11.         for(UINT i = 0; i < objCount; ++i)
  12.         {
  13.             D3D12_GPU_VIRTUAL_ADDRESS cbAddress = objectCB->GetGPUVirtualAddress();
  15.             // 每个物体的偏移
  16.             cbAddress += i*objCBByteSize;
  18.             // 计算在描述符堆中的偏移
  19.             int heapIndex = frameIndex*objCount + i;
  20.             auto handle = CD3DX12_CPU_DESCRIPTOR_HANDLE(mCbvHeap->GetCPUDescriptorHandleForHeapStart());
  21.             handle.Offset(heapIndex, mCbvSrvUavDescriptorSize);
  23.             D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
  24.             cbvDesc.BufferLocation = cbAddress;
  25.             cbvDesc.SizeInBytes = objCBByteSize;
  27.             md3dDevice->CreateConstantBufferView(&cbvDesc, handle);
  28.         }
  29.     }
  31.     UINT passCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(PassConstants));
  32.     每个帧资源都要一个pass 描述符
  33.     for(int frameIndex = 0; frameIndex < gNumFrameResources; ++frameIndex)
  34.     {
  35.         auto passCB = mFrameResources[frameIndex]->PassCB->Resource();
  36.         D3D12_GPU_VIRTUAL_ADDRESS cbAddress = passCB->GetGPUVirtualAddress();
  38.         计算偏移
  39.         int heapIndex = mPassCbvOffset + frameIndex;
  40.         auto handle = CD3DX12_CPU_DESCRIPTOR_HANDLE(mCbvHeap->GetCPUDescriptorHandleForHeapStart());
  41.         handle.Offset(heapIndex, mCbvSrvUavDescriptorSize);
  43.         D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
  44.         cbvDesc.BufferLocation = cbAddress;
  45.         cbvDesc.SizeInBytes = passCBByteSize;
  46.         
  47.         md3dDevice->CreateConstantBufferView(&cbvDesc, handle);
  48.     }
  49. }

绘制

最后一步是绘制每个渲染项 ：

  1. void ShapesApp::DrawRenderItems(ID3D12GraphicsCommandList* cmdList, const std::vector<RenderItem*>& ritems)
  2. {
  3.     UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));
  4.  
  5. 	auto objectCB = mCurrFrameResource->ObjectCB->Resource();
  7.     for(size_t i = 0; i < ritems.size(); ++i)
  8.     {
  9.         auto ri = ritems[i];
  11.         cmdList->IASetVertexBuffers(0, 1, &ri->Geo->VertexBufferView());
  12.         cmdList->IASetIndexBuffer(&ri->Geo->IndexBufferView());
  13.         cmdList->IASetPrimitiveTopology(ri->PrimitiveType);
  15.         
  16.         UINT cbvIndex = mCurrFrameResourceIndex*(UINT)mOpaqueRitems.size() + ri->ObjCBIndex;
  17.         auto cbvHandle = CD3DX12_GPU_DESCRIPTOR_HANDLE(mCbvHeap->GetGPUDescriptorHandleForHeapStart());
  18.         cbvHandle.Offset(cbvIndex, mCbvSrvUavDescriptorSize);
  20.         cmdList->SetGraphicsRootDescriptorTable(0, cbvHandle);
  22.         cmdList->DrawIndexedInstanced(ri->IndexCount, 1, ri->StartIndexLocation, ri->BaseVertexLocation, 0);
  23.     }
  24. }

细探根签名

根签名由一系列根参数构成 根参数主要有以下三种类型
img

我们可以创建出任意组合的根签名 只要不超过64 DWORD大小 根常量使用方便 无需使用相应的常量缓冲区 与 cbv堆，但是假如我们使用根常量存储mvp矩阵，16个float元素需要16个DWORD 即需要16个根常量 大幅消耗了根签名的空间 所以在使用时我们要灵活组合

根签名结构体定义：

  1. typedef struct D3D12_ROOT_PARAMETER
  2.     {
  3.     D3D12_ROOT_PARAMETER_TYPE ParameterType;
  4.     union 
  5.         {
  6.         D3D12_ROOT_DESCRIPTOR_TABLE DescriptorTable;
  7.         D3D12_ROOT_CONSTANTS Constants;
  8.         D3D12_ROOT_DESCRIPTOR Descriptor;
  9.         } 	;
  10.     D3D12_SHADER_VISIBILITY ShaderVisibility;
  11.     } 	D3D12_ROOT_PARAMETER;

其中ParameterType的定义是根参数的类型，包括描述符表，根常量，cbv根描述符，srv根描述符，uav根描述符：
img
ShaderVisibility代表着着色器可见性：
img

创建 DescriptorTable Constants Descriptor

DescriptorTable :
描述符表的定义可以借助CD3DX12_DESCRIPTOR_RANGE的init方法

  1. struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE
  2. {
  3.     CD3DX12_DESCRIPTOR_RANGE() { }
  4.     explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o) :
  5.         D3D12_DESCRIPTOR_RANGE(o)
  6.     {}
  7.     CD3DX12_DESCRIPTOR_RANGE(
  8.         D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
  9.         UINT numDescriptors,
  10.         UINT baseShaderRegister,
  11.         UINT registerSpace = 0,
  12.         UINT offsetInDescriptorsFromTableStart =
  13.         D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
  14.     {
  15.         Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
  16.     }
  17.     
  18.     inline void Init(
  19.         D3D12_DESCRIPTOR_RANGE_TYPE rangeType,
  20.         UINT numDescriptors,
  21.         UINT baseShaderRegister,
  22.         UINT registerSpace = 0,
  23.         UINT offsetInDescriptorsFromTableStart =
  24.         D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
  25.     {
  26.         Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart);
  27.     }
  28. }

其中D3D12_DESCRIPTOR_RANGE_TYPE rangeType定义为：
img
numDescriptors代表着范围内描述符的数量
baseShaderRegister：
img

img
然后使用InitAsDescriptorTable创建 ：

  1.  CD3DX12_DESCRIPTOR_RANGE cbvTable0;
  2.  cbvTable0.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);
  4.  CD3DX12_DESCRIPTOR_RANGE cbvTable1;
  5.  cbvTable1.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 1);
  7. CD3DX12_ROOT_PARAMETER slotRootParameter[2];
  8.  slotRootParameter[0].InitAsDescriptorTable(1, &cbvTable0);
  9.  slotRootParameter[1].InitAsDescriptorTable(1, &cbvTable1);

根描述符与根常量的定义可以直接使用如下方法创建：

  1. static inline void InitAsConstants(
  2.     _Out_ D3D12_ROOT_PARAMETER &rootParam,
  3.     UINT num32BitValues,
  4.     UINT shaderRegister,
  5.     UINT registerSpace = 0,
  6.     D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
  7. {
  8.     rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
  9.     rootParam.ShaderVisibility = visibility;
  10.     CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace);
  11. }
  13. static inline void InitAsConstantBufferView(
  14.     _Out_ D3D12_ROOT_PARAMETER &rootParam,
  15.     UINT shaderRegister,
  16.     UINT registerSpace = 0,
  17.     D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL)
  18. {
  19.     rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
  20.     rootParam.ShaderVisibility = visibility;
  21.     CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace);
  22. }

例子：
img
img

不同类型的根签名绑定着色器寄存器

将不同类型的根签名绑定着色器寄存器需要使用不同的命令：

根常量：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
其中根常量与根描述符都不需要涉及描述符堆

原文链接：https://www.cnblogs.com/dyccyber/p/18185325

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C++热门文章

  • C/C++编程笔记：编写不会在C ++中编译的C程序，我教你呀！
  • 洛谷 P2085 最小函数值
  • 使用C++界面框架ImGUI开发一个简单程序
  • C++ Json解析CJsonObject的详细使用
  • C++编译错误杂记
  • 二分法（二）：采用二分法解决“最小化最大值问题”
  • C++实现json字符串与map的转换
  • C++借助curses库实现俄罗斯方块
  • 长乐培训Day5
  • 【OpenFOAM】——OpenFOAM入门算例学习

    • C++推荐文章

  • #8. 「模板」树链剖分
  • 预设型 DP
  • Standard Template Libary or C++ Standard Library
  • 一种优秀的虚拟机内存架构 - AQ
  • 如何让 MGR 不从 Primary 节点克隆数据？
  • TLScanary：Pwn中的利器
  • c++临时对象导致的生命周期问题
  • C++(Qt)-GIS开发-简易瓦片地图下载器
  • 逆向通达信 x 逆向微信 x 逆向Qt
  • C++面向对象

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号