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