Divide Framework 0.1
A free and open-source 3D Framework under heavy development
Loading...
Searching...
No Matches
vkResources.cpp
Go to the documentation of this file.
1
2
3#include "Headers/vkResources.h"
4#include "Headers/VKWrapper.h"
5
6#include "Platform/Video/GLIM/glim.h"
7#include "Platform/Video/Headers/DescriptorSets.h"
8#include "Platform/Video/Headers/GenericDrawCommand.h"
9
10namespace Divide
11{
12
13 std::array<VkBlendFactor, to_base( BlendProperty::COUNT )> vkBlendTable;
14 std::array<VkBlendOp, to_base( BlendOperation::COUNT )> vkBlendOpTable;
15 std::array<VkCompareOp, to_base( ComparisonFunction::COUNT )> vkCompareFuncTable;
16 std::array<VkStencilOp, to_base( StencilOperation::COUNT )> vkStencilOpTable;
17 std::array<VkCullModeFlags, to_base( CullMode::COUNT )> vkCullModeTable;
18 std::array<VkPolygonMode, to_base( FillMode::COUNT )> vkFillModeTable;
19 std::array<VkImageType, to_base( TextureType::COUNT )> vkTextureTypeTable;
20 std::array<VkImageViewType, to_base( TextureType::COUNT )> vkTextureViewTypeTable;
21 std::array<VkPrimitiveTopology, to_base( PrimitiveTopology::COUNT )> vkPrimitiveTypeTable;
22 std::array<VkSamplerAddressMode, to_base( TextureWrap::COUNT )> vkWrapTable;
23 std::array<VkShaderStageFlagBits, to_base( ShaderType::COUNT )> vkShaderStageTable;
24 std::array<VulkanQueryType, to_base( QueryType::COUNT )> vkQueryTypeTable;
25
26 namespace Debug
27 {
28 PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = VK_NULL_HANDLE;
29 PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = VK_NULL_HANDLE;
30 PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = VK_NULL_HANDLE;
31 PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = VK_NULL_HANDLE;
32 PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = VK_NULL_HANDLE;
33
34
35 void SetObjectName( const VkDevice device, const uint64_t object, const VkObjectType objectType, const char* name )
36 {
37 if ( VK_API::s_hasDebugMarkerSupport )
38 {
39 VkDebugUtilsObjectNameInfoEXT nameInfo{};
40 nameInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
41 nameInfo.objectHandle = object;
42 nameInfo.objectType = objectType;
43 nameInfo.pObjectName = name;
44 vkSetDebugUtilsObjectNameEXT( device, &nameInfo );
45 }
46 }
47
48 void SetObjectTag( const VkDevice device, const uint64_t object, const VkObjectType objectType, const size_t tagSize, void* tagData, const uint64_t tagName )
49 {
50 if ( VK_API::s_hasDebugMarkerSupport )
51 {
52 VkDebugUtilsObjectTagInfoEXT tagInfo{};
53 tagInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT;
54 tagInfo.objectHandle = object;
55 tagInfo.objectType = objectType;
56 tagInfo.tagSize = tagSize;
57 tagInfo.tagName = tagName;
58 tagInfo.pTag = tagData;
59 vkSetDebugUtilsObjectTagEXT( device, &tagInfo );
60 }
61 }
62 }
63
64 namespace VKUtil
65 {
66
67 void SubmitRenderCommand( const GenericDrawCommand& drawCommand,
68 const VkCommandBuffer commandBuffer,
69 const bool indexed )
70 {
71 if ( drawCommand._drawCount > 0u && drawCommand._cmd.instanceCount > 0u )
72 {
73 const bool useIndirectBuffer = isEnabledOption(drawCommand, CmdRenderOptions::RENDER_INDIRECT);
74
75 if ( !useIndirectBuffer && drawCommand._cmd.instanceCount > 1u && drawCommand._drawCount > 1u ) [[unlikely]]
76 {
77 DIVIDE_UNEXPECTED_CALL_MSG( "Multi-draw is incompatible with instancing as gl_DrawID will have the wrong value (base instance is also used for buffer indexing). Split the call into multiple draw commands with manual uniform-updates in-between!" );
78 }
79 if ( indexed )
80 {
81 if ( useIndirectBuffer )
82 {
83 const size_t offset = (drawCommand._commandOffset * sizeof( IndirectIndexedDrawCommand )) + VK_API::GetStateTracker()._drawIndirectBufferOffset;
84 vkCmdDrawIndexedIndirect( commandBuffer, VK_API::GetStateTracker()._drawIndirectBuffer, offset, drawCommand._drawCount, sizeof( IndirectIndexedDrawCommand ) );
85 }
86 else
87 {
88 vkCmdDrawIndexed( commandBuffer, drawCommand._cmd.indexCount, drawCommand._cmd.instanceCount, drawCommand._cmd.firstIndex, drawCommand._cmd.baseVertex, drawCommand._cmd.baseInstance );
89 }
90 }
91 else
92 {
93 if ( useIndirectBuffer )
94 {
95 const size_t offset = (drawCommand._commandOffset * sizeof( IndirectNonIndexedDrawCommand )) + VK_API::GetStateTracker()._drawIndirectBufferOffset;
96 vkCmdDrawIndirect( commandBuffer, VK_API::GetStateTracker()._drawIndirectBuffer, offset, drawCommand._drawCount, sizeof( IndirectNonIndexedDrawCommand ) );
97 }
98 else
99 {
100 vkCmdDraw( commandBuffer, drawCommand._cmd.vertexCount, drawCommand._cmd.instanceCount, drawCommand._cmd.baseVertex, drawCommand._cmd.baseInstance );
101 }
102 }
103 }
104 }
105
106 void OnStartup( [[maybe_unused]] VkDevice device )
107 {
108 vkBlendTable[to_base( BlendProperty::ZERO )] = VK_BLEND_FACTOR_ZERO;
109 vkBlendTable[to_base( BlendProperty::ONE )] = VK_BLEND_FACTOR_ONE;
110 vkBlendTable[to_base( BlendProperty::SRC_COLOR )] = VK_BLEND_FACTOR_SRC_COLOR;
111 vkBlendTable[to_base( BlendProperty::INV_SRC_COLOR )] = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
112 vkBlendTable[to_base( BlendProperty::SRC_ALPHA )] = VK_BLEND_FACTOR_SRC_ALPHA;
113 vkBlendTable[to_base( BlendProperty::INV_SRC_ALPHA )] = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
114 vkBlendTable[to_base( BlendProperty::DEST_ALPHA )] = VK_BLEND_FACTOR_DST_ALPHA;
115 vkBlendTable[to_base( BlendProperty::INV_DEST_ALPHA )] = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
116 vkBlendTable[to_base( BlendProperty::DEST_COLOR )] = VK_BLEND_FACTOR_DST_COLOR;
117 vkBlendTable[to_base( BlendProperty::INV_DEST_COLOR )] = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
118 vkBlendTable[to_base( BlendProperty::SRC_ALPHA_SAT )] = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
119
120 vkBlendOpTable[to_base( BlendOperation::ADD )] = VK_BLEND_OP_ADD;
121 vkBlendOpTable[to_base( BlendOperation::SUBTRACT )] = VK_BLEND_OP_SUBTRACT;
122 vkBlendOpTable[to_base( BlendOperation::REV_SUBTRACT )] = VK_BLEND_OP_REVERSE_SUBTRACT;
123 vkBlendOpTable[to_base( BlendOperation::MIN )] = VK_BLEND_OP_MIN;
124 vkBlendOpTable[to_base( BlendOperation::MAX )] = VK_BLEND_OP_MAX;
125
126 vkCompareFuncTable[to_base( ComparisonFunction::NEVER )] = VK_COMPARE_OP_NEVER;
127 vkCompareFuncTable[to_base( ComparisonFunction::LESS )] = VK_COMPARE_OP_LESS;
128 vkCompareFuncTable[to_base( ComparisonFunction::EQUAL )] = VK_COMPARE_OP_EQUAL;
129 vkCompareFuncTable[to_base( ComparisonFunction::LEQUAL )] = VK_COMPARE_OP_LESS_OR_EQUAL;
130 vkCompareFuncTable[to_base( ComparisonFunction::GREATER )] = VK_COMPARE_OP_GREATER;
131 vkCompareFuncTable[to_base( ComparisonFunction::NEQUAL )] = VK_COMPARE_OP_NOT_EQUAL;
132 vkCompareFuncTable[to_base( ComparisonFunction::GEQUAL )] = VK_COMPARE_OP_GREATER_OR_EQUAL;
133 vkCompareFuncTable[to_base( ComparisonFunction::ALWAYS )] = VK_COMPARE_OP_ALWAYS;
134
135 vkStencilOpTable[to_base( StencilOperation::KEEP )] = VK_STENCIL_OP_KEEP;
136 vkStencilOpTable[to_base( StencilOperation::ZERO )] = VK_STENCIL_OP_ZERO;
137 vkStencilOpTable[to_base( StencilOperation::REPLACE )] = VK_STENCIL_OP_REPLACE;
138 vkStencilOpTable[to_base( StencilOperation::INCR )] = VK_STENCIL_OP_INCREMENT_AND_CLAMP;
139 vkStencilOpTable[to_base( StencilOperation::DECR )] = VK_STENCIL_OP_DECREMENT_AND_CLAMP;
140 vkStencilOpTable[to_base( StencilOperation::INV )] = VK_STENCIL_OP_INVERT;
141 vkStencilOpTable[to_base( StencilOperation::INCR_WRAP )] = VK_STENCIL_OP_INCREMENT_AND_WRAP;
142 vkStencilOpTable[to_base( StencilOperation::DECR_WRAP )] = VK_STENCIL_OP_DECREMENT_AND_WRAP;
143
144 vkCullModeTable[to_base( CullMode::BACK )] = VK_CULL_MODE_BACK_BIT;
145 vkCullModeTable[to_base( CullMode::FRONT )] = VK_CULL_MODE_FRONT_BIT;
146 vkCullModeTable[to_base( CullMode::ALL )] = VK_CULL_MODE_FRONT_AND_BACK;
147 vkCullModeTable[to_base( CullMode::NONE )] = VK_CULL_MODE_NONE;
148
149 vkFillModeTable[to_base( FillMode::POINT )] = VK_POLYGON_MODE_POINT;
150 vkFillModeTable[to_base( FillMode::WIREFRAME )] = VK_POLYGON_MODE_LINE;
151 vkFillModeTable[to_base( FillMode::SOLID )] = VK_POLYGON_MODE_FILL;
152
153 vkTextureTypeTable[to_base( TextureType::TEXTURE_1D )] = VK_IMAGE_TYPE_1D;
154 vkTextureTypeTable[to_base( TextureType::TEXTURE_2D )] = VK_IMAGE_TYPE_2D;
155 vkTextureTypeTable[to_base( TextureType::TEXTURE_3D )] = VK_IMAGE_TYPE_3D;
156 vkTextureTypeTable[to_base( TextureType::TEXTURE_CUBE_MAP )] = VK_IMAGE_TYPE_2D;
157 vkTextureTypeTable[to_base( TextureType::TEXTURE_1D_ARRAY )] = VK_IMAGE_TYPE_1D;
158 vkTextureTypeTable[to_base( TextureType::TEXTURE_2D_ARRAY )] = VK_IMAGE_TYPE_2D;
159 vkTextureTypeTable[to_base( TextureType::TEXTURE_CUBE_ARRAY )] = VK_IMAGE_TYPE_2D;
160
161 vkTextureViewTypeTable[to_base( TextureType::TEXTURE_1D )] = VK_IMAGE_VIEW_TYPE_1D;
162 vkTextureViewTypeTable[to_base( TextureType::TEXTURE_2D )] = VK_IMAGE_VIEW_TYPE_2D;
163 vkTextureViewTypeTable[to_base( TextureType::TEXTURE_3D )] = VK_IMAGE_VIEW_TYPE_3D;
164 vkTextureViewTypeTable[to_base( TextureType::TEXTURE_CUBE_MAP )] = VK_IMAGE_VIEW_TYPE_CUBE;
165 vkTextureViewTypeTable[to_base( TextureType::TEXTURE_1D_ARRAY )] = VK_IMAGE_VIEW_TYPE_1D_ARRAY;
166 vkTextureViewTypeTable[to_base( TextureType::TEXTURE_2D_ARRAY )] = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
167 vkTextureViewTypeTable[to_base( TextureType::TEXTURE_CUBE_ARRAY )] = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
168
169 vkPrimitiveTypeTable[to_base( PrimitiveTopology::POINTS )] = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
170 vkPrimitiveTypeTable[to_base( PrimitiveTopology::LINES )] = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
171 vkPrimitiveTypeTable[to_base( PrimitiveTopology::LINE_STRIP )] = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
172 vkPrimitiveTypeTable[to_base( PrimitiveTopology::TRIANGLES )] = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
173 vkPrimitiveTypeTable[to_base( PrimitiveTopology::TRIANGLE_STRIP )] = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
174 vkPrimitiveTypeTable[to_base( PrimitiveTopology::TRIANGLE_FAN )] = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
175 vkPrimitiveTypeTable[to_base( PrimitiveTopology::LINES_ADJANCENCY )] = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
176 vkPrimitiveTypeTable[to_base( PrimitiveTopology::LINE_STRIP_ADJACENCY )] = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
177 vkPrimitiveTypeTable[to_base( PrimitiveTopology::TRIANGLES_ADJACENCY )] = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
178 vkPrimitiveTypeTable[to_base( PrimitiveTopology::TRIANGLE_STRIP_ADJACENCY )] = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
179 vkPrimitiveTypeTable[to_base( PrimitiveTopology::PATCH )] = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
180 vkPrimitiveTypeTable[to_base( PrimitiveTopology::COMPUTE )] = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
181
182 vkWrapTable[to_base( TextureWrap::MIRROR_REPEAT )] = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
183 vkWrapTable[to_base( TextureWrap::REPEAT )] = VK_SAMPLER_ADDRESS_MODE_REPEAT;
184 vkWrapTable[to_base( TextureWrap::CLAMP_TO_EDGE )] = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
185 vkWrapTable[to_base( TextureWrap::CLAMP_TO_BORDER )] = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
186 vkWrapTable[to_base( TextureWrap::MIRROR_CLAMP_TO_EDGE )] = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
187
188 vkShaderStageTable[to_base( ShaderType::VERTEX )] = VK_SHADER_STAGE_VERTEX_BIT;
189 vkShaderStageTable[to_base( ShaderType::FRAGMENT )] = VK_SHADER_STAGE_FRAGMENT_BIT;
190 vkShaderStageTable[to_base( ShaderType::GEOMETRY )] = VK_SHADER_STAGE_GEOMETRY_BIT;
191 vkShaderStageTable[to_base( ShaderType::TESSELLATION_CTRL )] = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
192 vkShaderStageTable[to_base( ShaderType::TESSELLATION_EVAL )] = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
193 vkShaderStageTable[to_base( ShaderType::COMPUTE )] = VK_SHADER_STAGE_COMPUTE_BIT;
194
195 vkQueryTypeTable[to_U8(log2( to_base( QueryType::VERTICES_SUBMITTED ) ) ) - 1]._statistics = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT;
196 vkQueryTypeTable[to_U8(log2( to_base( QueryType::PRIMITIVES_GENERATED ) ) ) - 1]._queryType = VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT;
197 vkQueryTypeTable[to_U8(log2( to_base( QueryType::TESSELLATION_PATCHES ) ) ) - 1]._statistics = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT;
198 vkQueryTypeTable[to_U8(log2( to_base( QueryType::TESSELLATION_EVAL_INVOCATIONS ) ) ) - 1]._statistics = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT;
199 vkQueryTypeTable[to_U8(log2( to_base( QueryType::GPU_TIME ) ) ) - 1]._queryType = VK_QUERY_TYPE_TIMESTAMP;
200 vkQueryTypeTable[to_U8(log2( to_base( QueryType::SAMPLE_COUNT ) ) ) - 1]._queryType = VK_QUERY_TYPE_OCCLUSION;
201 vkQueryTypeTable[to_U8(log2( to_base( QueryType::SAMPLE_COUNT ) ) ) - 1]._accurate = true;
202 vkQueryTypeTable[to_U8(log2( to_base( QueryType::ANY_SAMPLE_RENDERED ) ) ) - 1]._queryType = VK_QUERY_TYPE_OCCLUSION;
203 }
204
205 VkFormat InternalFormat( const GFXImageFormat baseFormat, const GFXDataFormat dataType, const GFXImagePacking packing ) noexcept
206 {
207 const bool isDepth = IsDepthTexture( packing );
208 const bool isSRGB = packing == GFXImagePacking::NORMALIZED_SRGB;
209 const bool isPacked = packing == GFXImagePacking::RGB_565 || packing == GFXImagePacking::RGBA_4444;
210 const bool isNormalized = packing == GFXImagePacking::NORMALIZED || isSRGB || isDepth || isPacked;
211
212 if ( isDepth )
213 {
214 DIVIDE_ASSERT( baseFormat == GFXImageFormat::RED );
215 }
216
217 if ( isSRGB )
218 {
219 DIVIDE_ASSERT( dataType == GFXDataFormat::UNSIGNED_BYTE &&
220 baseFormat == GFXImageFormat::RGB ||
221 baseFormat == GFXImageFormat::BGR ||
222 baseFormat == GFXImageFormat::RGBA ||
223 baseFormat == GFXImageFormat::BGRA ||
224 baseFormat == GFXImageFormat::DXT1_RGB ||
225 baseFormat == GFXImageFormat::DXT1_RGBA ||
226 baseFormat == GFXImageFormat::DXT3_RGBA ||
227 baseFormat == GFXImageFormat::DXT5_RGBA ||
228 baseFormat == GFXImageFormat::BC7,
229 "VKUtil::InternalFormat: Vulkan supports VK_FORMAT_R8(G8)_SRGB and BC1/2/3/7, but OpenGL doesn't, so for now we completely ignore these formats!" );
230 }
231
232 if ( isNormalized && !isDepth )
233 {
234 DIVIDE_ASSERT( dataType == GFXDataFormat::SIGNED_BYTE ||
235 dataType == GFXDataFormat::UNSIGNED_BYTE ||
236 dataType == GFXDataFormat::SIGNED_SHORT ||
237 dataType == GFXDataFormat::UNSIGNED_SHORT );
238 }
239
240 if ( isPacked )
241 {
242 DIVIDE_ASSERT( baseFormat == GFXImageFormat::RGB ||
243 baseFormat == GFXImageFormat::BGR ||
244 baseFormat == GFXImageFormat::RGBA ||
245 baseFormat == GFXImageFormat::BGRA );
246 }
247
248 if ( baseFormat == GFXImageFormat::BGR || baseFormat == GFXImageFormat::BGRA )
249 {
250 DIVIDE_ASSERT(dataType == GFXDataFormat::UNSIGNED_BYTE ||
251 dataType == GFXDataFormat::SIGNED_BYTE,
252 "VKUtil::InternalFormat: Vulkan only supports 8Bpp for BGR(A) formats.");
253 }
254
255 switch ( baseFormat )
256 {
257 case GFXImageFormat::RED:
258 {
259 if ( packing == GFXImagePacking::DEPTH )
260 {
261 switch ( dataType )
262 {
263 case GFXDataFormat::SIGNED_BYTE:
264 case GFXDataFormat::UNSIGNED_BYTE:
265 case GFXDataFormat::SIGNED_SHORT:
266 case GFXDataFormat::UNSIGNED_SHORT: return VK_FORMAT_D16_UNORM;
267 case GFXDataFormat::SIGNED_INT:
268 case GFXDataFormat::UNSIGNED_INT: return VK_API::s_depthFormatInformation._d24x8Supported ? VK_FORMAT_X8_D24_UNORM_PACK32 : VK_FORMAT_D32_SFLOAT;
269 case GFXDataFormat::FLOAT_16: DIVIDE_UNEXPECTED_CALL_MSG( "VKUtil::InternalFormat: Vulkan does not support half-float depth buffers!" ); break;
270 case GFXDataFormat::FLOAT_32: return VK_API::s_depthFormatInformation._d32FSupported ? VK_FORMAT_D32_SFLOAT : VK_FORMAT_X8_D24_UNORM_PACK32;
271 default: break;
272 };
273 }
274 else if ( packing == GFXImagePacking::DEPTH_STENCIL )
275 {
276 switch ( dataType )
277 {
278 case GFXDataFormat::SIGNED_BYTE:
279 case GFXDataFormat::UNSIGNED_BYTE:
280 case GFXDataFormat::SIGNED_SHORT:
281 case GFXDataFormat::UNSIGNED_SHORT:
282 case GFXDataFormat::SIGNED_INT:
283 case GFXDataFormat::UNSIGNED_INT: return VK_API::s_depthFormatInformation._d24s8Supported ? VK_FORMAT_D24_UNORM_S8_UINT : VK_FORMAT_D32_SFLOAT_S8_UINT;
284 case GFXDataFormat::FLOAT_16: DIVIDE_UNEXPECTED_CALL_MSG("VKUtil::InternalFormat: Vulkan does not support half-float depth buffers!"); break;
285 case GFXDataFormat::FLOAT_32: return VK_API::s_depthFormatInformation._d32s8Supported ? VK_FORMAT_D32_SFLOAT_S8_UINT : VK_FORMAT_D24_UNORM_S8_UINT;
286 default: break;
287 };
288 }
289 else
290 {
291 switch ( dataType )
292 {
293 case GFXDataFormat::UNSIGNED_BYTE: return isNormalized ? VK_FORMAT_R8_UNORM : VK_FORMAT_R8_UINT;
294 case GFXDataFormat::UNSIGNED_SHORT: return isNormalized ? VK_FORMAT_R16_UNORM : VK_FORMAT_R16_UINT;
295 case GFXDataFormat::SIGNED_BYTE: return isNormalized ? VK_FORMAT_R8_SNORM : VK_FORMAT_R8_SINT;
296 case GFXDataFormat::SIGNED_SHORT: return isNormalized ? VK_FORMAT_R16_SNORM : VK_FORMAT_R16_SINT;
297 case GFXDataFormat::UNSIGNED_INT: return VK_FORMAT_R32_UINT;
298 case GFXDataFormat::SIGNED_INT: return VK_FORMAT_R32_SINT;
299 case GFXDataFormat::FLOAT_16: return VK_FORMAT_R16_SFLOAT;
300 case GFXDataFormat::FLOAT_32: return VK_FORMAT_R32_SFLOAT;
301 default: break;
302 };
303 }
304 }break;
305 case GFXImageFormat::RG:
306 {
307 switch ( dataType )
308 {
309 case GFXDataFormat::UNSIGNED_BYTE: return isNormalized ? VK_FORMAT_R8G8_UNORM : VK_FORMAT_R8G8_UINT;
310 case GFXDataFormat::UNSIGNED_SHORT: return isNormalized ? VK_FORMAT_R16G16_UNORM : VK_FORMAT_R16G16_UINT;
311 case GFXDataFormat::SIGNED_BYTE: return isNormalized ? VK_FORMAT_R8G8_SNORM : VK_FORMAT_R8G8_SINT;
312 case GFXDataFormat::SIGNED_SHORT: return isNormalized ? VK_FORMAT_R16G16_SNORM : VK_FORMAT_R16G16_SINT;
313 case GFXDataFormat::UNSIGNED_INT: return VK_FORMAT_R32G32_UINT;
314 case GFXDataFormat::SIGNED_INT: return VK_FORMAT_R32G32_SINT;
315 case GFXDataFormat::FLOAT_16: return VK_FORMAT_R16G16_SFLOAT;
316 case GFXDataFormat::FLOAT_32: return VK_FORMAT_R32G32_SFLOAT;
317 default: break;
318 };
319 }break;
320 case GFXImageFormat::BGR:
321 {
322 if ( packing == GFXImagePacking::RGB_565 )
323 {
324 return VK_FORMAT_B5G6R5_UNORM_PACK16;
325 }
326 else
327 {
328 switch ( dataType )
329 {
330 case GFXDataFormat::UNSIGNED_BYTE: return isNormalized ? (isSRGB ? VK_FORMAT_B8G8R8_SRGB : VK_FORMAT_B8G8R8_UNORM) : VK_FORMAT_B8G8R8_UINT;
331 case GFXDataFormat::SIGNED_BYTE : return isNormalized ? VK_FORMAT_B8G8R8_SNORM : VK_FORMAT_B8G8R8_SINT;
332 default: break;
333 };
334 }
335 }break;
336 case GFXImageFormat::RGB:
337 {
338 if ( packing == GFXImagePacking::RGB_565 )
339 {
340 return VK_FORMAT_R5G6B5_UNORM_PACK16;
341 }
342 else
343 {
344 switch ( dataType )
345 {
346 case GFXDataFormat::UNSIGNED_BYTE: return isNormalized ? (isSRGB ? VK_FORMAT_R8G8B8_SRGB : VK_FORMAT_R8G8B8_UNORM) : VK_FORMAT_R8G8B8_UINT;
347 case GFXDataFormat::UNSIGNED_SHORT: return isNormalized ? VK_FORMAT_R16G16B16_UNORM : VK_FORMAT_R16G16B16_UINT;
348 case GFXDataFormat::SIGNED_BYTE: return isNormalized ? VK_FORMAT_R8G8B8_SNORM : VK_FORMAT_R8G8B8_SINT;
349 case GFXDataFormat::SIGNED_SHORT: return isNormalized ? VK_FORMAT_R16G16B16_SNORM : VK_FORMAT_R16G16B16_SINT;
350 case GFXDataFormat::UNSIGNED_INT: return VK_FORMAT_R32G32B32_UINT;
351 case GFXDataFormat::SIGNED_INT: return VK_FORMAT_R32G32B32_SINT;
352 case GFXDataFormat::FLOAT_16: return VK_FORMAT_R16G16B16_SFLOAT;
353 case GFXDataFormat::FLOAT_32: return VK_FORMAT_R32G32B32_SFLOAT;
354 default: break;
355 };
356 }
357 }break;
358 case GFXImageFormat::BGRA:
359 {
360 if ( packing == GFXImagePacking::RGBA_4444 )
361 {
362 return VK_FORMAT_B4G4R4A4_UNORM_PACK16;
363 }
364 else
365 {
366 switch ( dataType )
367 {
368 case GFXDataFormat::UNSIGNED_BYTE: return isNormalized ? (isSRGB ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM) : VK_FORMAT_B8G8R8A8_UINT;
369 case GFXDataFormat::SIGNED_BYTE: return isNormalized ? VK_FORMAT_B8G8R8A8_SNORM : VK_FORMAT_B8G8R8A8_SINT;
370 default: break;
371 };
372 }
373 } break;
374 case GFXImageFormat::RGBA:
375 {
376 if ( packing == GFXImagePacking::RGBA_4444 )
377 {
378 return VK_FORMAT_R4G4B4A4_UNORM_PACK16;
379 }
380 else
381 {
382 switch ( dataType )
383 {
384 case GFXDataFormat::UNSIGNED_BYTE: return isNormalized ? (isSRGB ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM) : VK_FORMAT_R8G8B8A8_UINT;
385 case GFXDataFormat::UNSIGNED_SHORT: return isNormalized ? VK_FORMAT_R16G16B16A16_UNORM : VK_FORMAT_R16G16B16A16_UINT;
386 case GFXDataFormat::SIGNED_BYTE: return isNormalized ? VK_FORMAT_R8G8B8A8_SNORM : VK_FORMAT_R8G8B8A8_SINT;
387 case GFXDataFormat::SIGNED_SHORT: return isNormalized ? VK_FORMAT_R16G16B16A16_SNORM : VK_FORMAT_R16G16B16A16_SINT;
388 case GFXDataFormat::UNSIGNED_INT: return VK_FORMAT_R32G32B32A32_UINT;
389 case GFXDataFormat::SIGNED_INT: return VK_FORMAT_R32G32B32A32_SINT;
390 case GFXDataFormat::FLOAT_16: return VK_FORMAT_R16G16B16A16_SFLOAT;
391 case GFXDataFormat::FLOAT_32: return VK_FORMAT_R32G32B32A32_SFLOAT;
392 default: break;
393 };
394 }
395 }break;
396
397 case GFXImageFormat::DXT1_RGB: return isSRGB ? VK_FORMAT_BC1_RGB_SRGB_BLOCK : VK_FORMAT_BC1_RGB_UNORM_BLOCK;
398 case GFXImageFormat::DXT1_RGBA: return isSRGB ? VK_FORMAT_BC1_RGBA_SRGB_BLOCK : VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
399 case GFXImageFormat::DXT3_RGBA: return isSRGB ? VK_FORMAT_BC2_SRGB_BLOCK : VK_FORMAT_BC2_UNORM_BLOCK;
400 case GFXImageFormat::DXT5_RGBA: return isSRGB ? VK_FORMAT_BC3_UNORM_BLOCK : VK_FORMAT_BC3_UNORM_BLOCK;
401 case GFXImageFormat::BC7: return isSRGB ? VK_FORMAT_BC7_SRGB_BLOCK : VK_FORMAT_BC7_UNORM_BLOCK;
402 case GFXImageFormat::BC3n: return VK_FORMAT_BC3_UNORM_BLOCK;
403 case GFXImageFormat::BC4s: return VK_FORMAT_BC4_SNORM_BLOCK;
404 case GFXImageFormat::BC4u: return VK_FORMAT_BC4_UNORM_BLOCK;
405 case GFXImageFormat::BC5s: return VK_FORMAT_BC5_SNORM_BLOCK;
406 case GFXImageFormat::BC5u: return VK_FORMAT_BC5_UNORM_BLOCK;
407 case GFXImageFormat::BC6s: return VK_FORMAT_BC6H_SFLOAT_BLOCK;
408 case GFXImageFormat::BC6u: return VK_FORMAT_BC6H_UFLOAT_BLOCK;
409 default: break;
410 }
411
412 DIVIDE_UNEXPECTED_CALL();
413 return VK_FORMAT_MAX_ENUM;
414 }
415
416 VkFormat InternalFormat( const GFXDataFormat format, const U8 componentCount, const bool normalized ) noexcept
417 {
418 switch ( format )
419 {
420 case GFXDataFormat::UNSIGNED_BYTE:
421 {
422 switch ( componentCount )
423 {
424 case 1u: return normalized ? VK_FORMAT_R8_UNORM : VK_FORMAT_R8_UINT;
425 case 2u: return normalized ? VK_FORMAT_R8G8_UNORM : VK_FORMAT_R8G8_UINT;
426 case 3u: return normalized ? VK_FORMAT_R8G8B8_UNORM : VK_FORMAT_R8G8B8_UINT;
427 case 4u: return normalized ? VK_FORMAT_R8G8B8A8_UNORM : VK_FORMAT_R8G8B8A8_UINT;
428 default: break;
429 };
430 } break;
431 case GFXDataFormat::UNSIGNED_SHORT:
432 {
433 switch ( componentCount )
434 {
435 case 1u: return normalized ? VK_FORMAT_R16_UNORM : VK_FORMAT_R16_UINT;
436 case 2u: return normalized ? VK_FORMAT_R16G16_UNORM : VK_FORMAT_R16G16_UINT;
437 case 3u: return normalized ? VK_FORMAT_R16G16B16_UNORM : VK_FORMAT_R16G16B16_UINT;
438 case 4u: return normalized ? VK_FORMAT_R16G16B16A16_UNORM : VK_FORMAT_R16G16B16A16_UINT;
439 default: break;
440 };
441 } break;
442 case GFXDataFormat::UNSIGNED_INT:
443 {
444 switch ( componentCount )
445 {
446 case 1u: return VK_FORMAT_R32_UINT;
447 case 2u: return VK_FORMAT_R32G32_UINT;
448 case 3u: return VK_FORMAT_R32G32B32_UINT;
449 case 4u: return VK_FORMAT_R32G32B32A32_UINT;
450 default: break;
451 };
452 } break;
453 case GFXDataFormat::SIGNED_BYTE:
454 {
455 switch ( componentCount )
456 {
457 case 1u: return normalized ? VK_FORMAT_R8_SNORM : VK_FORMAT_R8_SINT;
458 case 2u: return normalized ? VK_FORMAT_R8_SNORM : VK_FORMAT_R8_SINT;
459 case 3u: return normalized ? VK_FORMAT_R8_SNORM : VK_FORMAT_R8_SINT;
460 case 4u: return normalized ? VK_FORMAT_R8_SNORM : VK_FORMAT_R8_SINT;
461 default: break;
462 };
463 } break;
464 case GFXDataFormat::SIGNED_SHORT:
465 {
466 switch ( componentCount )
467 {
468 case 1u: return normalized ? VK_FORMAT_R16_SNORM : VK_FORMAT_R16_SINT;
469 case 2u: return normalized ? VK_FORMAT_R16G16_SNORM : VK_FORMAT_R16G16_SINT;
470 case 3u: return normalized ? VK_FORMAT_R16G16B16_SNORM : VK_FORMAT_R16G16B16_SINT;
471 case 4u: return normalized ? VK_FORMAT_R16G16B16A16_SNORM : VK_FORMAT_R16G16B16A16_SINT;
472 default: break;
473 };
474 } break;
475 case GFXDataFormat::SIGNED_INT:
476 {
477 switch ( componentCount )
478 {
479 case 1u: return VK_FORMAT_R32_SINT;
480 case 2u: return VK_FORMAT_R32G32_SINT;
481 case 3u: return VK_FORMAT_R32G32B32_SINT;
482 case 4u: return VK_FORMAT_R32G32B32A32_SINT;
483 default: break;
484 };
485 } break;
486 case GFXDataFormat::FLOAT_16:
487 {
488 switch ( componentCount )
489 {
490 case 1u: return VK_FORMAT_R16_SFLOAT;
491 case 2u: return VK_FORMAT_R16G16_SFLOAT;
492 case 3u: return VK_FORMAT_R16G16B16_SFLOAT;
493 case 4u: return VK_FORMAT_R16G16B16A16_SFLOAT;
494 default: break;
495 };
496 } break;
497 case GFXDataFormat::FLOAT_32:
498 {
499 switch ( componentCount )
500 {
501 case 1u: return VK_FORMAT_R32_SFLOAT;
502 case 2u: return VK_FORMAT_R32G32_SFLOAT;
503 case 3u: return VK_FORMAT_R32G32B32_SFLOAT;
504 case 4u: return VK_FORMAT_R32G32B32A32_SFLOAT;
505 default: break;
506 };
507 } break;
508
509 case GFXDataFormat::COUNT: break;
510 }
511
512 DIVIDE_UNEXPECTED_CALL();
513 return VK_FORMAT_MAX_ENUM;
514 }
515
516 VkDescriptorType vkDescriptorType( const DescriptorSetBindingType type, const bool isPushDescriptor ) noexcept
517 {
518 switch ( type )
519 {
520 case DescriptorSetBindingType::COMBINED_IMAGE_SAMPLER: return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
521 case DescriptorSetBindingType::IMAGE: return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
522 case DescriptorSetBindingType::UNIFORM_BUFFER: return isPushDescriptor ? VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER : VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
523 case DescriptorSetBindingType::SHADER_STORAGE_BUFFER: return isPushDescriptor ? VK_DESCRIPTOR_TYPE_STORAGE_BUFFER : VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
524
525 case DescriptorSetBindingType::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
526 }
527
528 return VK_DESCRIPTOR_TYPE_MAX_ENUM;
529 }
530 }; //namespace VKUtil
531}; //namespace Divide
DIVIDE_ASSERT
#define DIVIDE_ASSERT(...)
Definition: PlatformDefines.h:734
DIVIDE_UNEXPECTED_CALL
#define DIVIDE_UNEXPECTED_CALL()
Definition: PlatformDefines.h:737
DIVIDE_UNEXPECTED_CALL_MSG
#define DIVIDE_UNEXPECTED_CALL_MSG(X)
Definition: PlatformDefines.h:736
Divide::VK_API::s_depthFormatInformation
static DepthFormatInformation s_depthFormatInformation
Definition: VKWrapper.h:184
Divide::VK_API::GetStateTracker
static VKStateTracker & GetStateTracker() noexcept
Definition: VKWrapper.cpp:3088
Divide::VK_API::s_hasDebugMarkerSupport
static bool s_hasDebugMarkerSupport
Definition: VKWrapper.h:179
Divide::Debug::SetObjectName
void SetObjectName(VkDevice device, uint64_t object, VkObjectType objectType, const char *name)
Definition: vkResources.cpp:35
Divide::Debug::vkSetDebugUtilsObjectNameEXT
PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT
Definition: vkResources.cpp:31
Divide::Debug::vkSetDebugUtilsObjectTagEXT
PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT
Definition: vkResources.cpp:32
Divide::Debug::vkCmdInsertDebugUtilsLabelEXT
PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT
Definition: vkResources.cpp:30
Divide::Debug::vkCmdBeginDebugUtilsLabelEXT
PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT
Definition: vkResources.cpp:28
Divide::Debug::vkCmdEndDebugUtilsLabelEXT
PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT
Definition: vkResources.cpp:29
Divide::Debug::SetObjectTag
void SetObjectTag(VkDevice device, uint64_t object, const VkObjectType objectType, size_t tagSize, void *tagData, uint64_t tagName)
Definition: vkResources.cpp:48
Divide::VKUtil::vkDescriptorType
VkDescriptorType vkDescriptorType(DescriptorSetBindingType type, bool isPushDescriptor) noexcept
Definition: vkResources.cpp:516
Divide::VKUtil::InternalFormat
VkFormat InternalFormat(GFXImageFormat baseFormat, GFXDataFormat dataType, GFXImagePacking packing) noexcept
Definition: vkResources.cpp:205
Divide::VKUtil::SubmitRenderCommand
void SubmitRenderCommand(const GenericDrawCommand &drawCommand, const VkCommandBuffer commandBuffer, bool indexed)
Note: If internal format is not GL_NONE, an indexed draw is issued!
Definition: vkResources.cpp:67
Divide::VKUtil::OnStartup
void OnStartup(VkDevice device)
Definition: vkResources.cpp:106
Divide
Handle console commands that start with a forward slash.
Definition: AIProcessor.cpp:7
Divide::vkBlendTable
std::array< VkBlendFactor, to_base(BlendProperty::COUNT)> vkBlendTable
Definition: vkResources.cpp:13
Divide::vkFillModeTable
std::array< VkPolygonMode, to_base(FillMode::COUNT)> vkFillModeTable
Definition: vkResources.cpp:18
Divide::isEnabledOption
bool isEnabledOption(const GenericDrawCommand &cmd, CmdRenderOptions option) noexcept
Definition: GenericDrawCommand.inl:37
Divide::vkBlendOpTable
std::array< VkBlendOp, to_base(BlendOperation::COUNT)> vkBlendOpTable
Definition: vkResources.cpp:14
Divide::vkTextureViewTypeTable
std::array< VkImageViewType, to_base(TextureType::COUNT)> vkTextureViewTypeTable
Definition: vkResources.cpp:20
Divide::U8
uint8_t U8
Definition: PlatformDataTypes.h:44
Divide::StencilOperation::INV
@ INV
Bitwise inverts the current stencil buffer value.
Divide::StencilOperation::COUNT
@ COUNT
Place all properties above this.
Divide::StencilOperation::ZERO
@ ZERO
Sets the stencil buffer value to 0.
Divide::StencilOperation::REPLACE
@ REPLACE
Sets the stencil buffer value to ref, as specified by StencilFunc.
Divide::StencilOperation::KEEP
@ KEEP
Keeps the current value.
Divide::StencilOperation::DECR
@ DECR
Decrements the current stencil buffer value. Clamps to 0.
Divide::vkCompareFuncTable
std::array< VkCompareOp, to_base(ComparisonFunction::COUNT)> vkCompareFuncTable
Definition: vkResources.cpp:15
Divide::BlendProperty::COUNT
@ COUNT
Place all properties above this.
Divide::BlendOperation::COUNT
@ COUNT
Place all properties above this.
Divide::IsDepthTexture
bool IsDepthTexture(GFXImagePacking packing) noexcept
Definition: TextureDescriptor.inl:69
Divide::DescriptorSetBindingType
DescriptorSetBindingType
Definition: DescriptorSetsFwd.h:48
Divide::ComparisonFunction::NEQUAL
@ NEQUAL
Passes if the incoming YYY value is not equal to the stored YYY value.
Divide::ComparisonFunction::LESS
@ LESS
Passes if the incoming YYY value is less than the stored YYY value.
Divide::ComparisonFunction::COUNT
@ COUNT
Place all properties above this.
Divide::ComparisonFunction::EQUAL
@ EQUAL
Passes if the incoming YYY value is equal to the stored YYY value.
Divide::ComparisonFunction::GREATER
@ GREATER
Passes if the incoming YYY value is greater than the stored YYY value.
Divide::vkTextureTypeTable
std::array< VkImageType, to_base(TextureType::COUNT)> vkTextureTypeTable
Definition: vkResources.cpp:19
Divide::FillMode::WIREFRAME
@ WIREFRAME
Boundary edges of the polygon are drawn as line segments.
Divide::FillMode::COUNT
@ COUNT
Place all properties above this.
Divide::FillMode::SOLID
@ SOLID
The interior of the polygon is filled.
Divide::to_U8
constexpr U8 to_U8(const T value)
Definition: PlatformDataTypes.h:284
Divide::vkWrapTable
std::array< VkSamplerAddressMode, to_base(TextureWrap::COUNT)> vkWrapTable
Definition: vkResources.cpp:22
Divide::vkPrimitiveTypeTable
std::array< VkPrimitiveTopology, to_base(PrimitiveTopology::COUNT)> vkPrimitiveTypeTable
Definition: vkResources.cpp:21
Divide::vkCullModeTable
std::array< VkCullModeFlags, to_base(CullMode::COUNT)> vkCullModeTable
Definition: vkResources.cpp:17
Divide::CullMode::BACK
@ BACK
Cull Back facing polygons (aka CW)
Divide::CullMode::COUNT
@ COUNT
Place all properties above this.
Divide::CullMode::ALL
@ ALL
Cull All polygons.
Divide::CullMode::FRONT
@ FRONT
Cull Front facing polygons (aka CCW)
Divide::vkQueryTypeTable
std::array< VulkanQueryType, to_base(QueryType::COUNT)> vkQueryTypeTable
Definition: vkResources.cpp:24
Divide::vkShaderStageTable
std::array< VkShaderStageFlagBits, to_base(ShaderType::COUNT)> vkShaderStageTable
Definition: vkResources.cpp:23
Divide::vkStencilOpTable
std::array< VkStencilOp, to_base(StencilOperation::COUNT)> vkStencilOpTable
Definition: vkResources.cpp:16
Divide::to_base
constexpr auto to_base(const Type value) -> Type
Definition: PlatformDataTypes.h:228
Divide::GenericDrawCommand::_cmd
IndirectIndexedDrawCommand _cmd
Definition: GenericDrawCommand.h:85
Divide::VK_API::DepthFormatInformation::_d32FSupported
bool _d32FSupported
Definition: VKWrapper.h:176
Divide::VK_API::DepthFormatInformation::_d24s8Supported
bool _d24s8Supported
Definition: VKWrapper.h:173
Divide::VK_API::DepthFormatInformation::_d24x8Supported
bool _d24x8Supported
Definition: VKWrapper.h:175
Divide::VK_API::DepthFormatInformation::_d32s8Supported
bool _d32s8Supported
Definition: VKWrapper.h:174
Divide::VKStateTracker::_drawIndirectBufferOffset
size_t _drawIndirectBufferOffset
Definition: vkResources.h:225