1 /* 2 * Copyright (C) 2023 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/unique_ptr.h> 24 #include <base/containers/vector.h> 25 #include <base/util/formats.h> 26 #include <render/device/pipeline_layout_desc.h> 27 #include <render/device/pipeline_state_desc.h> 28 #include <render/namespace.h> 29 #include <render/nodecontext/intf_render_command_list.h> 30 #include <render/render_data_structures.h> 31 #include <render/resource_handle.h> 32 33 #include "nodecontext/pipeline_descriptor_set_binder.h" 34 #include "util/log.h" 35 36 RENDER_BEGIN_NAMESPACE() 37 class GpuResourceManager; 38 class LinearAllocator; 39 class NodeContextDescriptorSetManager; 40 class NodeContextPsoManager; 41 class RenderNodeContextManager; 42 43 enum class DrawType : uint32_t { 44 UNDEFINED = 0, 45 DRAW = 1, 46 DRAW_INDEXED = 2, 47 DRAW_INDIRECT = 3, 48 DRAW_INDEXED_INDIRECT = 4, 49 }; 50 51 // BarrierPoint is a special command which will be added before render commands 52 // that need some kind of syncing. 53 // RenderGraph is responsible for updating the barriers to be correct. 54 // 55 // BarrierPoint is added for: 56 // 57 // BeginRenderPass 58 // Dispatch 59 // DispatchIndirect 60 // 61 // CopyBuffer 62 // CopyBufferImage 63 // BlitImage 64 enum class RenderCommandType : uint32_t { 65 UNDEFINED, 66 DRAW, 67 DRAW_INDIRECT, 68 DISPATCH, 69 DISPATCH_INDIRECT, 70 BIND_PIPELINE, 71 BEGIN_RENDER_PASS, 72 NEXT_SUBPASS, 73 END_RENDER_PASS, 74 BIND_VERTEX_BUFFERS, 75 BIND_INDEX_BUFFER, 76 COPY_BUFFER, 77 COPY_BUFFER_IMAGE, 78 COPY_IMAGE, 79 BLIT_IMAGE, 80 81 BARRIER_POINT, 82 83 UPDATE_DESCRIPTOR_SETS, 84 BIND_DESCRIPTOR_SETS, 85 86 PUSH_CONSTANT, 87 88 BUILD_ACCELERATION_STRUCTURE, 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 98 EXECUTE_BACKEND_FRAME_POSITION, 99 100 WRITE_TIMESTAMP, 101 102 GPU_QUEUE_TRANSFER_RELEASE, 103 GPU_QUEUE_TRANSFER_ACQUIRE, 104 }; 105 106 enum class RenderPassBeginType : uint32_t { 107 RENDER_PASS_BEGIN, 108 RENDER_PASS_SUBPASS_BEGIN, // multi render commandlist render pass subpass begin 109 }; 110 111 enum class RenderPassEndType : uint32_t { 112 END_RENDER_PASS, 113 END_SUBPASS, 114 }; 115 116 struct RenderCommandDraw { 117 DrawType drawType { DrawType::UNDEFINED }; 118 119 uint32_t vertexCount { 0 }; 120 uint32_t instanceCount { 0 }; 121 uint32_t firstVertex { 0 }; 122 uint32_t firstInstance { 0 }; 123 124 uint32_t indexCount { 0 }; 125 uint32_t firstIndex { 0 }; 126 int32_t vertexOffset { 0 }; 127 }; 128 129 struct RenderCommandDrawIndirect { 130 DrawType drawType { DrawType::UNDEFINED }; 131 132 RenderHandle argsHandle; 133 uint32_t offset { 0 }; 134 uint32_t drawCount { 0 }; 135 uint32_t stride { 0 }; 136 }; 137 138 struct RenderCommandDispatch { 139 uint32_t groupCountX { 0 }; 140 uint32_t groupCountY { 0 }; 141 uint32_t groupCountZ { 0 }; 142 }; 143 144 struct RenderCommandDispatchIndirect { 145 RenderHandle argsHandle; 146 uint32_t offset { 0 }; 147 }; 148 149 struct RenderCommandBindPipeline { 150 RenderHandle psoHandle; 151 PipelineBindPoint pipelineBindPoint; 152 }; 153 154 struct RenderCommandUpdateDescriptorSets { 155 RenderHandle descriptorSetHandles[PipelineLayoutConstants::MAX_DESCRIPTOR_SET_COUNT] { {}, {}, {}, {} }; 156 }; 157 158 struct RenderCommandBindDescriptorSets { 159 RenderHandle psoHandle; // this is the previously BindPipeline() pso handle 160 161 uint32_t firstSet { 0u }; 162 uint32_t setCount { 0u }; 163 PLUGIN_STATIC_ASSERT(PipelineLayoutConstants::MAX_DESCRIPTOR_SET_COUNT == 4); 164 RenderHandle descriptorSetHandles[PipelineLayoutConstants::MAX_DESCRIPTOR_SET_COUNT] { {}, {}, {}, {} }; 165 166 uint32_t dynamicOffsetCount { 0u }; 167 uint32_t* dynamicOffsets { nullptr }; 168 }; 169 170 struct RenderPassImageLayouts { 171 // counts are the same as in RenderPassDesc 172 // these layouts are used for render pass hashing 173 // layouts in the beginning of the render pass 174 ImageLayout attachmentInitialLayouts[PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT] { 175 ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED 176 }; 177 178 // layouts after the render pass 179 ImageLayout attachmentFinalLayouts[PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT] { 180 ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED 181 }; 182 }; 183 184 struct RenderPassAttachmentResourceStates { 185 PLUGIN_STATIC_ASSERT(PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT == 8u); 186 // the state of resources when used in render pass (subpasses) 187 GpuResourceState states[PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT] {}; 188 ImageLayout layouts[PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT] { CORE_IMAGE_LAYOUT_UNDEFINED, 189 CORE_IMAGE_LAYOUT_UNDEFINED, CORE_IMAGE_LAYOUT_UNDEFINED, CORE_IMAGE_LAYOUT_UNDEFINED, 190 CORE_IMAGE_LAYOUT_UNDEFINED, CORE_IMAGE_LAYOUT_UNDEFINED, CORE_IMAGE_LAYOUT_UNDEFINED, 191 CORE_IMAGE_LAYOUT_UNDEFINED }; 192 }; 193 194 struct RenderCommandBeginRenderPass { 195 RenderPassBeginType beginType { RenderPassBeginType::RENDER_PASS_BEGIN }; 196 RenderPassDesc renderPassDesc; 197 RenderPassImageLayouts imageLayouts; 198 RenderPassAttachmentResourceStates inputResourceStates; 199 bool enableAutomaticLayoutChanges { true }; 200 201 uint32_t subpassStartIndex { 0 }; // patched multi render command list render passes can have > 0 202 BASE_NS::array_view<RenderPassSubpassDesc> subpasses; 203 BASE_NS::array_view<RenderPassAttachmentResourceStates> subpassResourceStates; 204 }; 205 206 struct RenderCommandNextSubpass { 207 SubpassContents subpassContents { SubpassContents::CORE_SUBPASS_CONTENTS_INLINE }; 208 // index to other render command list if CORE_SUBPASS_CONTENTS_SECONDARY_COMMAND_LISTS 209 uint64_t renderCommandListIndex { 0 }; 210 }; 211 212 struct RenderCommandEndRenderPass { 213 RenderPassEndType endType { RenderPassEndType::END_RENDER_PASS }; 214 uint32_t subpassStartIndex { 0u }; 215 uint32_t subpassCount { 0u }; 216 }; 217 218 struct RenderCommandBlitImage { 219 RenderHandle srcHandle; 220 RenderHandle dstHandle; 221 222 ImageBlit imageBlit; 223 224 Filter filter { Filter::CORE_FILTER_NEAREST }; 225 226 ImageLayout srcImageLayout { ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED }; 227 ImageLayout dstImageLayout { ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED }; 228 }; 229 230 struct RenderCommandPushConstant { 231 RenderHandle psoHandle; // this is the previously BindPipeline() pso handle 232 233 PushConstant pushConstant; 234 uint8_t* data { nullptr }; 235 }; 236 237 struct ResourceBarrier { 238 AccessFlags accessFlags { 0 }; 239 PipelineStageFlags pipelineStageFlags { 0 }; 240 ImageLayout optionalImageLayout { ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED }; 241 uint32_t optionalByteOffset { 0 }; 242 uint32_t optionalByteSize { PipelineStateConstants::GPU_BUFFER_WHOLE_SIZE }; 243 ImageSubresourceRange optionalImageSubresourceRange {}; 244 }; 245 246 struct CommandBarrier { 247 RenderHandle resourceHandle; 248 249 ResourceBarrier src; 250 GpuQueue srcGpuQueue; 251 252 ResourceBarrier dst; 253 GpuQueue dstGpuQueue; 254 }; 255 256 struct RenderCommandBarrierPoint { 257 RenderCommandType renderCommandType { RenderCommandType::UNDEFINED }; 258 259 uint32_t barrierPointIndex { ~0u }; 260 261 uint32_t customBarrierIndexBegin { ~0u }; 262 uint32_t customBarrierCount { 0u }; 263 264 uint32_t vertexIndexBarrierIndexBegin { ~0u }; 265 uint32_t vertexIndexBarrierCount { 0u }; 266 267 uint32_t descriptorSetHandleIndexBegin { ~0u }; 268 uint32_t descriptorSetHandleCount { 0 }; 269 }; 270 271 struct RenderCommandBindVertexBuffers { 272 uint32_t vertexBufferCount { 0 }; 273 VertexBuffer vertexBuffers[PipelineStateConstants::MAX_VERTEX_BUFFER_COUNT]; 274 }; 275 276 struct RenderCommandBindIndexBuffer { 277 IndexBuffer indexBuffer; 278 }; 279 280 struct RenderCommandCopyBuffer { 281 RenderHandle srcHandle; 282 RenderHandle dstHandle; 283 284 BufferCopy bufferCopy; 285 }; 286 287 struct RenderCommandCopyBufferImage { 288 enum class CopyType : uint32_t { 289 UNDEFINED = 0, 290 BUFFER_TO_IMAGE = 1, 291 IMAGE_TO_BUFFER = 2, 292 }; 293 294 CopyType copyType { CopyType::UNDEFINED }; 295 RenderHandle srcHandle; 296 RenderHandle dstHandle; 297 298 BufferImageCopy bufferImageCopy; 299 }; 300 301 struct RenderCommandCopyImage { 302 RenderHandle srcHandle; 303 RenderHandle dstHandle; 304 305 ImageCopy imageCopy; 306 }; 307 308 struct RenderCommandBuildAccelerationStructure { 309 AccelerationStructureType type { AccelerationStructureType::CORE_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL }; 310 BuildAccelerationStructureFlags flags { 0 }; 311 BuildAccelerationStructureMode mode { 312 BuildAccelerationStructureMode::CORE_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD 313 }; 314 RenderHandle srcAccelerationStructure; 315 RenderHandle dstAccelerationStructure; 316 317 RenderHandle scratchBuffer; 318 uint32_t scratchOffset { 0u }; 319 320 AccelerationStructureGeometryTrianglesData* trianglesData { nullptr }; 321 AccelerationStructureGeometryAabbsData* aabbsData { nullptr }; 322 AccelerationStructureGeometryInstancesData* instancesData { nullptr }; 323 324 BASE_NS::array_view<AccelerationStructureGeometryTrianglesData> trianglesView; 325 BASE_NS::array_view<AccelerationStructureGeometryAabbsData> aabbsView; 326 BASE_NS::array_view<AccelerationStructureGeometryInstancesData> instancesView; 327 }; 328 329 // dynamic states 330 struct RenderCommandDynamicStateViewport { 331 ViewportDesc viewportDesc; 332 }; 333 334 struct RenderCommandDynamicStateScissor { 335 ScissorDesc scissorDesc; 336 }; 337 338 struct RenderCommandDynamicStateLineWidth { 339 float lineWidth { 1.0f }; 340 }; 341 342 struct RenderCommandDynamicStateDepthBias { 343 float depthBiasConstantFactor { 0.0f }; 344 float depthBiasClamp { 0.0f }; 345 float depthBiasSlopeFactor { 0.0f }; 346 }; 347 348 struct RenderCommandDynamicStateBlendConstants { 349 float blendConstants[4u] { 0.0f, 0.0f, 0.0f, 0.0f }; // rgba values used in blending 350 }; 351 352 struct RenderCommandDynamicStateDepthBounds { 353 float minDepthBounds { 0.0f }; 354 float maxDepthBounds { 1.0f }; 355 }; 356 357 enum class StencilDynamicState : uint32_t { 358 UNDEFINED = 0, 359 COMPARE_MASK = 1, 360 WRITE_MASK = 2, 361 REFERENCE = 3, 362 }; 363 364 struct RenderCommandDynamicStateStencil { 365 StencilDynamicState dynamicState { StencilDynamicState::UNDEFINED }; 366 StencilFaceFlags faceMask { 0 }; 367 uint32_t mask { 0 }; 368 }; 369 370 struct RenderCommandWriteTimestamp { 371 RenderHandle handle; 372 uint32_t queryIndex { 0 }; 373 PipelineStageFlagBits pipelineStageFlagBits { PipelineStageFlagBits::CORE_PIPELINE_STAGE_TOP_OF_PIPE_BIT }; 374 }; 375 376 struct RenderCommandExecuteBackendFramePosition { 377 uint64_t id { 0 }; 378 }; 379 380 struct RenderCommandWithType { 381 RenderCommandType type { RenderCommandType::UNDEFINED }; 382 void* rc { nullptr }; 383 }; 384 385 class RenderCommandList final : public IRenderCommandList { 386 public: 387 struct LinearAllocatorStruct { 388 BASE_NS::vector<BASE_NS::unique_ptr<LinearAllocator>> allocators; 389 }; 390 391 RenderCommandList(NodeContextDescriptorSetManager& nodeContextDescriptorSetMgr, 392 const GpuResourceManager& gpuResourceMgr, const NodeContextPsoManager& nodeContextPsoMgr, const GpuQueue& queue, 393 const bool enableMultiQueue); 394 ~RenderCommandList() = default; 395 396 // called in render node graph if multi-queue gpu release acquire barriers have been patched 397 void SetValidGpuQueueReleaseAcquireBarriers(); 398 399 BASE_NS::array_view<const RenderCommandWithType> GetRenderCommands() const; 400 uint32_t GetRenderCommandCount() const; 401 bool HasValidRenderCommands() const; 402 GpuQueue GetGpuQueue() const; 403 bool HasMultiRenderCommandListSubpasses() const; 404 uint32_t GetMultiRenderCommandListSubpassCount() const; 405 406 BASE_NS::array_view<const CommandBarrier> GetCustomBarriers() const; 407 BASE_NS::array_view<const VertexBuffer> GetVertexInputBufferBarriers() const; 408 // for barriers 409 BASE_NS::array_view<const RenderHandle> GetDescriptorSetHandles() const; 410 411 // reset buffers and data 412 void BeginFrame(); 413 414 // preparations if needed 415 void BeforeRenderNodeExecuteFrame(); 416 // clean-up if needed 417 void AfterRenderNodeExecuteFrame(); 418 419 void Draw(const uint32_t vertexCount, const uint32_t instanceCount, const uint32_t firstVertex, 420 const uint32_t firstInstance) override; 421 void DrawIndexed(const uint32_t indexCount, const uint32_t instanceCount, const uint32_t firstIndex, 422 const int32_t vertexOffset, const uint32_t firstInstance) override; 423 void DrawIndirect(const RenderHandle bufferHandle, const uint32_t offset, const uint32_t drawCount, 424 const uint32_t stride) override; 425 void DrawIndexedIndirect(const RenderHandle bufferHandle, const uint32_t offset, const uint32_t drawCount, 426 const uint32_t stride) override; 427 428 void Dispatch(const uint32_t groupCountX, const uint32_t groupCountY, const uint32_t groupCountZ) override; 429 void DispatchIndirect(const RenderHandle bufferHandle, const uint32_t offset) override; 430 431 void BindPipeline(const RenderHandle psoHandle) override; 432 433 void PushConstant(const RENDER_NS::PushConstant& pushConstant, const uint8_t* data) override; 434 435 void BindVertexBuffers(const BASE_NS::array_view<const VertexBuffer> vertexBuffers) override; 436 void BindIndexBuffer(const IndexBuffer& indexBuffer) override; 437 438 void BeginRenderPass(const RenderPassDesc& renderPassDesc, 439 const BASE_NS::array_view<const RenderPassSubpassDesc> subpassDescs) override; 440 void BeginRenderPass(const RenderPassDesc& renderPassDesc, const uint32_t subpassStartIdx, 441 const RenderPassSubpassDesc& subpassDescs) override; 442 void EndRenderPass() override; 443 444 void NextSubpass(const SubpassContents& subpassContents) override; 445 446 void BeginDisableAutomaticBarrierPoints() override; 447 void EndDisableAutomaticBarrierPoints() override; 448 void AddCustomBarrierPoint() override; 449 450 void CustomMemoryBarrier(const GeneralBarrier& source, const GeneralBarrier& destination) override; 451 void CustomBufferBarrier(const RenderHandle handle, const BufferResourceBarrier& source, 452 const BufferResourceBarrier& destination, const uint32_t byteOffset, const uint32_t byteSize) override; 453 void CustomImageBarrier(const RenderHandle handle, const ImageResourceBarrier& destination, 454 const ImageSubresourceRange& imageSubresourceRange) override; 455 void CustomImageBarrier(const RenderHandle handle, const ImageResourceBarrier& source, 456 const ImageResourceBarrier& destination, const ImageSubresourceRange& imageSubresourceRange) override; 457 458 void CopyBufferToBuffer( 459 const RenderHandle sourceHandle, const RenderHandle destinationHandle, const BufferCopy& bufferCopy) override; 460 void CopyBufferToImage(const RenderHandle sourceHandle, const RenderHandle destinationHandle, 461 const BufferImageCopy& bufferImageCopy) override; 462 void CopyImageToBuffer(const RenderHandle sourceHandle, const RenderHandle destinationHandle, 463 const BufferImageCopy& bufferImageCopy) override; 464 void CopyImageToImage( 465 const RenderHandle sourceHandle, const RenderHandle destinationHandle, const ImageCopy& imageCopy) override; 466 467 void BlitImage(const RenderHandle sourceImageHandle, const RenderHandle destinationImageHandle, 468 const ImageBlit& imageBlit, const Filter filter) override; 469 470 void UpdateDescriptorSet( 471 const RenderHandle handle, const DescriptorSetLayoutBindingResources& bindingResources) override; 472 void BindDescriptorSet(const uint32_t set, const RenderHandle handle) override; 473 void BindDescriptorSet(const uint32_t set, const RenderHandle handle, 474 const BASE_NS::array_view<const uint32_t> dynamicOffsets) override; 475 void BindDescriptorSets(const uint32_t firstSet, const BASE_NS::array_view<const RenderHandle> handles) override; 476 // only supports setting dynamic offsets when there is a single descriptor set 477 void BindDescriptorSets(const uint32_t firstSet, const BASE_NS::array_view<const RenderHandle> handles, 478 const BASE_NS::array_view<const uint32_t> dynamicOffsets); 479 480 void BuildAccelerationStructures(const AccelerationStructureBuildGeometryData& geometry, 481 const BASE_NS::array_view<const AccelerationStructureGeometryTrianglesData> triangles, 482 const BASE_NS::array_view<const AccelerationStructureGeometryAabbsData> aabbs, 483 const BASE_NS::array_view<const AccelerationStructureGeometryInstancesData> instances) override; 484 485 // dynamic states 486 void SetDynamicStateViewport(const ViewportDesc& viewportDesc) override; 487 void SetDynamicStateScissor(const ScissorDesc& scissorDesc) override; 488 void SetDynamicStateLineWidth(const float lineWidth) override; 489 void SetDynamicStateDepthBias( 490 const float depthBiasConstantFactor, const float depthBiasClamp, const float depthBiasSlopeFactor) override; 491 void SetDynamicStateBlendConstants(const BASE_NS::array_view<const float> blendConstants) override; 492 void SetDynamicStateDepthBounds(const float minDepthBounds, const float maxDepthBounds) override; 493 void SetDynamicStateStencilCompareMask(const StencilFaceFlags faceMask, const uint32_t compareMask) override; 494 void SetDynamicStateStencilWriteMask(const StencilFaceFlags faceMask, const uint32_t writeMask) override; 495 void SetDynamicStateStencilReference(const StencilFaceFlags faceMask, const uint32_t reference) override; 496 497 void SetExecuteBackendFramePosition() override; 498 499 // for IRenderNodeInterface GetTypeName()500 BASE_NS::string_view GetTypeName() const override 501 { 502 return "IRenderCommandList"; 503 } GetUid()504 BASE_NS::Uid GetUid() const override 505 { 506 return IRenderCommandList::UID; 507 } 508 509 private: 510 #if (RENDER_VALIDATION_ENABLED == 1) 511 // used for validation 512 const GpuResourceManager& gpuResourceMgr_; 513 const NodeContextPsoManager& psoMgr_; 514 #endif 515 NodeContextDescriptorSetManager& nodeContextDescriptorSetManager_; 516 517 // add barrier/synchronization point where descriptor resources need to be synchronized 518 // on gfx this happens before BeginRenderPass() 519 // on compute this happens before Dispatch -methods 520 void AddBarrierPoint(const RenderCommandType renderCommandType); 521 522 void ProcessInputAttachments(const RenderPassDesc& renderPassDsc, const RenderPassSubpassDesc& subpassRef, 523 RenderPassAttachmentResourceStates& subpassResourceStates); 524 void ProcessColorAttachments(const RenderPassDesc& renderPassDsc, const RenderPassSubpassDesc& subpassRef, 525 RenderPassAttachmentResourceStates& subpassResourceStates); 526 void ProcessResolveAttachments(const RenderPassDesc& renderPassDsc, const RenderPassSubpassDesc& subpassRef, 527 RenderPassAttachmentResourceStates& subpassResourceStates); 528 void ProcessDepthAttachments(const RenderPassDesc& renderPassDsc, const RenderPassSubpassDesc& subpassRef, 529 RenderPassAttachmentResourceStates& subpassResourceStates); 530 531 void ValidatePipeline(); 532 void ValidatePipelineLayout(); 533 534 struct DescriptorSetBind { 535 RenderHandle descriptorSetHandle; 536 bool hasDynamicBarrierResources { false }; 537 }; 538 struct CustomBarrierIndices { 539 int32_t prevSize { 0 }; 540 bool dirtyCustomBarriers { false }; 541 }; 542 543 // state data is mostly for validation 544 struct StateData { 545 bool validCommandList { true }; 546 bool validPso { false }; 547 bool renderPassHasBegun { false }; 548 bool automaticBarriersEnabled { true }; 549 bool executeBackendFrameSet { false }; 550 551 bool dirtyDescriptorSetsForBarriers { false }; 552 553 uint32_t renderPassStartIndex { 0u }; 554 uint32_t renderPassSubpassCount { 0u }; 555 556 uint32_t currentBarrierPointIndex { 0u }; 557 558 // handle for validation 559 RenderHandle currentPsoHandle; 560 bool checkBindPipelineLayout { false }; 561 PipelineBindPoint currentPsoBindPoint { PipelineBindPoint::CORE_PIPELINE_BIND_POINT_MAX_ENUM }; 562 563 uint32_t currentBoundSetsMask { 0u }; // bitmask for all descriptor sets 564 DescriptorSetBind currentBoundSets[PipelineLayoutConstants::MAX_DESCRIPTOR_SET_COUNT]; 565 CustomBarrierIndices currentCustomBarrierIndices; 566 567 RenderCommandBarrierPoint* currentBarrierPoint { nullptr }; 568 }; 569 StateData stateData_; 570 ResetStateData()571 void ResetStateData() 572 { 573 stateData_ = {}; 574 } 575 576 GpuQueue gpuQueue_; 577 // if device has enabled multiple queues this is true 578 bool enableMultiQueue_ { false }; 579 // true if valid multi-queue gpu resource transfers are created in render node graph 580 bool validReleaseAcquire_ { false }; 581 582 // true if render pass has been begun with subpasscount > 1 and not all subpasses given 583 bool hasMultiRenderCommandListSubpasses_ { false }; 584 uint32_t multiRendercommandListSubpassCount_ { 1u }; 585 586 BASE_NS::vector<RenderCommandWithType> renderCommands_; 587 588 // store all custom barriers to this list and provide indices in "barrier point" 589 // barriers are batched in this point and command is commit to the real GPU command buffer 590 BASE_NS::vector<CommandBarrier> customBarriers_; 591 592 // store all vertex and index buffer barriers to this list and provide indices in "barrier point" 593 // barriers are batched in this point and command is commit to the real GPU command buffer 594 // obviously barriers are only needed in begin render pass barrier point 595 BASE_NS::vector<VertexBuffer> vertexInputBufferBarriers_; 596 597 // store all descriptor set handles to this list and provide indices in "barrier point" 598 // barriers are batched in this point and command is commit to the real GPU command buffer 599 BASE_NS::vector<RenderHandle> descriptorSetHandlesForBarriers_; 600 601 // linear allocator for render command list commands 602 LinearAllocatorStruct allocator_; 603 }; 604 RENDER_END_NAMESPACE() 605 606 #endif // CORE_RENDER_RENDER_COMMAND_LIST_H 607