1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*
* Copyright 2019-2021 Diligent Graphics LLC
* Copyright 2015-2019 Egor Yusov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* In no event and under no legal theory, whether in tort (including negligence),
* contract, or otherwise, unless required by applicable law (such as deliberate
* and grossly negligent acts) or agreed to in writing, shall any Contributor be
* liable for any damages, including any direct, indirect, special, incidental,
* or consequential damages of any character arising as a result of this License or
* out of the use or inability to use the software (including but not limited to damages
* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
* all other commercial damages or losses), even if such Contributor has been advised
* of the possibility of such damages.
*/
#pragma once
/// \file
/// Declaration of Diligent::PipelineStateVkImpl class
#include <array>
#include <memory>
#include "EngineVkImplTraits.hpp"
#include "PipelineStateBase.hpp"
#include "PipelineResourceSignatureVkImpl.hpp" // Required by PipelineStateBase
#include "ShaderVariableManagerVk.hpp"
#include "FixedBlockMemoryAllocator.hpp"
#include "SRBMemoryAllocator.hpp"
#include "PipelineLayoutVk.hpp"
#include "VulkanUtilities/VulkanObjectWrappers.hpp"
#include "VulkanUtilities/VulkanCommandBuffer.hpp"
namespace Diligent
{
/// Pipeline state object implementation in Vulkan backend.
class PipelineStateVkImpl final : public PipelineStateBase<EngineVkImplTraits>
{
public:
using TPipelineStateBase = PipelineStateBase<EngineVkImplTraits>;
PipelineStateVkImpl(IReferenceCounters* pRefCounters, RenderDeviceVkImpl* pDeviceVk, const GraphicsPipelineStateCreateInfo& CreateInfo);
PipelineStateVkImpl(IReferenceCounters* pRefCounters, RenderDeviceVkImpl* pDeviceVk, const ComputePipelineStateCreateInfo& CreateInfo);
PipelineStateVkImpl(IReferenceCounters* pRefCounters, RenderDeviceVkImpl* pDeviceVk, const RayTracingPipelineStateCreateInfo& CreateInfo);
~PipelineStateVkImpl();
IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_PipelineStateVk, TPipelineStateBase)
/// Implementation of IPipelineStateVk::GetRenderPass().
virtual IRenderPassVk* DILIGENT_CALL_TYPE GetRenderPass() const override final { return GetRenderPassPtr().RawPtr<IRenderPassVk>(); }
/// Implementation of IPipelineStateVk::GetVkPipeline().
virtual VkPipeline DILIGENT_CALL_TYPE GetVkPipeline() const override final { return m_Pipeline; }
const PipelineLayoutVk& GetPipelineLayout() const { return m_PipelineLayout; }
static RenderPassDesc GetImplicitRenderPassDesc(Uint32 NumRenderTargets,
const TEXTURE_FORMAT RTVFormats[],
TEXTURE_FORMAT DSVFormat,
Uint8 SampleCount,
std::array<RenderPassAttachmentDesc, MAX_RENDER_TARGETS + 1>& Attachments,
std::array<AttachmentReference, MAX_RENDER_TARGETS + 1>& AttachmentReferences,
SubpassDesc& SubpassDesc);
struct ShaderStageInfo
{
ShaderStageInfo() {}
ShaderStageInfo(const ShaderVkImpl* pShader);
void Append(const ShaderVkImpl* pShader);
size_t Count() const;
// Shader stage type. All shaders in the stage must have the same type.
SHADER_TYPE Type = SHADER_TYPE_UNKNOWN;
std::vector<const ShaderVkImpl*> Shaders;
std::vector<std::vector<uint32_t>> SPIRVs;
friend SHADER_TYPE GetShaderStageType(const ShaderStageInfo& Stage) { return Stage.Type; }
};
using TShaderStages = std::vector<ShaderStageInfo>;
#ifdef DILIGENT_DEVELOPMENT
// Performs validation of SRB resource parameters that are not possible to validate
// when resource is bound.
using SRBArray = std::array<ShaderResourceBindingVkImpl*, MAX_RESOURCE_SIGNATURES>;
void DvpVerifySRBResources(const SRBArray& SRBs) const;
void DvpValidateResourceLimits() const;
#endif
private:
template <typename PSOCreateInfoType>
TShaderStages InitInternalObjects(const PSOCreateInfoType& CreateInfo,
std::vector<VkPipelineShaderStageCreateInfo>& vkShaderStages,
std::vector<VulkanUtilities::ShaderModuleWrapper>& ShaderModules);
void InitPipelineLayout(const PipelineStateCreateInfo& CreateInfo,
TShaderStages& ShaderStages);
RefCntAutoPtr<PipelineResourceSignatureVkImpl> CreateDefaultSignature(
const PipelineStateCreateInfo& CreateInfo,
const TShaderStages& ShaderStages,
Uint32 BindingIndex);
void Destruct();
VulkanUtilities::PipelineWrapper m_Pipeline;
PipelineLayoutVk m_PipelineLayout;
#ifdef DILIGENT_DEVELOPMENT
// Shader resources for all shaders in all shader stages
std::vector<std::shared_ptr<const SPIRVShaderResources>> m_ShaderResources;
// Resource attributions for every resource in m_ShaderResources, in the same order
std::vector<ResourceAttribution> m_ResourceAttibutions;
#endif
};
} // namespace Diligent
|
