1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef CORE_RENDER_RENDER_COMMAND_LIST_H 17 #define CORE_RENDER_RENDER_COMMAND_LIST_H 18 19 #include <cstddef> 20 #include <cstdint> 21 22 #include <base/containers/array_view.h> 23 #include <base/containers/string.h> 24 #include <base/containers/string_view.h> 25 #include <base/containers/unique_ptr.h> 26 #include <base/containers/vector.h> 27 #include <render/namespace.h> 28 #include <render/nodecontext/intf_render_command_list.h> 29 #include <render/render_data_structures.h> 30 #include <render/resource_handle.h> 31 32 RENDER_BEGIN_NAMESPACE() 33 class GpuResourceManager; 34 class LinearAllocator; 35 class NodeContextDescriptorSetManager; 36 class NodeContextPsoManager; 37 class RenderNodeContextManager; 38 39 enum class DrawType : uint32_t { 40 UNDEFINED = 0, 41 DRAW = 1, 42 DRAW_INDEXED = 2, 43 DRAW_INDIRECT = 3, 44 DRAW_INDEXED_INDIRECT = 4, 45 }; 46 47 // BarrierPoint is a special command which will be added before render commands 48 // that need some kind of syncing. 49 // RenderGraph is responsible for updating the barriers to be correct. 50 // 51 // BarrierPoint is added for: 52 // 53 // BeginRenderPass 54 // Dispatch 55 // DispatchIndirect 56 // 57 // CopyBuffer 58 // CopyBufferImage 59 // BlitImage 60 // ClearColorImage 61 62 enum class RenderCommandType : uint32_t { 63 UNDEFINED, 64 DRAW, 65 DRAW_INDIRECT, 66 DISPATCH, 67 DISPATCH_INDIRECT, 68 BIND_PIPELINE, 69 BEGIN_RENDER_PASS, 70 NEXT_SUBPASS, 71 END_RENDER_PASS, 72 BIND_VERTEX_BUFFERS, 73 BIND_INDEX_BUFFER, 74 COPY_BUFFER, 75 COPY_BUFFER_IMAGE, 76 COPY_IMAGE, 77 BLIT_IMAGE, 78 79 BARRIER_POINT, 80 81 BIND_DESCRIPTOR_SETS, 82 83 PUSH_CONSTANT, 84 85 BUILD_ACCELERATION_STRUCTURE, 86 87 CLEAR_COLOR_IMAGE, 88 89 DYNAMIC_STATE_VIEWPORT, 90 DYNAMIC_STATE_SCISSOR, 91 DYNAMIC_STATE_LINE_WIDTH, 92 DYNAMIC_STATE_DEPTH_BIAS, 93 DYNAMIC_STATE_BLEND_CONSTANTS, 94 DYNAMIC_STATE_DEPTH_BOUNDS, 95 DYNAMIC_STATE_STENCIL, 96 DYNAMIC_STATE_FRAGMENT_SHADING_RATE, 97 98 EXECUTE_BACKEND_FRAME_POSITION, 99 100 WRITE_TIMESTAMP, 101 102 GPU_QUEUE_TRANSFER_RELEASE, 103 GPU_QUEUE_TRANSFER_ACQUIRE, 104 105 BEGIN_DEBUG_MARKER, 106 END_DEBUG_MARKER, 107 108 COUNT, // used as the number of values and must be last 109 }; 110 111 #if RENDER_DEBUG_COMMAND_MARKERS_ENABLED 112 // These names should match the RenderCommandType enum values. 113 constexpr const char* COMMAND_NAMES[] = { 114 "Undefined", 115 "Draw", 116 "DrawIndirect", 117 "Dispatch", 118 "DispatchIndirect", 119 "BindPipeline", 120 "BeginRenderPass", 121 "NextSubpass", 122 "EndRenderPass", 123 "BindVertexBuffers", 124 "BindIndexBuffer", 125 "CopyBuffer", 126 "CopyBufferImage", 127 "CopyImage", 128 "BlitImage", 129 130 "BarrierPoint", 131 "BindDescriptorSets", 132 133 "PushConstant", 134 135 "BuildAccelerationStructures", 136 137 "ClearColorImage", 138 139 "DynamicStateViewport", 140 "DynamicStateScissor", 141 "DynamicStateLineWidth", 142 "DynamicStateDepthBias", 143 "DynamicStateBlendConstants", 144 "DynamicStateDepthBounds", 145 "DynamicStateStencil", 146 "DynamicStateFragmentShadingRate", 147 148 "ExecuteBackendFramePosition", 149 150 "WriteTimestamp", 151 152 "GpuQueueTransferRelease", 153 "GpuQueueTransferAcquire", 154 155 "BeginDebugMarker", 156 "EndDebugMark", 157 }; 158 static_assert(BASE_NS::countof(COMMAND_NAMES) == (static_cast<uint32_t>(RenderCommandType::COUNT))); 159 #endif 160 161 enum class RenderPassBeginType : uint32_t { 162 RENDER_PASS_BEGIN, 163 RENDER_PASS_SUBPASS_BEGIN, // multi render commandlist render pass subpass begin 164 }; 165 166 enum class RenderPassEndType : uint32_t { 167 END_RENDER_PASS, 168 END_SUBPASS, 169 }; 170 171 struct RenderCommandDraw { 172 DrawType drawType { DrawType::UNDEFINED }; 173 174 uint32_t vertexCount { 0 }; 175 uint32_t instanceCount { 0 }; 176 uint32_t firstVertex { 0 }; 177 uint32_t firstInstance { 0 }; 178 179 uint32_t indexCount { 0 }; 180 uint32_t firstIndex { 0 }; 181 int32_t vertexOffset { 0 }; 182 }; 183 184 struct RenderCommandDrawIndirect { 185 DrawType drawType { DrawType::UNDEFINED }; 186 187 RenderHandle argsHandle; 188 uint32_t offset { 0 }; 189 uint32_t drawCount { 0 }; 190 uint32_t stride { 0 }; 191 }; 192 193 struct RenderCommandDispatch { 194 uint32_t groupCountX { 0 }; 195 uint32_t groupCountY { 0 }; 196 uint32_t groupCountZ { 0 }; 197 }; 198 199 struct RenderCommandDispatchIndirect { 200 RenderHandle argsHandle; 201 uint32_t offset { 0 }; 202 }; 203 204 struct RenderCommandBindPipeline { 205 RenderHandle psoHandle; 206 PipelineBindPoint pipelineBindPoint; 207 }; 208 209 struct RenderCommandBindDescriptorSets { 210 RenderHandle psoHandle; // this is the previously BindPipeline() pso handle 211 212 uint32_t firstSet { 0u }; 213 uint32_t setCount { 0u }; 214 RenderHandle descriptorSetHandles[PipelineLayoutConstants::MAX_DESCRIPTOR_SET_COUNT] { {}, {}, {}, {} }; 215 216 struct DescriptorSetDynamicOffsets { 217 uint32_t dynamicOffsetCount { 0u }; 218 uint32_t* dynamicOffsets { nullptr }; 219 }; 220 DescriptorSetDynamicOffsets descriptorSetDynamicOffsets[PipelineLayoutConstants::MAX_DESCRIPTOR_SET_COUNT]; 221 }; 222 223 struct RenderPassImageLayouts { 224 // counts are the same as in RenderPassDesc 225 // these layouts are used for render pass hashing 226 // layouts in the beginning of the render pass 227 ImageLayout attachmentInitialLayouts[PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT] { 228 ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED 229 }; 230 231 // layouts after the render pass 232 ImageLayout attachmentFinalLayouts[PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT] { 233 ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED 234 }; 235 }; 236 237 struct RenderPassAttachmentResourceStates { 238 // the state of resources when used in render pass (subpasses) 239 GpuResourceState states[PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT] {}; 240 ImageLayout layouts[PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT] { CORE_IMAGE_LAYOUT_UNDEFINED, 241 CORE_IMAGE_LAYOUT_UNDEFINED, CORE_IMAGE_LAYOUT_UNDEFINED, CORE_IMAGE_LAYOUT_UNDEFINED, 242 CORE_IMAGE_LAYOUT_UNDEFINED, CORE_IMAGE_LAYOUT_UNDEFINED, CORE_IMAGE_LAYOUT_UNDEFINED, 243 CORE_IMAGE_LAYOUT_UNDEFINED }; 244 }; 245 246 struct RenderCommandBeginRenderPass { 247 RenderPassBeginType beginType { RenderPassBeginType::RENDER_PASS_BEGIN }; 248 RenderPassDesc renderPassDesc; 249 RenderPassImageLayouts imageLayouts; 250 RenderPassAttachmentResourceStates inputResourceStates; 251 bool enableAutomaticLayoutChanges { true }; 252 253 uint32_t subpassStartIndex { 0 }; // patched multi render command list render passes can have > 0 254 BASE_NS::array_view<RenderPassSubpassDesc> subpasses; 255 BASE_NS::array_view<RenderPassAttachmentResourceStates> subpassResourceStates; 256 }; 257 258 struct RenderCommandNextSubpass { 259 SubpassContents subpassContents { SubpassContents::CORE_SUBPASS_CONTENTS_INLINE }; 260 // index to other render command list if CORE_SUBPASS_CONTENTS_SECONDARY_COMMAND_LISTS 261 uint64_t renderCommandListIndex { 0 }; 262 }; 263 264 struct RenderCommandEndRenderPass { 265 RenderPassEndType endType { RenderPassEndType::END_RENDER_PASS }; 266 uint32_t subpassStartIndex { 0u }; 267 uint32_t subpassCount { 0u }; 268 }; 269 270 struct RenderCommandBlitImage { 271 RenderHandle srcHandle; 272 RenderHandle dstHandle; 273 274 ImageBlit imageBlit; 275 276 Filter filter { Filter::CORE_FILTER_NEAREST }; 277 278 // added already in render command list methods to correct layouts 279 ImageLayout srcImageLayout { ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED }; 280 ImageLayout dstImageLayout { ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED }; 281 }; 282 283 struct RenderCommandPushConstant { 284 RenderHandle psoHandle; // this is the previously BindPipeline() pso handle 285 286 PushConstant pushConstant; 287 uint8_t* data { nullptr }; 288 }; 289 290 struct ResourceBarrier { 291 AccessFlags accessFlags { 0 }; 292 PipelineStageFlags pipelineStageFlags { 0 }; 293 ImageLayout optionalImageLayout { ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED }; 294 uint32_t optionalByteOffset { 0 }; 295 uint32_t optionalByteSize { PipelineStateConstants::GPU_BUFFER_WHOLE_SIZE }; 296 ImageSubresourceRange optionalImageSubresourceRange {}; 297 }; 298 299 struct CommandBarrier { 300 RenderHandle resourceHandle; 301 302 ResourceBarrier src; 303 GpuQueue srcGpuQueue; 304 305 ResourceBarrier dst; 306 GpuQueue dstGpuQueue; 307 }; 308 309 struct RenderCommandBarrierPoint { 310 RenderCommandType renderCommandType { RenderCommandType::UNDEFINED }; 311 312 uint32_t barrierPointIndex { ~0u }; 313 314 uint32_t customBarrierIndexBegin { ~0u }; 315 uint32_t customBarrierCount { 0u }; 316 317 uint32_t vertexIndexBarrierIndexBegin { ~0u }; 318 uint32_t vertexIndexBarrierCount { 0u }; 319 320 uint32_t indirectBufferBarrierIndexBegin { ~0u }; 321 uint32_t indirectBufferBarrierCount { 0u }; 322 323 uint32_t descriptorSetHandleIndexBegin { ~0u }; 324 uint32_t descriptorSetHandleCount { 0 }; 325 }; 326 327 struct RenderCommandBindVertexBuffers { 328 uint32_t vertexBufferCount { 0 }; 329 VertexBuffer vertexBuffers[PipelineStateConstants::MAX_VERTEX_BUFFER_COUNT]; 330 }; 331 332 struct RenderCommandBindIndexBuffer { 333 IndexBuffer indexBuffer; 334 }; 335 336 struct RenderCommandCopyBuffer { 337 RenderHandle srcHandle; 338 RenderHandle dstHandle; 339 340 BufferCopy bufferCopy; 341 }; 342 343 struct RenderCommandCopyBufferImage { 344 enum class CopyType : uint32_t { 345 UNDEFINED = 0, 346 BUFFER_TO_IMAGE = 1, 347 IMAGE_TO_BUFFER = 2, 348 }; 349 350 CopyType copyType { CopyType::UNDEFINED }; 351 RenderHandle srcHandle; 352 RenderHandle dstHandle; 353 354 BufferImageCopy bufferImageCopy; 355 }; 356 357 struct RenderCommandCopyImage { 358 RenderHandle srcHandle; 359 RenderHandle dstHandle; 360 361 ImageCopy imageCopy; 362 }; 363 364 struct RenderCommandBuildAccelerationStructure { 365 AccelerationStructureType type { AccelerationStructureType::CORE_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL }; 366 BuildAccelerationStructureFlags flags { 0 }; 367 BuildAccelerationStructureMode mode { 368 BuildAccelerationStructureMode::CORE_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD 369 }; 370 RenderHandle srcAccelerationStructure; 371 RenderHandle dstAccelerationStructure; 372 373 RenderHandle scratchBuffer; 374 uint32_t scratchOffset { 0u }; 375 376 AccelerationStructureGeometryTrianglesData* trianglesData { nullptr }; 377 AccelerationStructureGeometryAabbsData* aabbsData { nullptr }; 378 AccelerationStructureGeometryInstancesData* instancesData { nullptr }; 379 380 BASE_NS::array_view<AccelerationStructureGeometryTrianglesData> trianglesView; 381 BASE_NS::array_view<AccelerationStructureGeometryAabbsData> aabbsView; 382 BASE_NS::array_view<AccelerationStructureGeometryInstancesData> instancesView; 383 }; 384 385 struct RenderCommandClearColorImage { 386 RenderHandle handle; 387 ClearColorValue color; 388 // added already in render command list methods to correct layout 389 ImageLayout imageLayout { CORE_IMAGE_LAYOUT_UNDEFINED }; 390 391 BASE_NS::array_view<ImageSubresourceRange> ranges; 392 }; 393 394 // dynamic states 395 struct RenderCommandDynamicStateViewport { 396 ViewportDesc viewportDesc; 397 }; 398 399 struct RenderCommandDynamicStateScissor { 400 ScissorDesc scissorDesc; 401 }; 402 403 struct RenderCommandDynamicStateLineWidth { 404 float lineWidth { 1.0f }; 405 }; 406 407 struct RenderCommandDynamicStateDepthBias { 408 float depthBiasConstantFactor { 0.0f }; 409 float depthBiasClamp { 0.0f }; 410 float depthBiasSlopeFactor { 0.0f }; 411 }; 412 413 struct RenderCommandDynamicStateBlendConstants { 414 float blendConstants[4u] { 0.0f, 0.0f, 0.0f, 0.0f }; // rgba values used in blending 415 }; 416 417 struct RenderCommandDynamicStateDepthBounds { 418 float minDepthBounds { 0.0f }; 419 float maxDepthBounds { 1.0f }; 420 }; 421 422 enum class StencilDynamicState : uint32_t { 423 UNDEFINED = 0, 424 COMPARE_MASK = 1, 425 WRITE_MASK = 2, 426 REFERENCE = 3, 427 }; 428 429 struct RenderCommandDynamicStateStencil { 430 StencilDynamicState dynamicState { StencilDynamicState::UNDEFINED }; 431 StencilFaceFlags faceMask { 0 }; 432 uint32_t mask { 0 }; 433 }; 434 435 struct RenderCommandDynamicStateFragmentShadingRate { 436 Size2D fragmentSize { 1u, 1u }; 437 FragmentShadingRateCombinerOps combinerOps {}; 438 }; 439 440 struct RenderCommandWriteTimestamp { 441 RenderHandle handle; 442 uint32_t queryIndex { 0 }; 443 PipelineStageFlagBits pipelineStageFlagBits { PipelineStageFlagBits::CORE_PIPELINE_STAGE_TOP_OF_PIPE_BIT }; 444 }; 445 446 struct RenderCommandExecuteBackendFramePosition { 447 uint64_t id { 0 }; 448 }; 449 450 #if (RENDER_DEBUG_MARKERS_ENABLED == 1) 451 struct RenderCommandBeginDebugMarker { 452 static constexpr uint32_t SIZE_OF_NAME { 128U }; 453 454 BASE_NS::fixed_string<SIZE_OF_NAME> name; 455 BASE_NS::Math::Vec4 color { 1.0f, 1.0f, 1.0f, 1.0f }; 456 }; 457 458 struct RenderCommandEndDebugMarker { 459 uint64_t id { 0 }; 460 }; 461 #endif 462 463 struct RenderCommandWithType { 464 RenderCommandType type { RenderCommandType::UNDEFINED }; 465 void* rc { nullptr }; 466 }; 467 468 struct MultiRenderPassCommandListData { 469 uint32_t subpassCount { 1u }; 470 uint32_t rpBeginCmdIndex { ~0u }; 471 uint32_t rpEndCmdIndex { ~0u }; 472 uint32_t rpBarrierCmdIndex { ~0u }; 473 bool secondaryCmdLists { false }; 474 }; 475 476 // RenderCommandList implementation 477 // NOTE: Many early optimizations cannot be done in the render command list 478 // (e.g. render pass and pipeline hashes are fully evaluated in the backend) 479 class RenderCommandList final : public IRenderCommandList { 480 public: 481 struct LinearAllocatorStruct { 482 BASE_NS::vector<BASE_NS::unique_ptr<LinearAllocator>> allocators; 483 }; 484 485 RenderCommandList(BASE_NS::string_view nodeName, NodeContextDescriptorSetManager& nodeContextDescriptorSetMgr, 486 const GpuResourceManager& gpuResourceMgr, const NodeContextPsoManager& nodeContextPsoMgr, const GpuQueue& queue, 487 bool enableMultiQueue); 488 ~RenderCommandList() = default; 489 490 // called in render node graph if multi-queue gpu release acquire barriers have been patched 491 void SetValidGpuQueueReleaseAcquireBarriers(); 492 493 BASE_NS::array_view<const RenderCommandWithType> GetRenderCommands() const; 494 uint32_t GetRenderCommandCount() const; 495 bool HasValidRenderCommands() const; 496 GpuQueue GetGpuQueue() const; 497 bool HasMultiRenderCommandListSubpasses() const; 498 MultiRenderPassCommandListData GetMultiRenderCommandListData() const; 499 // bindings are important for global descriptor set dependencies 500 bool HasGlobalDescriptorSetBindings() const; 501 502 BASE_NS::array_view<const CommandBarrier> GetCustomBarriers() const; 503 BASE_NS::array_view<const VertexBuffer> GetRenderpassVertexInputBufferBarriers() const; 504 BASE_NS::array_view<const VertexBuffer> GetRenderpassIndirectBufferBarriers() const; 505 // for barriers 506 BASE_NS::array_view<const RenderHandle> GetDescriptorSetHandles() const; 507 BASE_NS::array_view<const RenderHandle> GetUpdateDescriptorSetHandles() const; 508 509 // reset buffers and data 510 void BeginFrame(); 511 512 // preparations if needed 513 void BeforeRenderNodeExecuteFrame(); 514 // clean-up if needed 515 void AfterRenderNodeExecuteFrame(); 516 517 void Draw(const uint32_t vertexCount, const uint32_t instanceCount, 518 const uint32_t firstVertex, const uint32_t firstInstance) override; 519 void DrawIndexed(const uint32_t indexCount, const uint32_t instanceCount, const uint32_t firstIndex, 520 const int32_t vertexOffset, const uint32_t firstInstance) override; 521 void DrawIndirect(RenderHandle bufferHandle, uint32_t offset, uint32_t drawCount, uint32_t stride) override; 522 void DrawIndexedIndirect(RenderHandle bufferHandle, uint32_t offset, uint32_t drawCount, uint32_t stride) override; 523 524 void Dispatch(const uint32_t groupCountX, const uint32_t groupCountY, const uint32_t groupCountZ) override; 525 void DispatchIndirect(RenderHandle bufferHandle, uint32_t offset) override; 526 527 void BindPipeline(RenderHandle psoHandle) override; 528 529 void PushConstantData( 530 const struct RENDER_NS::PushConstant& pushConstant, BASE_NS::array_view<const uint8_t> data) override; 531 void PushConstant(const struct RENDER_NS::PushConstant& pushConstant, const uint8_t* data) override; 532 533 void BindVertexBuffers(BASE_NS::array_view<const VertexBuffer> vertexBuffers) override; 534 void BindIndexBuffer(const IndexBuffer& indexBuffer) override; 535 536 void BeginRenderPass( 537 const RenderPassDesc& renderPassDesc, BASE_NS::array_view<const RenderPassSubpassDesc> subpassDescs) override; 538 void BeginRenderPass(const RenderPassDesc& renderPassDesc, uint32_t subpassStartIdx, 539 const RenderPassSubpassDesc& subpassDescs) override; 540 void EndRenderPass() override; 541 542 void NextSubpass(const SubpassContents& subpassContents) override; 543 544 void BeginDisableAutomaticBarrierPoints() override; 545 void EndDisableAutomaticBarrierPoints() override; 546 void AddCustomBarrierPoint() override; 547 548 void CustomMemoryBarrier(const GeneralBarrier& source, const GeneralBarrier& destination) override; 549 void CustomBufferBarrier(RenderHandle handle, const BufferResourceBarrier& source, 550 const BufferResourceBarrier& destination, uint32_t byteOffset, uint32_t byteSize) override; 551 void CustomImageBarrier(RenderHandle handle, const ImageResourceBarrier& destination, 552 const ImageSubresourceRange& imageSubresourceRange) override; 553 void CustomImageBarrier(RenderHandle handle, const ImageResourceBarrier& source, 554 const ImageResourceBarrier& destination, const ImageSubresourceRange& imageSubresourceRange) override; 555 556 void CopyBufferToBuffer( 557 RenderHandle sourceHandle, RenderHandle destinationHandle, const BufferCopy& bufferCopy) override; 558 void CopyBufferToImage( 559 RenderHandle sourceHandle, RenderHandle destinationHandle, const BufferImageCopy& bufferImageCopy) override; 560 void CopyImageToBuffer( 561 RenderHandle sourceHandle, RenderHandle destinationHandle, const BufferImageCopy& bufferImageCopy) override; 562 void CopyImageToImage( 563 RenderHandle sourceHandle, RenderHandle destinationHandle, const ImageCopy& imageCopy) override; 564 565 void BlitImage(RenderHandle sourceImageHandle, RenderHandle destinationImageHandle, const ImageBlit& imageBlit, 566 Filter filter) override; 567 568 void UpdateDescriptorSet(RenderHandle handle, const DescriptorSetLayoutBindingResources& bindingResources) override; 569 void UpdateDescriptorSets(BASE_NS::array_view<const RenderHandle> handles, 570 BASE_NS::array_view<const DescriptorSetLayoutBindingResources> bindingResources) override; 571 void BindDescriptorSet(uint32_t set, RenderHandle handle) override; 572 void BindDescriptorSet( 573 uint32_t set, RenderHandle handle, BASE_NS::array_view<const uint32_t> dynamicOffsets) override; 574 void BindDescriptorSets(uint32_t firstSet, BASE_NS::array_view<const RenderHandle> handles) override; 575 void BindDescriptorSet(uint32_t set, const BindDescriptorSetData& desriptorSetData) override; 576 void BindDescriptorSets( 577 uint32_t firstSet, BASE_NS::array_view<const BindDescriptorSetData> descriptorSetData) override; 578 579 void BuildAccelerationStructures(const AccelerationStructureBuildGeometryData& geometry, 580 BASE_NS::array_view<const AccelerationStructureGeometryTrianglesData> triangles, 581 BASE_NS::array_view<const AccelerationStructureGeometryAabbsData> aabbs, 582 BASE_NS::array_view<const AccelerationStructureGeometryInstancesData> instances) override; 583 584 void ClearColorImage( 585 RenderHandle handle, ClearColorValue color, BASE_NS::array_view<const ImageSubresourceRange> ranges) override; 586 587 // dynamic states 588 void SetDynamicStateViewport(const ViewportDesc& viewportDesc) override; 589 void SetDynamicStateScissor(const ScissorDesc& scissorDesc) override; 590 void SetDynamicStateLineWidth(const float lineWidth) override; 591 void SetDynamicStateDepthBias( 592 const float depthBiasConstantFactor, const float depthBiasClamp, const float depthBiasSlopeFactor) override; 593 void SetDynamicStateBlendConstants(BASE_NS::array_view<const float> blendConstants) override; 594 void SetDynamicStateDepthBounds(const float minDepthBounds, const float maxDepthBounds) override; 595 void SetDynamicStateStencilCompareMask(StencilFaceFlags faceMask, uint32_t compareMask) override; 596 void SetDynamicStateStencilWriteMask(StencilFaceFlags faceMask, uint32_t writeMask) override; 597 void SetDynamicStateStencilReference(StencilFaceFlags faceMask, uint32_t reference) override; 598 void SetDynamicStateFragmentShadingRate( 599 const Size2D& fragmentSize, const FragmentShadingRateCombinerOps& combinerOps) override; 600 601 void SetExecuteBackendFramePosition() override; 602 603 void BeginDebugMarker(BASE_NS::string_view name) override; 604 void BeginDebugMarker(BASE_NS::string_view name, BASE_NS::Math::Vec4 color) override; 605 void EndDebugMarker() override; 606 607 // IInterface 608 const CORE_NS::IInterface* GetInterface(const BASE_NS::Uid& uid) const override; 609 CORE_NS::IInterface* GetInterface(const BASE_NS::Uid& uid) override; 610 void Ref() override; 611 void Unref() override; 612 613 private: 614 const BASE_NS::string nodeName_; 615 #if (RENDER_VALIDATION_ENABLED == 1) 616 // used for validation 617 const GpuResourceManager& gpuResourceMgr_; 618 const NodeContextPsoManager& psoMgr_; 619 #endif 620 NodeContextDescriptorSetManager& nodeContextDescriptorSetManager_; 621 622 // add barrier/synchronization point where descriptor resources need to be synchronized 623 // on gfx this happens before BeginRenderPass() 624 // on compute this happens before Dispatch -methods 625 void AddBarrierPoint(const RenderCommandType renderCommandType); 626 627 bool ProcessInputAttachments(const RenderPassDesc& renderPassDsc, const RenderPassSubpassDesc& subpassRef, 628 RenderPassAttachmentResourceStates& subpassResourceStates); 629 bool ProcessColorAttachments(const RenderPassDesc& renderPassDsc, const RenderPassSubpassDesc& subpassRef, 630 RenderPassAttachmentResourceStates& subpassResourceStates); 631 bool ProcessResolveAttachments(const RenderPassDesc& renderPassDsc, const RenderPassSubpassDesc& subpassRef, 632 RenderPassAttachmentResourceStates& subpassResourceStates); 633 bool ProcessDepthAttachments(const RenderPassDesc& renderPassDsc, const RenderPassSubpassDesc& subpassRef, 634 RenderPassAttachmentResourceStates& subpassResourceStates); 635 bool ProcessFragmentShadingRateAttachments(const RenderPassDesc& renderPassDsc, 636 const RenderPassSubpassDesc& subpassRef, RenderPassAttachmentResourceStates& subpassResourceStates); 637 638 void ValidateRenderPass(const RenderPassDesc& renderPassDesc); 639 void ValidatePipeline(); 640 void ValidatePipelineLayout(); 641 642 struct DescriptorSetBind { 643 RenderHandle descriptorSetHandle; 644 bool hasDynamicBarrierResources { false }; 645 }; 646 struct CustomBarrierIndices { 647 int32_t prevSize { 0 }; 648 bool dirtyCustomBarriers { false }; 649 }; 650 651 // state data is mostly for validation 652 struct StateData { 653 bool validCommandList { true }; 654 bool validPso { false }; 655 bool renderPassHasBegun { false }; 656 bool automaticBarriersEnabled { true }; 657 bool executeBackendFrameSet { false }; 658 659 bool dirtyDescriptorSetsForBarriers { false }; 660 661 uint32_t renderPassStartIndex { 0u }; 662 uint32_t renderPassSubpassCount { 0u }; 663 664 uint32_t currentBarrierPointIndex { 0u }; 665 666 // handle for validation 667 RenderHandle currentPsoHandle; 668 bool checkBindPipelineLayout { false }; 669 PipelineBindPoint currentPsoBindPoint { PipelineBindPoint::CORE_PIPELINE_BIND_POINT_GRAPHICS }; 670 671 uint32_t currentBoundSetsMask { 0u }; // bitmask for all descriptor sets 672 DescriptorSetBind currentBoundSets[PipelineLayoutConstants::MAX_DESCRIPTOR_SET_COUNT]; 673 CustomBarrierIndices currentCustomBarrierIndices; 674 675 RenderCommandBarrierPoint* currentBarrierPoint { nullptr }; 676 }; 677 StateData stateData_; 678 ResetStateData()679 void ResetStateData() 680 { 681 stateData_ = {}; 682 } 683 684 GpuQueue gpuQueue_; 685 // if device has enabled multiple queues this is true 686 bool enableMultiQueue_ { false }; 687 // true if valid multi-queue gpu resource transfers are created in render node graph 688 bool validReleaseAcquire_ { false }; 689 // true if has any global descriptor set bindings, needed for global descriptor set dependencies 690 bool hasGlobalDescriptorSetBindings_ { false }; 691 692 // true if render pass has been begun with subpasscount > 1 and not all subpasses given 693 bool hasMultiRpCommandListSubpasses_ { false }; 694 MultiRenderPassCommandListData multiRpCommandListData_ {}; 695 696 BASE_NS::vector<RenderCommandWithType> renderCommands_; 697 698 // store all custom barriers to this list and provide indices in "barrier point" 699 // barriers are batched in this point and command is commit to the real GPU command buffer 700 BASE_NS::vector<CommandBarrier> customBarriers_; 701 702 // store all vertex and index buffer barriers to this list and provide indices in "barrier point" 703 // barriers are batched in this point and command is commit to the real GPU command buffer 704 // obviously barriers are only needed in begin render pass barrier point 705 BASE_NS::vector<VertexBuffer> rpVertexInputBufferBarriers_; 706 707 // store all renderpass draw indirect barriers to this list and provide indices in "barrier point" 708 // barriers are batched in this point and command is commit to the real GPU command buffer 709 // obviously barriers are only needed in begin render pass barrier point 710 BASE_NS::vector<VertexBuffer> rpIndirectBufferBarriers_; 711 712 // store all descriptor set handles to this list and provide indices in "barrier point" 713 // barriers are batched in this point and command is commit to the real GPU command buffer 714 BASE_NS::vector<RenderHandle> descriptorSetHandlesForBarriers_; 715 716 // store all descriptor set handles which are updated to this list 717 BASE_NS::vector<RenderHandle> descriptorSetHandlesForUpdates_; 718 719 // linear allocator for render command list commands 720 LinearAllocatorStruct allocator_; 721 722 #if (RENDER_DEBUG_MARKERS_ENABLED == 1) 723 // need to end at some point 724 struct DebugMarkerStack { 725 uint32_t stackCounter { 0U }; 726 }; 727 DebugMarkerStack debugMarkerStack_; 728 #endif 729 }; 730 RENDER_END_NAMESPACE() 731 732 #endif // CORE_RENDER_RENDER_COMMAND_LIST_H 733