mirror of
https://github.com/godotengine/godot.git
synced 2024-11-24 13:12:42 +00:00
vulkan: Update all components to Vulkan SDK 1.3.183.0
Pass `VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT` to VMA when using Vulkan 1.3 features. Co-authored-by: Pedro J. Estébanez <pedrojrulez@gmail.com>
This commit is contained in:
parent
3ac98435ce
commit
940d629070
@ -515,8 +515,8 @@ License: Expat
|
||||
Files: ./thirdparty/vulkan/
|
||||
Comment: Vulkan Headers
|
||||
Copyright: 2014-2024, The Khronos Group Inc.
|
||||
2014-2023, Valve Corporation
|
||||
2014-2023, LunarG, Inc.
|
||||
2014-2024, Valve Corporation
|
||||
2014-2024, LunarG, Inc.
|
||||
License: Apache-2.0
|
||||
|
||||
Files: ./thirdparty/vulkan/vk_mem_alloc.h
|
||||
|
@ -999,6 +999,10 @@ Error RenderingDeviceDriverVulkan::_initialize_allocator() {
|
||||
allocator_info.physicalDevice = physical_device;
|
||||
allocator_info.device = vk_device;
|
||||
allocator_info.instance = context_driver->instance_get();
|
||||
const bool use_1_3_features = physical_device_properties.apiVersion >= VK_API_VERSION_1_3;
|
||||
if (use_1_3_features) {
|
||||
allocator_info.flags |= VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT;
|
||||
}
|
||||
VkResult err = vmaCreateAllocator(&allocator_info, &allocator);
|
||||
ERR_FAIL_COND_V_MSG(err, ERR_CANT_CREATE, "vmaCreateAllocator failed with error " + itos(err) + ".");
|
||||
|
||||
|
27
thirdparty/README.md
vendored
27
thirdparty/README.md
vendored
@ -344,7 +344,7 @@ See the patches in the `patches` directory.
|
||||
## glslang
|
||||
|
||||
- Upstream: https://github.com/KhronosGroup/glslang
|
||||
- Version: vulkan-sdk-1.3.275.0 (a91631b260cba3f22858d6c6827511e636c2458a, 2023)
|
||||
- Version: vulkan-sdk-1.3.283.0 (e8dd0b6903b34f1879520b444634c75ea2deedf5, 2024)
|
||||
- License: glslang
|
||||
|
||||
Version should be kept in sync with the one of the used Vulkan SDK (see `vulkan`
|
||||
@ -830,7 +830,7 @@ proposed by these libraries and better integrate them with Godot.
|
||||
## spirv-reflect
|
||||
|
||||
- Upstream: https://github.com/KhronosGroup/SPIRV-Reflect
|
||||
- Version: vulkan-sdk-1.3.275.0 (2f7460f0be0f73c9ffde719bc3e924b4250f4d98, 2024)
|
||||
- Version: vulkan-sdk-1.3.283.0 (ee5b57fba6a986381f998567761bbc064428e645, 2024)
|
||||
- License: Apache 2.0
|
||||
|
||||
Version should be kept in sync with the one of the used Vulkan SDK (see `vulkan`
|
||||
@ -923,15 +923,11 @@ folder.
|
||||
## volk
|
||||
|
||||
- Upstream: https://github.com/zeux/volk
|
||||
- Version: vulkan-sdk-1.3.275.0 (f2a16e3e19c2349b873343b2dc38a1d4c25af23a, 2024)
|
||||
- Version: vulkan-sdk-1.3.283.0 (3a8068a57417940cf2bf9d837a7bb60d015ca2f1, 2024)
|
||||
- License: MIT
|
||||
|
||||
Unless there is a specific reason to package a more recent version, please stick
|
||||
to tagged releases. All Vulkan libraries and headers should be kept in sync so:
|
||||
|
||||
- Update Vulkan SDK components to the matching tag (see "vulkan")
|
||||
- Update glslang (see "glslang")
|
||||
- Update spirv-reflect (see "spirv-reflect")
|
||||
Version should be kept in sync with the one of the used Vulkan SDK (see `vulkan`
|
||||
section).
|
||||
|
||||
Files extracted from upstream source:
|
||||
|
||||
@ -942,10 +938,16 @@ Files extracted from upstream source:
|
||||
## vulkan
|
||||
|
||||
- Upstream: https://github.com/KhronosGroup/Vulkan-Headers
|
||||
- Version: vulkan-sdk-1.3.275.0 (217e93c664ec6704ec2d8c36fa116c1a4a1e2d40, 2024)
|
||||
- Version: vulkan-sdk-1.3.283.0 (eaa319dade959cb61ed2229c8ea42e307cc8f8b3, 2024)
|
||||
- License: Apache 2.0
|
||||
|
||||
The vendored version should be kept in sync with volk, see above.
|
||||
Unless there is a specific reason to package a more recent version, please stick
|
||||
to tagged SDK releases. All Vulkan libraries and headers should be kept in sync so:
|
||||
|
||||
- Update Vulkan SDK components to the matching tag (see "vulkan")
|
||||
- Update volk (see "volk")
|
||||
- Update glslang (see "glslang")
|
||||
- Update spirv-reflect (see "spirv-reflect")
|
||||
|
||||
Files extracted from upstream source:
|
||||
|
||||
@ -956,8 +958,7 @@ Files extracted from upstream source:
|
||||
SDK release: https://github.com/KhronosGroup/Vulkan-Utility-Libraries/blob/main/include/vulkan/vk_enum_string_helper.h
|
||||
|
||||
`vk_mem_alloc.h` is taken from https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator
|
||||
Version: git (38627f4e37d7a9b13214fd267ec60e0e877e3997, 2024), as advised by upstream:
|
||||
https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/issues/318#issuecomment-1411804981
|
||||
Version: 3.1.0 (009ecd192c1289c7529bff248a16cfe896254816, 2024)
|
||||
`vk_mem_alloc.cpp` is a Godot file and should be preserved on updates.
|
||||
|
||||
Patches in the `patches` directory should be re-applied after updates.
|
||||
|
5
thirdparty/glslang/SPIRV/GLSL.ext.KHR.h
vendored
5
thirdparty/glslang/SPIRV/GLSL.ext.KHR.h
vendored
@ -1,5 +1,6 @@
|
||||
/*
|
||||
** Copyright (c) 2014-2020 The Khronos Group Inc.
|
||||
** Copyright (C) 2022-2024 Arm Limited.
|
||||
** Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
|
||||
**
|
||||
** Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -53,8 +54,12 @@ static const char* const E_SPV_KHR_terminate_invocation = "SPV_KHR_termi
|
||||
static const char* const E_SPV_KHR_workgroup_memory_explicit_layout = "SPV_KHR_workgroup_memory_explicit_layout";
|
||||
static const char* const E_SPV_KHR_subgroup_uniform_control_flow = "SPV_KHR_subgroup_uniform_control_flow";
|
||||
static const char* const E_SPV_KHR_fragment_shader_barycentric = "SPV_KHR_fragment_shader_barycentric";
|
||||
static const char* const E_SPV_KHR_quad_control = "SPV_KHR_quad_control";
|
||||
static const char* const E_SPV_AMD_shader_early_and_late_fragment_tests = "SPV_AMD_shader_early_and_late_fragment_tests";
|
||||
static const char* const E_SPV_KHR_ray_tracing_position_fetch = "SPV_KHR_ray_tracing_position_fetch";
|
||||
static const char* const E_SPV_KHR_cooperative_matrix = "SPV_KHR_cooperative_matrix";
|
||||
static const char* const E_SPV_KHR_maximal_reconvergence = "SPV_KHR_maximal_reconvergence";
|
||||
static const char* const E_SPV_KHR_subgroup_rotate = "SPV_KHR_subgroup_rotate";
|
||||
static const char* const E_SPV_KHR_expect_assume = "SPV_KHR_expect_assume";
|
||||
|
||||
#endif // #ifndef GLSLextKHR_H
|
||||
|
3
thirdparty/glslang/SPIRV/GLSL.ext.NV.h
vendored
3
thirdparty/glslang/SPIRV/GLSL.ext.NV.h
vendored
@ -87,4 +87,7 @@ const char* const E_SPV_NV_shader_invocation_reorder = "SPV_NV_shader_invocation
|
||||
//SPV_NV_displacement_micromap
|
||||
const char* const E_SPV_NV_displacement_micromap = "SPV_NV_displacement_micromap";
|
||||
|
||||
//SPV_NV_shader_atomic_fp16_vector
|
||||
const char* const E_SPV_NV_shader_atomic_fp16_vector = "SPV_NV_shader_atomic_fp16_vector";
|
||||
|
||||
#endif // #ifndef GLSLextNV_H
|
||||
|
2
thirdparty/glslang/SPIRV/GLSL.ext.QCOM.h
vendored
2
thirdparty/glslang/SPIRV/GLSL.ext.QCOM.h
vendored
@ -37,5 +37,7 @@ static const int GLSLextQCOMRevision = 1;
|
||||
|
||||
//SPV_QCOM_image_processing
|
||||
const char* const E_SPV_QCOM_image_processing = "SPV_QCOM_image_processing";
|
||||
//SPV_QCOM_image_processing2
|
||||
const char* const E_SPV_QCOM_image_processing2 = "SPV_QCOM_image_processing2";
|
||||
|
||||
#endif // #ifndef GLSLextQCOM_H
|
||||
|
343
thirdparty/glslang/SPIRV/GlslangToSpv.cpp
vendored
343
thirdparty/glslang/SPIRV/GlslangToSpv.cpp
vendored
@ -1,7 +1,7 @@
|
||||
//
|
||||
// Copyright (C) 2014-2016 LunarG, Inc.
|
||||
// Copyright (C) 2015-2020 Google, Inc.
|
||||
// Copyright (C) 2017 ARM Limited.
|
||||
// Copyright (C) 2017, 2022-2024 Arm Limited.
|
||||
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
// All rights reserved.
|
||||
@ -204,7 +204,8 @@ protected:
|
||||
spv::Id createBinaryMatrixOperation(spv::Op, OpDecorations&, spv::Id typeId, spv::Id left, spv::Id right);
|
||||
spv::Id createUnaryOperation(glslang::TOperator op, OpDecorations&, spv::Id typeId, spv::Id operand,
|
||||
glslang::TBasicType typeProxy,
|
||||
const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags);
|
||||
const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags,
|
||||
const glslang::TType &opType);
|
||||
spv::Id createUnaryMatrixOperation(spv::Op op, OpDecorations&, spv::Id typeId, spv::Id operand,
|
||||
glslang::TBasicType typeProxy);
|
||||
spv::Id createConversion(glslang::TOperator op, OpDecorations&, spv::Id destTypeId, spv::Id operand,
|
||||
@ -213,7 +214,8 @@ protected:
|
||||
spv::Id makeSmearedConstant(spv::Id constant, int vectorSize);
|
||||
spv::Id createAtomicOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId,
|
||||
std::vector<spv::Id>& operands, glslang::TBasicType typeProxy,
|
||||
const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags);
|
||||
const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags,
|
||||
const glslang::TType &opType);
|
||||
spv::Id createInvocationsOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands,
|
||||
glslang::TBasicType typeProxy);
|
||||
spv::Id CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation,
|
||||
@ -225,7 +227,9 @@ protected:
|
||||
spv::Id createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId);
|
||||
spv::Id getSymbolId(const glslang::TIntermSymbol* node);
|
||||
void addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier & qualifier);
|
||||
bool hasQCOMImageProceessingDecoration(spv::Id id, spv::Decoration decor);
|
||||
void addImageProcessingQCOMDecoration(spv::Id id, spv::Decoration decor);
|
||||
void addImageProcessing2QCOMDecoration(spv::Id id, bool isForGather);
|
||||
spv::Id createSpvConstant(const glslang::TIntermTyped&);
|
||||
spv::Id createSpvConstantFromConstUnionArray(const glslang::TType& type, const glslang::TConstUnionArray&,
|
||||
int& nextConst, bool specConstant);
|
||||
@ -280,6 +284,7 @@ protected:
|
||||
spv::Id taskPayloadID;
|
||||
// Used later for generating OpTraceKHR/OpExecuteCallableKHR/OpHitObjectRecordHit*/OpHitObjectGetShaderBindingTableData
|
||||
std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[4];
|
||||
std::unordered_map<spv::Id, std::vector<spv::Decoration> > idToQCOMDecorations;
|
||||
};
|
||||
|
||||
//
|
||||
@ -395,11 +400,11 @@ void TranslateMemoryDecoration(const glslang::TQualifier& qualifier, std::vector
|
||||
bool useVulkanMemoryModel)
|
||||
{
|
||||
if (!useVulkanMemoryModel) {
|
||||
if (qualifier.isCoherent())
|
||||
memory.push_back(spv::DecorationCoherent);
|
||||
if (qualifier.isVolatile()) {
|
||||
memory.push_back(spv::DecorationVolatile);
|
||||
memory.push_back(spv::DecorationCoherent);
|
||||
} else if (qualifier.isCoherent()) {
|
||||
memory.push_back(spv::DecorationCoherent);
|
||||
}
|
||||
}
|
||||
if (qualifier.isRestrict())
|
||||
@ -1163,6 +1168,7 @@ spv::ImageFormat TGlslangToSpvTraverser::TranslateImageFormat(const glslang::TTy
|
||||
case glslang::ElfR64i:
|
||||
builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
|
||||
builder.addCapability(spv::CapabilityInt64ImageEXT);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1558,8 +1564,13 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
|
||||
this->options.generateDebugInfo = true;
|
||||
|
||||
if (this->options.generateDebugInfo) {
|
||||
builder.setEmitOpLines();
|
||||
builder.setSourceFile(glslangIntermediate->getSourceFile());
|
||||
if (this->options.emitNonSemanticShaderDebugInfo) {
|
||||
builder.setEmitNonSemanticShaderDebugInfo(this->options.emitNonSemanticShaderDebugSource);
|
||||
}
|
||||
else {
|
||||
builder.setEmitSpirvDebugInfo();
|
||||
}
|
||||
builder.setDebugSourceFile(glslangIntermediate->getSourceFile());
|
||||
|
||||
// Set the source shader's text. If for SPV version 1.0, include
|
||||
// a preamble in comments stating the OpModuleProcessed instructions.
|
||||
@ -1584,9 +1595,6 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
|
||||
builder.addInclude(iItr->first, iItr->second);
|
||||
}
|
||||
|
||||
builder.setEmitNonSemanticShaderDebugInfo(this->options.emitNonSemanticShaderDebugInfo);
|
||||
builder.setEmitNonSemanticShaderDebugSource(this->options.emitNonSemanticShaderDebugSource);
|
||||
|
||||
stdBuiltins = builder.import("GLSL.std.450");
|
||||
|
||||
spv::AddressingModel addressingModel = spv::AddressingModelLogical;
|
||||
@ -1635,6 +1643,24 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
|
||||
builder.addExtension(spv::E_SPV_KHR_subgroup_uniform_control_flow);
|
||||
builder.addExecutionMode(shaderEntry, spv::ExecutionModeSubgroupUniformControlFlowKHR);
|
||||
}
|
||||
if (glslangIntermediate->getMaximallyReconverges()) {
|
||||
builder.addExtension(spv::E_SPV_KHR_maximal_reconvergence);
|
||||
builder.addExecutionMode(shaderEntry, spv::ExecutionModeMaximallyReconvergesKHR);
|
||||
}
|
||||
|
||||
if (glslangIntermediate->getQuadDerivMode())
|
||||
{
|
||||
builder.addCapability(spv::CapabilityQuadControlKHR);
|
||||
builder.addExtension(spv::E_SPV_KHR_quad_control);
|
||||
builder.addExecutionMode(shaderEntry, spv::ExecutionModeQuadDerivativesKHR);
|
||||
}
|
||||
|
||||
if (glslangIntermediate->getReqFullQuadsMode())
|
||||
{
|
||||
builder.addCapability(spv::CapabilityQuadControlKHR);
|
||||
builder.addExtension(spv::E_SPV_KHR_quad_control);
|
||||
builder.addExecutionMode(shaderEntry, spv::ExecutionModeRequireFullQuadsKHR);
|
||||
}
|
||||
|
||||
unsigned int mode;
|
||||
switch (glslangIntermediate->getStage()) {
|
||||
@ -1983,8 +2009,9 @@ void TGlslangToSpvTraverser::finishSpv(bool compileOnly)
|
||||
}
|
||||
|
||||
// finish off the entry-point SPV instruction by adding the Input/Output <id>
|
||||
for (auto it = iOSet.cbegin(); it != iOSet.cend(); ++it)
|
||||
entryPoint->addIdOperand(*it);
|
||||
entryPoint->reserveOperands(iOSet.size());
|
||||
for (auto id : iOSet)
|
||||
entryPoint->addIdOperand(id);
|
||||
}
|
||||
|
||||
// Add capabilities, extensions, remove unneeded decorations, etc.,
|
||||
@ -2019,7 +2046,9 @@ void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol)
|
||||
{
|
||||
// We update the line information even though no code might be generated here
|
||||
// This is helpful to yield correct lines for control flow instructions
|
||||
builder.setLine(symbol->getLoc().line, symbol->getLoc().getFilename());
|
||||
if (!linkageOnly) {
|
||||
builder.setDebugSourceLocation(symbol->getLoc().line, symbol->getLoc().getFilename());
|
||||
}
|
||||
|
||||
SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
|
||||
if (symbol->getType().isStruct())
|
||||
@ -2128,7 +2157,7 @@ void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol)
|
||||
|
||||
bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::TIntermBinary* node)
|
||||
{
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
if (node->getLeft()->getAsSymbolNode() != nullptr && node->getLeft()->getType().isStruct()) {
|
||||
glslangTypeToIdMap[node->getLeft()->getType().getStruct()] = node->getLeft()->getAsSymbolNode()->getId();
|
||||
}
|
||||
@ -2173,7 +2202,7 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T
|
||||
spv::Id rValue = accessChainLoad(node->getRight()->getType());
|
||||
|
||||
// reset line number for assignment
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
|
||||
if (node->getOp() != glslang::EOpAssign) {
|
||||
// the left is also an r-value
|
||||
@ -2506,7 +2535,7 @@ spv::Id TGlslangToSpvTraverser::translateForcedType(spv::Id object)
|
||||
|
||||
bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TIntermUnary* node)
|
||||
{
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
|
||||
SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
|
||||
if (node->getType().getQualifier().isSpecConstant())
|
||||
@ -2670,7 +2699,7 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
|
||||
// if not, then possibly an operation
|
||||
if (! result)
|
||||
result = createUnaryOperation(node->getOp(), decorations, resultType(), operand,
|
||||
node->getOperand()->getBasicType(), lvalueCoherentFlags);
|
||||
node->getOperand()->getBasicType(), lvalueCoherentFlags, node->getType());
|
||||
|
||||
// it could be attached to a SPIR-V intruction
|
||||
if (!result) {
|
||||
@ -2763,6 +2792,11 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
|
||||
|
||||
return false;
|
||||
|
||||
case glslang::EOpAssumeEXT:
|
||||
builder.addCapability(spv::CapabilityExpectAssumeKHR);
|
||||
builder.addExtension(spv::E_SPV_KHR_expect_assume);
|
||||
builder.createNoResultOp(spv::OpAssumeTrueKHR, operand);
|
||||
return false;
|
||||
case glslang::EOpEmitStreamVertex:
|
||||
builder.createNoResultOp(spv::OpEmitStreamVertex, operand);
|
||||
return false;
|
||||
@ -2894,11 +2928,11 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
return false;
|
||||
} else {
|
||||
if (node->getOp() == glslang::EOpScope)
|
||||
builder.enterScope(0);
|
||||
builder.enterLexicalBlock(0);
|
||||
}
|
||||
} else {
|
||||
if (sequenceDepth > 1 && node->getOp() == glslang::EOpScope)
|
||||
builder.leaveScope();
|
||||
builder.leaveLexicalBlock();
|
||||
--sequenceDepth;
|
||||
}
|
||||
|
||||
@ -2925,6 +2959,9 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
}
|
||||
case glslang::EOpFunction:
|
||||
if (visit == glslang::EvPreVisit) {
|
||||
if (options.generateDebugInfo) {
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
}
|
||||
if (isShaderEntryPoint(node)) {
|
||||
inEntryPoint = true;
|
||||
builder.setBuildPoint(shaderEntry->getLastBlock());
|
||||
@ -2933,10 +2970,10 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
} else {
|
||||
handleFunctionEntry(node);
|
||||
}
|
||||
if (options.generateDebugInfo) {
|
||||
if (options.generateDebugInfo && !options.emitNonSemanticShaderDebugInfo) {
|
||||
const auto& loc = node->getLoc();
|
||||
const char* sourceFileName = loc.getFilename();
|
||||
spv::Id sourceFileId = sourceFileName ? builder.getStringId(sourceFileName) : builder.getSourceFile();
|
||||
spv::Id sourceFileId = sourceFileName ? builder.getStringId(sourceFileName) : builder.getMainFileId();
|
||||
currentFunction->setDebugLineInfo(sourceFileId, loc.line, loc.column);
|
||||
}
|
||||
} else {
|
||||
@ -2954,7 +2991,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
return false;
|
||||
case glslang::EOpFunctionCall:
|
||||
{
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
if (node->isUserDefined())
|
||||
result = handleUserFunctionCall(node);
|
||||
if (result) {
|
||||
@ -3020,7 +3057,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
case glslang::EOpConstructF16Mat4x3:
|
||||
case glslang::EOpConstructF16Mat4x4:
|
||||
isMatrix = true;
|
||||
// fall through
|
||||
[[fallthrough]];
|
||||
case glslang::EOpConstructFloat:
|
||||
case glslang::EOpConstructVec2:
|
||||
case glslang::EOpConstructVec3:
|
||||
@ -3075,7 +3112,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
case glslang::EOpConstructCooperativeMatrixNV:
|
||||
case glslang::EOpConstructCooperativeMatrixKHR:
|
||||
{
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
std::vector<spv::Id> arguments;
|
||||
translateArguments(*node, arguments, lvalueCoherentFlags);
|
||||
spv::Id constructed;
|
||||
@ -3191,7 +3228,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
|
||||
case glslang::EOpAtomicStore:
|
||||
noReturnValue = true;
|
||||
// fallthrough
|
||||
[[fallthrough]];
|
||||
case glslang::EOpAtomicLoad:
|
||||
atomic = true;
|
||||
break;
|
||||
@ -3221,6 +3258,12 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
binOp = node->getOp();
|
||||
break;
|
||||
|
||||
case glslang::EOpExpectEXT:
|
||||
builder.addCapability(spv::CapabilityExpectAssumeKHR);
|
||||
builder.addExtension(spv::E_SPV_KHR_expect_assume);
|
||||
binOp = node->getOp();
|
||||
break;
|
||||
|
||||
case glslang::EOpIgnoreIntersectionNV:
|
||||
case glslang::EOpTerminateRayNV:
|
||||
case glslang::EOpTraceNV:
|
||||
@ -3288,7 +3331,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
|
||||
case glslang::EOpReorderThreadNV:
|
||||
noReturnValue = true;
|
||||
//Fallthrough
|
||||
[[fallthrough]];
|
||||
case glslang::EOpHitObjectIsEmptyNV:
|
||||
case glslang::EOpHitObjectIsMissNV:
|
||||
case glslang::EOpHitObjectIsHitNV:
|
||||
@ -3331,6 +3374,22 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
builder.addExtension(spv::E_SPV_QCOM_image_processing);
|
||||
break;
|
||||
|
||||
case glslang::EOpImageBlockMatchWindowSSDQCOM:
|
||||
case glslang::EOpImageBlockMatchWindowSADQCOM:
|
||||
builder.addCapability(spv::CapabilityTextureBlockMatchQCOM);
|
||||
builder.addExtension(spv::E_SPV_QCOM_image_processing);
|
||||
builder.addCapability(spv::CapabilityTextureBlockMatch2QCOM);
|
||||
builder.addExtension(spv::E_SPV_QCOM_image_processing2);
|
||||
break;
|
||||
|
||||
case glslang::EOpImageBlockMatchGatherSSDQCOM:
|
||||
case glslang::EOpImageBlockMatchGatherSADQCOM:
|
||||
builder.addCapability(spv::CapabilityTextureBlockMatchQCOM);
|
||||
builder.addExtension(spv::E_SPV_QCOM_image_processing);
|
||||
builder.addCapability(spv::CapabilityTextureBlockMatch2QCOM);
|
||||
builder.addExtension(spv::E_SPV_QCOM_image_processing2);
|
||||
break;
|
||||
|
||||
case glslang::EOpFetchMicroTriangleVertexPositionNV:
|
||||
case glslang::EOpFetchMicroTriangleVertexBarycentricNV:
|
||||
builder.addExtension(spv::E_SPV_NV_displacement_micromap);
|
||||
@ -3361,7 +3420,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
right->traverse(this);
|
||||
spv::Id rightId = accessChainLoad(right->getType());
|
||||
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
OpDecorations decorations = { precision,
|
||||
TranslateNoContractionDecoration(node->getType().getQualifier()),
|
||||
TranslateNonUniformDecoration(node->getType().getQualifier()) };
|
||||
@ -3596,7 +3655,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
|
||||
lvalueCoherentFlags |= TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType());
|
||||
} else {
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
glslang::TOperator glslangOp = node->getOp();
|
||||
if (arg == 1 &&
|
||||
(glslangOp == glslang::EOpRayQueryGetIntersectionType ||
|
||||
@ -3648,7 +3707,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
}
|
||||
}
|
||||
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
if (node->getOp() == glslang::EOpCooperativeMatrixLoad ||
|
||||
node->getOp() == glslang::EOpCooperativeMatrixLoadNV) {
|
||||
std::vector<spv::IdImmediate> idImmOps;
|
||||
@ -3739,7 +3798,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
glslang::TBasicType typeProxy = (node->getOp() == glslang::EOpAtomicStore)
|
||||
? node->getSequence()[0]->getAsTyped()->getBasicType() : node->getBasicType();
|
||||
result = createAtomicOperation(node->getOp(), precision, resultType(), operands, typeProxy,
|
||||
lvalueCoherentFlags);
|
||||
lvalueCoherentFlags, node->getType());
|
||||
} else if (node->getOp() == glslang::EOpSpirvInst) {
|
||||
const auto& spirvInst = node->getSpirvInstruction();
|
||||
if (spirvInst.set == "") {
|
||||
@ -3786,7 +3845,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
||||
result = createUnaryOperation(
|
||||
node->getOp(), decorations,
|
||||
resultType(), operands.front(),
|
||||
glslangOperands[0]->getAsTyped()->getBasicType(), lvalueCoherentFlags);
|
||||
glslangOperands[0]->getAsTyped()->getBasicType(), lvalueCoherentFlags, node->getType());
|
||||
}
|
||||
break;
|
||||
default:
|
||||
@ -3888,7 +3947,7 @@ bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang
|
||||
node->getFalseBlock()->traverse(this);
|
||||
spv::Id falseValue = accessChainLoad(node->getFalseBlock()->getAsTyped()->getType());
|
||||
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
|
||||
// done if void
|
||||
if (node->getBasicType() == glslang::EbtVoid)
|
||||
@ -4096,7 +4155,7 @@ bool TGlslangToSpvTraverser::visitLoop(glslang::TVisit /* visit */, glslang::TIn
|
||||
// instructions in it, since the body/test may have arbitrary instructions,
|
||||
// including merges of its own.
|
||||
builder.setBuildPoint(&blocks.head);
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.createLoopMerge(&blocks.merge, &blocks.continue_target, control, operands);
|
||||
if (node->testFirst() && node->getTest()) {
|
||||
spv::Block& test = builder.makeNewBlock();
|
||||
@ -4119,7 +4178,7 @@ bool TGlslangToSpvTraverser::visitLoop(glslang::TVisit /* visit */, glslang::TIn
|
||||
node->getTerminal()->traverse(this);
|
||||
builder.createBranch(&blocks.head);
|
||||
} else {
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.createBranch(&blocks.body);
|
||||
|
||||
breakForLoop.push(true);
|
||||
@ -4154,7 +4213,7 @@ bool TGlslangToSpvTraverser::visitBranch(glslang::TVisit /* visit */, glslang::T
|
||||
if (node->getExpression())
|
||||
node->getExpression()->traverse(this);
|
||||
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
|
||||
switch (node->getFlowOp()) {
|
||||
case glslang::EOpKill:
|
||||
@ -5322,17 +5381,34 @@ void TGlslangToSpvTraverser::updateMemberOffset(const glslang::TType& structType
|
||||
int memberAlignment = glslangIntermediate->getMemberAlignment(memberType, memberSize, dummyStride, explicitLayout,
|
||||
matrixLayout == glslang::ElmRowMajor);
|
||||
|
||||
bool isVectorLike = memberType.isVector();
|
||||
if (memberType.isMatrix()) {
|
||||
if (matrixLayout == glslang::ElmRowMajor)
|
||||
isVectorLike = memberType.getMatrixRows() == 1;
|
||||
else
|
||||
isVectorLike = memberType.getMatrixCols() == 1;
|
||||
}
|
||||
|
||||
// Adjust alignment for HLSL rules
|
||||
// TODO: make this consistent in early phases of code:
|
||||
// adjusting this late means inconsistencies with earlier code, which for reflection is an issue
|
||||
// Until reflection is brought in sync with these adjustments, don't apply to $Global,
|
||||
// which is the most likely to rely on reflection, and least likely to rely implicit layouts
|
||||
if (glslangIntermediate->usingHlslOffsets() &&
|
||||
! memberType.isArray() && memberType.isVector() && structType.getTypeName().compare("$Global") != 0) {
|
||||
int dummySize;
|
||||
int componentAlignment = glslangIntermediate->getBaseAlignmentScalar(memberType, dummySize);
|
||||
if (componentAlignment <= 4)
|
||||
! memberType.isStruct() && structType.getTypeName().compare("$Global") != 0) {
|
||||
int componentSize;
|
||||
int componentAlignment = glslangIntermediate->getBaseAlignmentScalar(memberType, componentSize);
|
||||
if (! memberType.isArray() && isVectorLike && componentAlignment <= 4)
|
||||
memberAlignment = componentAlignment;
|
||||
|
||||
// Don't add unnecessary padding after this member
|
||||
if (memberType.isMatrix()) {
|
||||
if (matrixLayout == glslang::ElmRowMajor)
|
||||
memberSize -= componentSize * (4 - memberType.getMatrixCols());
|
||||
else
|
||||
memberSize -= componentSize * (4 - memberType.getMatrixRows());
|
||||
} else if (memberType.isArray())
|
||||
memberSize -= componentSize * (4 - memberType.getVectorSize());
|
||||
}
|
||||
|
||||
// Bump up to member alignment
|
||||
@ -5340,7 +5416,7 @@ void TGlslangToSpvTraverser::updateMemberOffset(const glslang::TType& structType
|
||||
|
||||
// Bump up to vec4 if there is a bad straddle
|
||||
if (explicitLayout != glslang::ElpScalar && glslangIntermediate->improperStraddle(memberType, memberSize,
|
||||
currentOffset))
|
||||
currentOffset, isVectorLike))
|
||||
glslang::RoundToPow2(currentOffset, 16);
|
||||
|
||||
nextOffset = currentOffset + memberSize;
|
||||
@ -5425,8 +5501,10 @@ void TGlslangToSpvTraverser::makeFunctions(const glslang::TIntermSequence& glslF
|
||||
// memory and use RestrictPointer/AliasedPointer.
|
||||
if (originalParam(type.getQualifier().storage, type, false) ||
|
||||
!writableParam(type.getQualifier().storage)) {
|
||||
decorations.push_back(type.getQualifier().isRestrict() ? spv::DecorationRestrict :
|
||||
spv::DecorationAliased);
|
||||
// TranslateMemoryDecoration added Restrict decoration already.
|
||||
if (!type.getQualifier().isRestrict()) {
|
||||
decorations.push_back(spv::DecorationAliased);
|
||||
}
|
||||
} else {
|
||||
decorations.push_back(type.getQualifier().isRestrict() ? spv::DecorationRestrictPointerEXT :
|
||||
spv::DecorationAliasedPointerEXT);
|
||||
@ -5738,7 +5816,7 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
|
||||
if (! node->isImage() && ! node->isTexture())
|
||||
return spv::NoResult;
|
||||
|
||||
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
|
||||
builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
|
||||
|
||||
// Process a GLSL texturing op (will be SPV image)
|
||||
|
||||
@ -6041,7 +6119,7 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
|
||||
operands.push_back(*opIt);
|
||||
|
||||
return createAtomicOperation(node->getOp(), precision, resultType(), operands, typeProxy,
|
||||
lvalueCoherentFlags);
|
||||
lvalueCoherentFlags, node->getType());
|
||||
}
|
||||
}
|
||||
|
||||
@ -6566,6 +6644,10 @@ spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpD
|
||||
binOp = isUnsigned ? spv::OpUMul32x16INTEL : spv::OpIMul32x16INTEL;
|
||||
break;
|
||||
|
||||
case glslang::EOpExpectEXT:
|
||||
binOp = spv::OpExpectKHR;
|
||||
break;
|
||||
|
||||
case glslang::EOpLessThan:
|
||||
case glslang::EOpGreaterThan:
|
||||
case glslang::EOpLessThanEqual:
|
||||
@ -6788,7 +6870,8 @@ spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, OpDecora
|
||||
}
|
||||
|
||||
spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDecorations& decorations, spv::Id typeId,
|
||||
spv::Id operand, glslang::TBasicType typeProxy, const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags)
|
||||
spv::Id operand, glslang::TBasicType typeProxy, const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags,
|
||||
const glslang::TType &opType)
|
||||
{
|
||||
spv::Op unaryOp = spv::OpNop;
|
||||
int extBuiltins = -1;
|
||||
@ -7076,7 +7159,7 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDe
|
||||
// Handle all of the atomics in one place, in createAtomicOperation()
|
||||
std::vector<spv::Id> operands;
|
||||
operands.push_back(operand);
|
||||
return createAtomicOperation(op, decorations.precision, typeId, operands, typeProxy, lvalueCoherentFlags);
|
||||
return createAtomicOperation(op, decorations.precision, typeId, operands, typeProxy, lvalueCoherentFlags, opType);
|
||||
}
|
||||
|
||||
case glslang::EOpBitFieldReverse:
|
||||
@ -7169,7 +7252,9 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDe
|
||||
case glslang::EOpSubgroupExclusiveXor:
|
||||
case glslang::EOpSubgroupQuadSwapHorizontal:
|
||||
case glslang::EOpSubgroupQuadSwapVertical:
|
||||
case glslang::EOpSubgroupQuadSwapDiagonal: {
|
||||
case glslang::EOpSubgroupQuadSwapDiagonal:
|
||||
case glslang::EOpSubgroupQuadAll:
|
||||
case glslang::EOpSubgroupQuadAny: {
|
||||
std::vector<spv::Id> operands;
|
||||
operands.push_back(operand);
|
||||
return createSubgroupOperation(op, typeId, operands, typeProxy);
|
||||
@ -7792,7 +7877,7 @@ spv::Id TGlslangToSpvTraverser::makeSmearedConstant(spv::Id constant, int vector
|
||||
// For glslang ops that map to SPV atomic opCodes
|
||||
spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv::Decoration /*precision*/,
|
||||
spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy,
|
||||
const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags)
|
||||
const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags, const glslang::TType &opType)
|
||||
{
|
||||
spv::Op opCode = spv::OpNop;
|
||||
|
||||
@ -7803,14 +7888,20 @@ spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv
|
||||
opCode = spv::OpAtomicIAdd;
|
||||
if (typeProxy == glslang::EbtFloat16 || typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble) {
|
||||
opCode = spv::OpAtomicFAddEXT;
|
||||
builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_add);
|
||||
if (typeProxy == glslang::EbtFloat16) {
|
||||
builder.addExtension(spv::E_SPV_EXT_shader_atomic_float16_add);
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16AddEXT);
|
||||
} else if (typeProxy == glslang::EbtFloat) {
|
||||
builder.addCapability(spv::CapabilityAtomicFloat32AddEXT);
|
||||
if (typeProxy == glslang::EbtFloat16 &&
|
||||
(opType.getVectorSize() == 2 || opType.getVectorSize() == 4)) {
|
||||
builder.addExtension(spv::E_SPV_NV_shader_atomic_fp16_vector);
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16VectorNV);
|
||||
} else {
|
||||
builder.addCapability(spv::CapabilityAtomicFloat64AddEXT);
|
||||
builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_add);
|
||||
if (typeProxy == glslang::EbtFloat16) {
|
||||
builder.addExtension(spv::E_SPV_EXT_shader_atomic_float16_add);
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16AddEXT);
|
||||
} else if (typeProxy == glslang::EbtFloat) {
|
||||
builder.addCapability(spv::CapabilityAtomicFloat32AddEXT);
|
||||
} else {
|
||||
builder.addCapability(spv::CapabilityAtomicFloat64AddEXT);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -7823,13 +7914,19 @@ spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv
|
||||
case glslang::EOpAtomicCounterMin:
|
||||
if (typeProxy == glslang::EbtFloat16 || typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble) {
|
||||
opCode = spv::OpAtomicFMinEXT;
|
||||
builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
|
||||
if (typeProxy == glslang::EbtFloat16)
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
|
||||
else if (typeProxy == glslang::EbtFloat)
|
||||
builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
|
||||
else
|
||||
builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
|
||||
if (typeProxy == glslang::EbtFloat16 &&
|
||||
(opType.getVectorSize() == 2 || opType.getVectorSize() == 4)) {
|
||||
builder.addExtension(spv::E_SPV_NV_shader_atomic_fp16_vector);
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16VectorNV);
|
||||
} else {
|
||||
builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
|
||||
if (typeProxy == glslang::EbtFloat16)
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
|
||||
else if (typeProxy == glslang::EbtFloat)
|
||||
builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
|
||||
else
|
||||
builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
|
||||
}
|
||||
} else if (typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64) {
|
||||
opCode = spv::OpAtomicUMin;
|
||||
} else {
|
||||
@ -7841,13 +7938,19 @@ spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv
|
||||
case glslang::EOpAtomicCounterMax:
|
||||
if (typeProxy == glslang::EbtFloat16 || typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble) {
|
||||
opCode = spv::OpAtomicFMaxEXT;
|
||||
builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
|
||||
if (typeProxy == glslang::EbtFloat16)
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
|
||||
else if (typeProxy == glslang::EbtFloat)
|
||||
builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
|
||||
else
|
||||
builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
|
||||
if (typeProxy == glslang::EbtFloat16 &&
|
||||
(opType.getVectorSize() == 2 || opType.getVectorSize() == 4)) {
|
||||
builder.addExtension(spv::E_SPV_NV_shader_atomic_fp16_vector);
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16VectorNV);
|
||||
} else {
|
||||
builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
|
||||
if (typeProxy == glslang::EbtFloat16)
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
|
||||
else if (typeProxy == glslang::EbtFloat)
|
||||
builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
|
||||
else
|
||||
builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
|
||||
}
|
||||
} else if (typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64) {
|
||||
opCode = spv::OpAtomicUMax;
|
||||
} else {
|
||||
@ -7872,6 +7975,12 @@ spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv
|
||||
case glslang::EOpAtomicExchange:
|
||||
case glslang::EOpImageAtomicExchange:
|
||||
case glslang::EOpAtomicCounterExchange:
|
||||
if ((typeProxy == glslang::EbtFloat16) &&
|
||||
(opType.getVectorSize() == 2 || opType.getVectorSize() == 4)) {
|
||||
builder.addExtension(spv::E_SPV_NV_shader_atomic_fp16_vector);
|
||||
builder.addCapability(spv::CapabilityAtomicFloat16VectorNV);
|
||||
}
|
||||
|
||||
opCode = spv::OpAtomicExchange;
|
||||
break;
|
||||
case glslang::EOpAtomicCompSwap:
|
||||
@ -7970,6 +8079,7 @@ spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv
|
||||
}
|
||||
|
||||
std::vector<spv::Id> spvAtomicOperands; // hold the spv operands
|
||||
spvAtomicOperands.reserve(6);
|
||||
spvAtomicOperands.push_back(pointerId);
|
||||
spvAtomicOperands.push_back(scopeId);
|
||||
spvAtomicOperands.push_back(semanticsId);
|
||||
@ -8274,6 +8384,11 @@ spv::Id TGlslangToSpvTraverser::createSubgroupOperation(glslang::TOperator op, s
|
||||
case glslang::EOpSubgroupElect:
|
||||
builder.addCapability(spv::CapabilityGroupNonUniform);
|
||||
break;
|
||||
case glslang::EOpSubgroupQuadAll:
|
||||
case glslang::EOpSubgroupQuadAny:
|
||||
builder.addExtension(spv::E_SPV_KHR_quad_control);
|
||||
builder.addCapability(spv::CapabilityQuadControlKHR);
|
||||
[[fallthrough]];
|
||||
case glslang::EOpSubgroupAll:
|
||||
case glslang::EOpSubgroupAny:
|
||||
case glslang::EOpSubgroupAllEqual:
|
||||
@ -8293,6 +8408,11 @@ spv::Id TGlslangToSpvTraverser::createSubgroupOperation(glslang::TOperator op, s
|
||||
builder.addCapability(spv::CapabilityGroupNonUniform);
|
||||
builder.addCapability(spv::CapabilityGroupNonUniformBallot);
|
||||
break;
|
||||
case glslang::EOpSubgroupRotate:
|
||||
case glslang::EOpSubgroupClusteredRotate:
|
||||
builder.addExtension(spv::E_SPV_KHR_subgroup_rotate);
|
||||
builder.addCapability(spv::CapabilityGroupNonUniformRotateKHR);
|
||||
break;
|
||||
case glslang::EOpSubgroupShuffle:
|
||||
case glslang::EOpSubgroupShuffleXor:
|
||||
builder.addCapability(spv::CapabilityGroupNonUniform);
|
||||
@ -8381,7 +8501,9 @@ spv::Id TGlslangToSpvTraverser::createSubgroupOperation(glslang::TOperator op, s
|
||||
// Figure out which opcode to use.
|
||||
switch (op) {
|
||||
case glslang::EOpSubgroupElect: opCode = spv::OpGroupNonUniformElect; break;
|
||||
case glslang::EOpSubgroupQuadAll: opCode = spv::OpGroupNonUniformQuadAllKHR; break;
|
||||
case glslang::EOpSubgroupAll: opCode = spv::OpGroupNonUniformAll; break;
|
||||
case glslang::EOpSubgroupQuadAny: opCode = spv::OpGroupNonUniformQuadAnyKHR; break;
|
||||
case glslang::EOpSubgroupAny: opCode = spv::OpGroupNonUniformAny; break;
|
||||
case glslang::EOpSubgroupAllEqual: opCode = spv::OpGroupNonUniformAllEqual; break;
|
||||
case glslang::EOpSubgroupBroadcast: opCode = spv::OpGroupNonUniformBroadcast; break;
|
||||
@ -8398,6 +8520,8 @@ spv::Id TGlslangToSpvTraverser::createSubgroupOperation(glslang::TOperator op, s
|
||||
case glslang::EOpSubgroupShuffleXor: opCode = spv::OpGroupNonUniformShuffleXor; break;
|
||||
case glslang::EOpSubgroupShuffleUp: opCode = spv::OpGroupNonUniformShuffleUp; break;
|
||||
case glslang::EOpSubgroupShuffleDown: opCode = spv::OpGroupNonUniformShuffleDown; break;
|
||||
case glslang::EOpSubgroupRotate:
|
||||
case glslang::EOpSubgroupClusteredRotate: opCode = spv::OpGroupNonUniformRotateKHR; break;
|
||||
case glslang::EOpSubgroupAdd:
|
||||
case glslang::EOpSubgroupInclusiveAdd:
|
||||
case glslang::EOpSubgroupExclusiveAdd:
|
||||
@ -8578,7 +8702,10 @@ spv::Id TGlslangToSpvTraverser::createSubgroupOperation(glslang::TOperator op, s
|
||||
|
||||
// Every operation begins with the Execution Scope operand.
|
||||
spv::IdImmediate executionScope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
|
||||
spvGroupOperands.push_back(executionScope);
|
||||
// All other ops need the execution scope. Quad Control Ops don't need scope, it's always Quad.
|
||||
if (opCode != spv::OpGroupNonUniformQuadAllKHR && opCode != spv::OpGroupNonUniformQuadAnyKHR) {
|
||||
spvGroupOperands.push_back(executionScope);
|
||||
}
|
||||
|
||||
// Next, for all operations that use a Group Operation, push that as an operand.
|
||||
if (groupOperation != spv::GroupOperationMax) {
|
||||
@ -8821,6 +8948,8 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
|
||||
case glslang::EOpSubgroupShuffleXor:
|
||||
case glslang::EOpSubgroupShuffleUp:
|
||||
case glslang::EOpSubgroupShuffleDown:
|
||||
case glslang::EOpSubgroupRotate:
|
||||
case glslang::EOpSubgroupClusteredRotate:
|
||||
case glslang::EOpSubgroupClusteredAdd:
|
||||
case glslang::EOpSubgroupClusteredMul:
|
||||
case glslang::EOpSubgroupClusteredMin:
|
||||
@ -9179,6 +9308,30 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
|
||||
opCode = spv::OpFetchMicroTriangleVertexPositionNV;
|
||||
break;
|
||||
|
||||
case glslang::EOpImageBlockMatchWindowSSDQCOM:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
|
||||
opCode = spv::OpImageBlockMatchWindowSSDQCOM;
|
||||
addImageProcessing2QCOMDecoration(operands[0], false);
|
||||
addImageProcessing2QCOMDecoration(operands[2], false);
|
||||
break;
|
||||
case glslang::EOpImageBlockMatchWindowSADQCOM:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
|
||||
opCode = spv::OpImageBlockMatchWindowSADQCOM;
|
||||
addImageProcessing2QCOMDecoration(operands[0], false);
|
||||
addImageProcessing2QCOMDecoration(operands[2], false);
|
||||
break;
|
||||
case glslang::EOpImageBlockMatchGatherSSDQCOM:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
|
||||
opCode = spv::OpImageBlockMatchGatherSSDQCOM;
|
||||
addImageProcessing2QCOMDecoration(operands[0], true);
|
||||
addImageProcessing2QCOMDecoration(operands[2], true);
|
||||
break;
|
||||
case glslang::EOpImageBlockMatchGatherSADQCOM:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
|
||||
opCode = spv::OpImageBlockMatchGatherSADQCOM;
|
||||
addImageProcessing2QCOMDecoration(operands[0], true);
|
||||
addImageProcessing2QCOMDecoration(operands[2], true);
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
@ -9685,6 +9838,16 @@ void TGlslangToSpvTraverser::addMeshNVDecoration(spv::Id id, int member, const g
|
||||
}
|
||||
}
|
||||
|
||||
bool TGlslangToSpvTraverser::hasQCOMImageProceessingDecoration(spv::Id id, spv::Decoration decor)
|
||||
{
|
||||
std::vector<spv::Decoration> &decoVec = idToQCOMDecorations[id];
|
||||
for ( auto d : decoVec ) {
|
||||
if ( d == decor )
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void TGlslangToSpvTraverser::addImageProcessingQCOMDecoration(spv::Id id, spv::Decoration decor)
|
||||
{
|
||||
spv::Op opc = builder.getOpCode(id);
|
||||
@ -9695,7 +9858,43 @@ void TGlslangToSpvTraverser::addImageProcessingQCOMDecoration(spv::Id id, spv::D
|
||||
|
||||
if (opc == spv::OpLoad) {
|
||||
spv::Id texid = builder.getIdOperand(id, 0);
|
||||
builder.addDecoration(texid, decor);
|
||||
if (!hasQCOMImageProceessingDecoration(texid, decor)) {//
|
||||
builder.addDecoration(texid, decor);
|
||||
idToQCOMDecorations[texid].push_back(decor);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void TGlslangToSpvTraverser::addImageProcessing2QCOMDecoration(spv::Id id, bool isForGather)
|
||||
{
|
||||
if (isForGather) {
|
||||
return addImageProcessingQCOMDecoration(id, spv::DecorationBlockMatchTextureQCOM);
|
||||
}
|
||||
|
||||
auto addDecor =
|
||||
[this](spv::Id id, spv::Decoration decor) {
|
||||
spv::Id tsopc = this->builder.getOpCode(id);
|
||||
if (tsopc == spv::OpLoad) {
|
||||
spv::Id tsid = this->builder.getIdOperand(id, 0);
|
||||
if (this->glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) {
|
||||
assert(iOSet.count(tsid) > 0);
|
||||
}
|
||||
if (!hasQCOMImageProceessingDecoration(tsid, decor)) {
|
||||
this->builder.addDecoration(tsid, decor);
|
||||
idToQCOMDecorations[tsid].push_back(decor);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
spv::Id opc = builder.getOpCode(id);
|
||||
bool isInterfaceObject = (opc != spv::OpSampledImage);
|
||||
|
||||
if (!isInterfaceObject) {
|
||||
addDecor(builder.getIdOperand(id, 0), spv::DecorationBlockMatchTextureQCOM);
|
||||
addDecor(builder.getIdOperand(id, 1), spv::DecorationBlockMatchSamplerQCOM);
|
||||
} else {
|
||||
addDecor(id, spv::DecorationBlockMatchTextureQCOM);
|
||||
addDecor(id, spv::DecorationBlockMatchSamplerQCOM);
|
||||
}
|
||||
}
|
||||
|
||||
@ -10025,6 +10224,7 @@ spv::Id TGlslangToSpvTraverser::createShortCircuit(glslang::TOperator op, glslan
|
||||
|
||||
// Operands to accumulate OpPhi operands
|
||||
std::vector<spv::Id> phiOperands;
|
||||
phiOperands.reserve(4);
|
||||
// accumulate left operand's phi information
|
||||
phiOperands.push_back(leftId);
|
||||
phiOperands.push_back(builder.getBuildPoint()->getId());
|
||||
@ -10064,7 +10264,6 @@ spv::Id TGlslangToSpvTraverser::getExtBuiltins(const char* name)
|
||||
if (extBuiltinMap.find(name) != extBuiltinMap.end())
|
||||
return extBuiltinMap[name];
|
||||
else {
|
||||
builder.addExtension(name);
|
||||
spv::Id extBuiltins = builder.import(name);
|
||||
extBuiltinMap[name] = extBuiltins;
|
||||
return extBuiltins;
|
||||
|
401
thirdparty/glslang/SPIRV/SpvBuilder.cpp
vendored
401
thirdparty/glslang/SPIRV/SpvBuilder.cpp
vendored
File diff suppressed because it is too large
Load Diff
116
thirdparty/glslang/SPIRV/SpvBuilder.h
vendored
116
thirdparty/glslang/SPIRV/SpvBuilder.h
vendored
@ -103,31 +103,53 @@ public:
|
||||
stringIds[file_c_str] = strId;
|
||||
return strId;
|
||||
}
|
||||
spv::Id getSourceFile() const
|
||||
|
||||
spv::Id getMainFileId() const { return mainFileId; }
|
||||
|
||||
// Initialize the main source file name
|
||||
void setDebugSourceFile(const std::string& file)
|
||||
{
|
||||
return sourceFileStringId;
|
||||
if (trackDebugInfo) {
|
||||
dirtyLineTracker = true;
|
||||
mainFileId = getStringId(file);
|
||||
currentFileId = mainFileId;
|
||||
}
|
||||
}
|
||||
void setSourceFile(const std::string& file)
|
||||
|
||||
// Set the debug source location tracker in the builder.
|
||||
// The upcoming instructions in basic blocks will be associated to this location.
|
||||
void setDebugSourceLocation(int line, const char* filename)
|
||||
{
|
||||
sourceFileStringId = getStringId(file);
|
||||
currentFileId = sourceFileStringId;
|
||||
if (trackDebugInfo) {
|
||||
dirtyLineTracker = true;
|
||||
if (line != 0) {
|
||||
// TODO: This is special handling of some AST nodes having (untracked) line 0.
|
||||
// But they should have a valid line number.
|
||||
currentLine = line;
|
||||
if (filename) {
|
||||
currentFileId = getStringId(filename);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void setSourceText(const std::string& text) { sourceText = text; }
|
||||
void addSourceExtension(const char* ext) { sourceExtensions.push_back(ext); }
|
||||
void addModuleProcessed(const std::string& p) { moduleProcesses.push_back(p.c_str()); }
|
||||
void setEmitOpLines() { emitOpLines = true; }
|
||||
void setEmitNonSemanticShaderDebugInfo(bool const emit)
|
||||
void setEmitSpirvDebugInfo()
|
||||
{
|
||||
emitNonSemanticShaderDebugInfo = emit;
|
||||
|
||||
if(emit)
|
||||
{
|
||||
importNonSemanticShaderDebugInfoInstructions();
|
||||
}
|
||||
trackDebugInfo = true;
|
||||
emitSpirvDebugInfo = true;
|
||||
}
|
||||
void setEmitNonSemanticShaderDebugSource(bool const src)
|
||||
void setEmitNonSemanticShaderDebugInfo(bool emitSourceText)
|
||||
{
|
||||
emitNonSemanticShaderDebugSource = src;
|
||||
trackDebugInfo = true;
|
||||
emitNonSemanticShaderDebugInfo = true;
|
||||
importNonSemanticShaderDebugInfoInstructions();
|
||||
|
||||
if (emitSourceText) {
|
||||
emitNonSemanticShaderDebugSource = emitSourceText;
|
||||
}
|
||||
}
|
||||
void addExtension(const char* ext) { extensions.insert(ext); }
|
||||
void removeExtension(const char* ext)
|
||||
@ -169,20 +191,6 @@ public:
|
||||
return id;
|
||||
}
|
||||
|
||||
// Generate OpLine for non-filename-based #line directives (ie no filename
|
||||
// seen yet): Log the current line, and if different than the last one,
|
||||
// issue a new OpLine using the new line and current source file name.
|
||||
void setLine(int line);
|
||||
|
||||
// If filename null, generate OpLine for non-filename-based line directives,
|
||||
// else do filename-based: Log the current line and file, and if different
|
||||
// than the last one, issue a new OpLine using the new line and file
|
||||
// name.
|
||||
void setLine(int line, const char* filename);
|
||||
// Low-level OpLine. See setLine() for a layered helper.
|
||||
void addLine(Id fileName, int line, int column);
|
||||
void addDebugScopeAndLine(Id fileName, int line, int column);
|
||||
|
||||
// For creating new types (will return old type if the requested one was already made).
|
||||
Id makeVoidType();
|
||||
Id makeBoolType();
|
||||
@ -226,6 +234,7 @@ public:
|
||||
Id makeMemberDebugType(Id const memberType, DebugTypeLoc const& debugTypeLoc);
|
||||
Id makeCompositeDebugType(std::vector<Id> const& memberTypes, char const*const name,
|
||||
NonSemanticShaderDebugInfo100DebugCompositeType const tag, bool const isOpaqueType = false);
|
||||
Id makePointerDebugType(StorageClass storageClass, Id const baseType);
|
||||
Id makeDebugSource(const Id fileName);
|
||||
Id makeDebugCompilationUnit();
|
||||
Id createDebugGlobalVariable(Id const type, char const*const name, Id const variable);
|
||||
@ -317,8 +326,6 @@ public:
|
||||
// See if a resultId is valid for use as an initializer.
|
||||
bool isValidInitializer(Id resultId) const { return isConstant(resultId) || isGlobalVariable(resultId); }
|
||||
|
||||
bool isRayTracingOpCode(Op opcode) const;
|
||||
|
||||
int getScalarTypeWidth(Id typeId) const
|
||||
{
|
||||
Id scalarTypeId = getScalarTypeId(typeId);
|
||||
@ -408,11 +415,16 @@ public:
|
||||
// Also reset current last DebugScope and current source line to unknown
|
||||
void setBuildPoint(Block* bp) {
|
||||
buildPoint = bp;
|
||||
lastDebugScopeId = NoResult;
|
||||
currentLine = 0;
|
||||
// TODO: Technically, change of build point should set line tracker dirty. But we'll have bad line info for
|
||||
// branch instructions. Commenting this for now because at least this matches the old behavior.
|
||||
dirtyScopeTracker = true;
|
||||
}
|
||||
Block* getBuildPoint() const { return buildPoint; }
|
||||
|
||||
// Append an instruction to the end of the current build point.
|
||||
// Optionally, additional debug info instructions may also be prepended.
|
||||
void addInstruction(std::unique_ptr<Instruction> inst);
|
||||
|
||||
// Make the entry-point function. The returned pointer is only valid
|
||||
// for the lifetime of this builder.
|
||||
Function* makeEntryPoint(const char*);
|
||||
@ -429,10 +441,10 @@ public:
|
||||
void makeReturn(bool implicit, Id retVal = 0);
|
||||
|
||||
// Initialize state and generate instructions for new lexical scope
|
||||
void enterScope(uint32_t line);
|
||||
void enterLexicalBlock(uint32_t line);
|
||||
|
||||
// Set state and generate instructions to exit current lexical scope
|
||||
void leaveScope();
|
||||
void leaveLexicalBlock();
|
||||
|
||||
// Prepare builder for generation of instructions for a function.
|
||||
void enterFunction(Function const* function);
|
||||
@ -881,21 +893,37 @@ public:
|
||||
unsigned int spvVersion; // the version of SPIR-V to emit in the header
|
||||
SourceLanguage sourceLang;
|
||||
int sourceVersion;
|
||||
spv::Id sourceFileStringId;
|
||||
spv::Id nonSemanticShaderCompilationUnitId {0};
|
||||
spv::Id nonSemanticShaderDebugInfo {0};
|
||||
spv::Id debugInfoNone {0};
|
||||
spv::Id debugExpression {0}; // Debug expression with zero operations.
|
||||
std::string sourceText;
|
||||
int currentLine;
|
||||
const char* currentFile;
|
||||
spv::Id currentFileId;
|
||||
|
||||
// True if an new OpLine/OpDebugLine may need to be inserted. Either:
|
||||
// 1. The current debug location changed
|
||||
// 2. The current build point changed
|
||||
bool dirtyLineTracker;
|
||||
int currentLine = 0;
|
||||
// OpString id of the current file name. Always 0 if debug info is off.
|
||||
spv::Id currentFileId = 0;
|
||||
// OpString id of the main file name. Always 0 if debug info is off.
|
||||
spv::Id mainFileId = 0;
|
||||
|
||||
// True if an new OpDebugScope may need to be inserted. Either:
|
||||
// 1. A new lexical block is pushed
|
||||
// 2. The current build point changed
|
||||
bool dirtyScopeTracker;
|
||||
std::stack<spv::Id> currentDebugScopeId;
|
||||
spv::Id lastDebugScopeId;
|
||||
bool emitOpLines;
|
||||
bool emitNonSemanticShaderDebugInfo;
|
||||
bool restoreNonSemanticShaderDebugInfo;
|
||||
bool emitNonSemanticShaderDebugSource;
|
||||
|
||||
// This flag toggles tracking of debug info while building the SPIR-V.
|
||||
bool trackDebugInfo = false;
|
||||
// This flag toggles emission of SPIR-V debug instructions, like OpLine and OpSource.
|
||||
bool emitSpirvDebugInfo = false;
|
||||
// This flag toggles emission of Non-Semantic Debug extension debug instructions.
|
||||
bool emitNonSemanticShaderDebugInfo = false;
|
||||
bool restoreNonSemanticShaderDebugInfo = false;
|
||||
bool emitNonSemanticShaderDebugSource = false;
|
||||
|
||||
std::set<std::string> extensions;
|
||||
std::vector<const char*> sourceExtensions;
|
||||
std::vector<const char*> moduleProcesses;
|
||||
|
1
thirdparty/glslang/SPIRV/SpvPostProcess.cpp
vendored
1
thirdparty/glslang/SPIRV/SpvPostProcess.cpp
vendored
@ -181,6 +181,7 @@ void Builder::postProcessType(const Instruction& inst, Id typeId)
|
||||
else if (width == 8)
|
||||
addCapability(CapabilityInt8);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if (basicTypeOp == OpTypeInt) {
|
||||
if (width == 16)
|
||||
|
9
thirdparty/glslang/SPIRV/disassemble.cpp
vendored
9
thirdparty/glslang/SPIRV/disassemble.cpp
vendored
@ -80,6 +80,7 @@ enum ExtInstSet {
|
||||
GLSLextNVInst,
|
||||
OpenCLExtInst,
|
||||
NonSemanticDebugPrintfExtInst,
|
||||
NonSemanticDebugBreakExtInst,
|
||||
NonSemanticShaderDebugInfo100
|
||||
};
|
||||
|
||||
@ -360,7 +361,7 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
|
||||
switch (stream[word]) {
|
||||
case 8: idDescriptor[resultId] = "int8_t"; break;
|
||||
case 16: idDescriptor[resultId] = "int16_t"; break;
|
||||
default: assert(0); // fallthrough
|
||||
default: assert(0); [[fallthrough]];
|
||||
case 32: idDescriptor[resultId] = "int"; break;
|
||||
case 64: idDescriptor[resultId] = "int64_t"; break;
|
||||
}
|
||||
@ -368,7 +369,7 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
|
||||
case OpTypeFloat:
|
||||
switch (stream[word]) {
|
||||
case 16: idDescriptor[resultId] = "float16_t"; break;
|
||||
default: assert(0); // fallthrough
|
||||
default: assert(0); [[fallthrough]];
|
||||
case 32: idDescriptor[resultId] = "float"; break;
|
||||
case 64: idDescriptor[resultId] = "float64_t"; break;
|
||||
}
|
||||
@ -506,6 +507,8 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
|
||||
extInstSet = OpenCLExtInst;
|
||||
} else if (strcmp("NonSemantic.DebugPrintf", name) == 0) {
|
||||
extInstSet = NonSemanticDebugPrintfExtInst;
|
||||
} else if (strcmp("NonSemantic.DebugBreak", name) == 0) {
|
||||
extInstSet = NonSemanticDebugBreakExtInst;
|
||||
} else if (strcmp("NonSemantic.Shader.DebugInfo.100", name) == 0) {
|
||||
extInstSet = NonSemanticShaderDebugInfo100;
|
||||
} else if (strcmp(spv::E_SPV_AMD_shader_ballot, name) == 0 ||
|
||||
@ -533,6 +536,8 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
|
||||
out << "(" << GLSLextNVGetDebugNames(name, entrypoint) << ")";
|
||||
} else if (extInstSet == NonSemanticDebugPrintfExtInst) {
|
||||
out << "(DebugPrintf)";
|
||||
} else if (extInstSet == NonSemanticDebugBreakExtInst) {
|
||||
out << "(DebugBreak)";
|
||||
} else if (extInstSet == NonSemanticShaderDebugInfo100) {
|
||||
out << "(" << NonSemanticShaderDebugInfo100GetDebugNames(entrypoint) << ")";
|
||||
}
|
||||
|
70
thirdparty/glslang/SPIRV/doc.cpp
vendored
70
thirdparty/glslang/SPIRV/doc.cpp
vendored
@ -1,5 +1,6 @@
|
||||
//
|
||||
// Copyright (C) 2014-2015 LunarG, Inc.
|
||||
// Copyright (C) 2022-2024 Arm Limited.
|
||||
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
// All rights reserved.
|
||||
@ -198,6 +199,7 @@ const char* ExecutionModeString(int mode)
|
||||
case ExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD";
|
||||
case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT";
|
||||
case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlow";
|
||||
case ExecutionModeMaximallyReconvergesKHR: return "MaximallyReconverges";
|
||||
|
||||
case ExecutionModeOutputLinesNV: return "OutputLinesNV";
|
||||
case ExecutionModeOutputPrimitivesNV: return "OutputPrimitivesNV";
|
||||
@ -217,6 +219,9 @@ const char* ExecutionModeString(int mode)
|
||||
case ExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL";
|
||||
case ExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL";
|
||||
|
||||
case ExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR";
|
||||
case ExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR";
|
||||
|
||||
case ExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT";
|
||||
case ExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT";
|
||||
case ExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT";
|
||||
@ -314,6 +319,7 @@ const char* DecorationString(int decoration)
|
||||
|
||||
case DecorationWeightTextureQCOM: return "DecorationWeightTextureQCOM";
|
||||
case DecorationBlockMatchTextureQCOM: return "DecorationBlockMatchTextureQCOM";
|
||||
case DecorationBlockMatchSamplerQCOM: return "DecorationBlockMatchSamplerQCOM";
|
||||
case DecorationExplicitInterpAMD: return "ExplicitInterpAMD";
|
||||
case DecorationOverrideCoverageNV: return "OverrideCoverageNV";
|
||||
case DecorationPassthroughNV: return "PassthroughNV";
|
||||
@ -938,6 +944,7 @@ const char* CapabilityString(int info)
|
||||
case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR";
|
||||
case CapabilityDrawParameters: return "DrawParameters";
|
||||
case CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR";
|
||||
case CapabilityGroupNonUniformRotateKHR: return "CapabilityGroupNonUniformRotateKHR";
|
||||
|
||||
case CapabilityStorageUniformBufferBlock16: return "StorageUniformBufferBlock16";
|
||||
case CapabilityStorageUniform16: return "StorageUniform16";
|
||||
@ -1031,11 +1038,15 @@ const char* CapabilityString(int info)
|
||||
case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR";
|
||||
|
||||
case CapabilityDemoteToHelperInvocationEXT: return "DemoteToHelperInvocationEXT";
|
||||
case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV";
|
||||
case CapabilityShaderClockKHR: return "ShaderClockKHR";
|
||||
case CapabilityQuadControlKHR: return "QuadControlKHR";
|
||||
case CapabilityInt64ImageEXT: return "Int64ImageEXT";
|
||||
|
||||
case CapabilityIntegerFunctions2INTEL: return "CapabilityIntegerFunctions2INTEL";
|
||||
|
||||
case CapabilityExpectAssumeKHR: return "ExpectAssumeKHR";
|
||||
|
||||
case CapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT";
|
||||
case CapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT";
|
||||
case CapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT";
|
||||
@ -1053,6 +1064,7 @@ const char* CapabilityString(int info)
|
||||
case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM";
|
||||
case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM";
|
||||
case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM";
|
||||
case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM";
|
||||
|
||||
default: return "Bad";
|
||||
}
|
||||
@ -1432,10 +1444,16 @@ const char* OpcodeString(int op)
|
||||
case 4430: return "OpSubgroupAllEqualKHR";
|
||||
case 4432: return "OpSubgroupReadInvocationKHR";
|
||||
|
||||
case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
|
||||
case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
|
||||
|
||||
case OpAtomicFAddEXT: return "OpAtomicFAddEXT";
|
||||
case OpAtomicFMinEXT: return "OpAtomicFMinEXT";
|
||||
case OpAtomicFMaxEXT: return "OpAtomicFMaxEXT";
|
||||
|
||||
case OpAssumeTrueKHR: return "OpAssumeTrueKHR";
|
||||
case OpExpectKHR: return "OpExpectKHR";
|
||||
|
||||
case 5000: return "OpGroupIAddNonUniformAMD";
|
||||
case 5001: return "OpGroupFAddNonUniformAMD";
|
||||
case 5002: return "OpGroupFMinNonUniformAMD";
|
||||
@ -1472,6 +1490,8 @@ const char* OpcodeString(int op)
|
||||
case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT";
|
||||
case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT";
|
||||
|
||||
case OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR";
|
||||
|
||||
case OpTypeRayQueryKHR: return "OpTypeRayQueryKHR";
|
||||
case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR";
|
||||
case OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR";
|
||||
@ -1559,6 +1579,10 @@ const char* OpcodeString(int op)
|
||||
case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM";
|
||||
case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM";
|
||||
case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM";
|
||||
case OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM";
|
||||
case OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM";
|
||||
case OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM";
|
||||
case OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM";
|
||||
|
||||
default:
|
||||
return "Bad";
|
||||
@ -1678,7 +1702,7 @@ void Parameterize()
|
||||
InstructionDesc[OpCooperativeMatrixStoreKHR].setResultAndType(false, false);
|
||||
InstructionDesc[OpBeginInvocationInterlockEXT].setResultAndType(false, false);
|
||||
InstructionDesc[OpEndInvocationInterlockEXT].setResultAndType(false, false);
|
||||
|
||||
InstructionDesc[OpAssumeTrueKHR].setResultAndType(false, false);
|
||||
// Specific additional context-dependent operands
|
||||
|
||||
ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'");
|
||||
@ -2457,6 +2481,11 @@ void Parameterize()
|
||||
InstructionDesc[OpAtomicFAddEXT].operands.push(OperandMemorySemantics, "'Semantics'");
|
||||
InstructionDesc[OpAtomicFAddEXT].operands.push(OperandId, "'Value'");
|
||||
|
||||
InstructionDesc[OpAssumeTrueKHR].operands.push(OperandId, "'Condition'");
|
||||
|
||||
InstructionDesc[OpExpectKHR].operands.push(OperandId, "'Value'");
|
||||
InstructionDesc[OpExpectKHR].operands.push(OperandId, "'ExpectedValue'");
|
||||
|
||||
InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Pointer'");
|
||||
InstructionDesc[OpAtomicISub].operands.push(OperandScope, "'Scope'");
|
||||
InstructionDesc[OpAtomicISub].operands.push(OperandMemorySemantics, "'Semantics'");
|
||||
@ -2885,6 +2914,11 @@ void Parameterize()
|
||||
InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandScope, "'Execution'");
|
||||
InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandId, "'Predicate'");
|
||||
|
||||
InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandScope, "'Execution'");
|
||||
InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandId, "'X'");
|
||||
InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandId, "'Delta'");
|
||||
InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandId, "'ClusterSize'", true);
|
||||
|
||||
InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Value'");
|
||||
InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Index'");
|
||||
|
||||
@ -2931,6 +2965,8 @@ void Parameterize()
|
||||
|
||||
InstructionDesc[OpGroupNonUniformPartitionNV].operands.push(OperandId, "X");
|
||||
|
||||
InstructionDesc[OpGroupNonUniformQuadAllKHR].operands.push(OperandId, "'Predicate'");
|
||||
InstructionDesc[OpGroupNonUniformQuadAnyKHR].operands.push(OperandId, "'Predicate'");
|
||||
InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
|
||||
|
||||
InstructionDesc[OpTraceNV].operands.push(OperandId, "'Acceleration Structure'");
|
||||
@ -3403,6 +3439,38 @@ void Parameterize()
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'block size'");
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandImageOperands, "", true);
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'target texture'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'target coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'reference texture'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'reference coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'block size'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandImageOperands, "", true);
|
||||
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'target texture'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'target coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'reference texture'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'reference coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'block size'");
|
||||
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandImageOperands, "", true);
|
||||
InstructionDesc[OpImageBlockMatchWindowSADQCOM].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'target texture'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'target coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'reference texture'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'reference coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'block size'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandImageOperands, "", true);
|
||||
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'target texture'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'target coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'reference texture'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'reference coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'block size'");
|
||||
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandImageOperands, "", true);
|
||||
InstructionDesc[OpImageBlockMatchGatherSADQCOM].setResultAndType(true, true);
|
||||
});
|
||||
}
|
||||
|
||||
|
27
thirdparty/glslang/SPIRV/spirv.hpp
vendored
27
thirdparty/glslang/SPIRV/spirv.hpp
vendored
@ -1,4 +1,4 @@
|
||||
// Copyright (c) 2014-2020 The Khronos Group Inc.
|
||||
// Copyright (c) 2014-2024 The Khronos Group Inc.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and/or associated documentation files (the "Materials"),
|
||||
@ -174,6 +174,8 @@ enum ExecutionMode {
|
||||
ExecutionModeStencilRefUnchangedBackAMD = 5082,
|
||||
ExecutionModeStencilRefGreaterBackAMD = 5083,
|
||||
ExecutionModeStencilRefLessBackAMD = 5084,
|
||||
ExecutionModeQuadDerivativesKHR = 5088,
|
||||
ExecutionModeRequireFullQuadsKHR = 5089,
|
||||
ExecutionModeOutputLinesEXT = 5269,
|
||||
ExecutionModeOutputLinesNV = 5269,
|
||||
ExecutionModeOutputPrimitivesEXT = 5270,
|
||||
@ -198,6 +200,7 @@ enum ExecutionMode {
|
||||
ExecutionModeNoGlobalOffsetINTEL = 5895,
|
||||
ExecutionModeNumSIMDWorkitemsINTEL = 5896,
|
||||
ExecutionModeSchedulerTargetFmaxMhzINTEL = 5903,
|
||||
ExecutionModeMaximallyReconvergesKHR = 6023,
|
||||
ExecutionModeStreamingInterfaceINTEL = 6154,
|
||||
ExecutionModeNamedBarrierCountINTEL = 6417,
|
||||
ExecutionModeMax = 0x7fffffff,
|
||||
@ -515,6 +518,7 @@ enum Decoration {
|
||||
DecorationNoUnsignedWrap = 4470,
|
||||
DecorationWeightTextureQCOM = 4487,
|
||||
DecorationBlockMatchTextureQCOM = 4488,
|
||||
DecorationBlockMatchSamplerQCOM = 4499,
|
||||
DecorationExplicitInterpAMD = 4999,
|
||||
DecorationOverrideCoverageNV = 5248,
|
||||
DecorationPassthroughNV = 5250,
|
||||
@ -722,8 +726,6 @@ enum BuiltIn {
|
||||
BuiltInHitTriangleVertexPositionsKHR = 5335,
|
||||
BuiltInHitMicroTriangleVertexPositionsNV = 5337,
|
||||
BuiltInHitMicroTriangleVertexBarycentricsNV = 5344,
|
||||
BuiltInHitKindFrontFacingMicroTriangleNV = 5405,
|
||||
BuiltInHitKindBackFacingMicroTriangleNV = 5406,
|
||||
BuiltInIncomingRayFlagsKHR = 5351,
|
||||
BuiltInIncomingRayFlagsNV = 5351,
|
||||
BuiltInRayGeometryIndexKHR = 5352,
|
||||
@ -731,6 +733,8 @@ enum BuiltIn {
|
||||
BuiltInSMCountNV = 5375,
|
||||
BuiltInWarpIDNV = 5376,
|
||||
BuiltInSMIDNV = 5377,
|
||||
BuiltInHitKindFrontFacingMicroTriangleNV = 5405,
|
||||
BuiltInHitKindBackFacingMicroTriangleNV = 5406,
|
||||
BuiltInCullMaskKHR = 6021,
|
||||
BuiltInMax = 0x7fffffff,
|
||||
};
|
||||
@ -1032,6 +1036,7 @@ enum Capability {
|
||||
CapabilityTextureSampleWeightedQCOM = 4484,
|
||||
CapabilityTextureBoxFilterQCOM = 4485,
|
||||
CapabilityTextureBlockMatchQCOM = 4486,
|
||||
CapabilityTextureBlockMatch2QCOM = 4498,
|
||||
CapabilityFloat16ImageAMD = 5008,
|
||||
CapabilityImageGatherBiasLodAMD = 5009,
|
||||
CapabilityFragmentMaskAMD = 5010,
|
||||
@ -1039,6 +1044,7 @@ enum Capability {
|
||||
CapabilityImageReadWriteLodAMD = 5015,
|
||||
CapabilityInt64ImageEXT = 5016,
|
||||
CapabilityShaderClockKHR = 5055,
|
||||
CapabilityQuadControlKHR = 5087,
|
||||
CapabilitySampleMaskOverrideCoverageNV = 5249,
|
||||
CapabilityGeometryShaderPassthroughNV = 5251,
|
||||
CapabilityShaderViewportIndexLayerEXT = 5254,
|
||||
@ -1099,11 +1105,12 @@ enum Capability {
|
||||
CapabilityDemoteToHelperInvocation = 5379,
|
||||
CapabilityDemoteToHelperInvocationEXT = 5379,
|
||||
CapabilityDisplacementMicromapNV = 5380,
|
||||
CapabilityRayTracingDisplacementMicromapNV = 5409,
|
||||
CapabilityRayTracingOpacityMicromapEXT = 5381,
|
||||
CapabilityShaderInvocationReorderNV = 5383,
|
||||
CapabilityBindlessTextureNV = 5390,
|
||||
CapabilityRayQueryPositionFetchKHR = 5391,
|
||||
CapabilityAtomicFloat16VectorNV = 5404,
|
||||
CapabilityRayTracingDisplacementMicromapNV = 5409,
|
||||
CapabilitySubgroupShuffleINTEL = 5568,
|
||||
CapabilitySubgroupBufferBlockIOINTEL = 5569,
|
||||
CapabilitySubgroupImageBlockIOINTEL = 5570,
|
||||
@ -1693,6 +1700,10 @@ enum Op {
|
||||
OpImageBoxFilterQCOM = 4481,
|
||||
OpImageBlockMatchSSDQCOM = 4482,
|
||||
OpImageBlockMatchSADQCOM = 4483,
|
||||
OpImageBlockMatchWindowSSDQCOM = 4500,
|
||||
OpImageBlockMatchWindowSADQCOM = 4501,
|
||||
OpImageBlockMatchGatherSSDQCOM = 4502,
|
||||
OpImageBlockMatchGatherSADQCOM = 4503,
|
||||
OpGroupIAddNonUniformAMD = 5000,
|
||||
OpGroupFAddNonUniformAMD = 5001,
|
||||
OpGroupFMinNonUniformAMD = 5002,
|
||||
@ -1704,6 +1715,8 @@ enum Op {
|
||||
OpFragmentMaskFetchAMD = 5011,
|
||||
OpFragmentFetchAMD = 5012,
|
||||
OpReadClockKHR = 5056,
|
||||
OpGroupNonUniformQuadAllKHR = 5110,
|
||||
OpGroupNonUniformQuadAnyKHR = 5111,
|
||||
OpHitObjectRecordHitMotionNV = 5249,
|
||||
OpHitObjectRecordHitWithIndexMotionNV = 5250,
|
||||
OpHitObjectRecordMissMotionNV = 5251,
|
||||
@ -2416,6 +2429,10 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
|
||||
case OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageBlockMatchWindowSSDQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageBlockMatchWindowSADQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageBlockMatchGatherSSDQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageBlockMatchGatherSADQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
|
||||
case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
|
||||
case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
|
||||
@ -2427,6 +2444,8 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
|
||||
case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
|
||||
case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
|
||||
case OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpGroupNonUniformQuadAllKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpGroupNonUniformQuadAnyKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break;
|
||||
case OpHitObjectRecordHitWithIndexMotionNV: *hasResult = false; *hasResultType = false; break;
|
||||
case OpHitObjectRecordMissMotionNV: *hasResult = false; *hasResultType = false; break;
|
||||
|
41
thirdparty/glslang/SPIRV/spvIR.h
vendored
41
thirdparty/glslang/SPIRV/spvIR.h
vendored
@ -56,6 +56,7 @@
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <optional>
|
||||
|
||||
namespace spv {
|
||||
|
||||
@ -96,6 +97,10 @@ public:
|
||||
Instruction(Id resultId, Id typeId, Op opCode) : resultId(resultId), typeId(typeId), opCode(opCode), block(nullptr) { }
|
||||
explicit Instruction(Op opCode) : resultId(NoResult), typeId(NoType), opCode(opCode), block(nullptr) { }
|
||||
virtual ~Instruction() {}
|
||||
void reserveOperands(size_t count) {
|
||||
operands.reserve(count);
|
||||
idOperand.reserve(count);
|
||||
}
|
||||
void addIdOperand(Id id) {
|
||||
// ids can't be 0
|
||||
assert(id);
|
||||
@ -190,6 +195,12 @@ protected:
|
||||
// SPIR-V IR block.
|
||||
//
|
||||
|
||||
struct DebugSourceLocation {
|
||||
int line;
|
||||
int column;
|
||||
spv::Id fileId;
|
||||
};
|
||||
|
||||
class Block {
|
||||
public:
|
||||
Block(Id id, Function& parent);
|
||||
@ -200,6 +211,28 @@ public:
|
||||
Id getId() { return instructions.front()->getResultId(); }
|
||||
|
||||
Function& getParent() const { return parent; }
|
||||
// Returns true if the source location is actually updated.
|
||||
// Note we still need the builder to insert the line marker instruction. This is just a tracker.
|
||||
bool updateDebugSourceLocation(int line, int column, spv::Id fileId) {
|
||||
if (currentSourceLoc && currentSourceLoc->line == line && currentSourceLoc->column == column &&
|
||||
currentSourceLoc->fileId == fileId) {
|
||||
return false;
|
||||
}
|
||||
|
||||
currentSourceLoc = DebugSourceLocation{line, column, fileId};
|
||||
return true;
|
||||
}
|
||||
// Returns true if the scope is actually updated.
|
||||
// Note we still need the builder to insert the debug scope instruction. This is just a tracker.
|
||||
bool updateDebugScope(spv::Id scopeId) {
|
||||
assert(scopeId);
|
||||
if (currentDebugScope && *currentDebugScope == scopeId) {
|
||||
return false;
|
||||
}
|
||||
|
||||
currentDebugScope = scopeId;
|
||||
return true;
|
||||
}
|
||||
void addInstruction(std::unique_ptr<Instruction> inst);
|
||||
void addPredecessor(Block* pred) { predecessors.push_back(pred); pred->successors.push_back(this);}
|
||||
void addLocalVariable(std::unique_ptr<Instruction> inst) { localVariables.push_back(std::move(inst)); }
|
||||
@ -292,6 +325,12 @@ protected:
|
||||
std::vector<std::unique_ptr<Instruction> > localVariables;
|
||||
Function& parent;
|
||||
|
||||
// Track source location of the last source location marker instruction.
|
||||
std::optional<DebugSourceLocation> currentSourceLoc;
|
||||
|
||||
// Track scope of the last debug scope instruction.
|
||||
std::optional<spv::Id> currentDebugScope;
|
||||
|
||||
// track whether this block is known to be uncreachable (not necessarily
|
||||
// true for all unreachable blocks, but should be set at least
|
||||
// for the extraneous ones introduced by the builder).
|
||||
@ -363,6 +402,7 @@ public:
|
||||
|
||||
void setDebugLineInfo(Id fileName, int line, int column) {
|
||||
lineInstruction = std::unique_ptr<Instruction>{new Instruction(OpLine)};
|
||||
lineInstruction->reserveOperands(3);
|
||||
lineInstruction->addIdOperand(fileName);
|
||||
lineInstruction->addImmediateOperand(line);
|
||||
lineInstruction->addImmediateOperand(column);
|
||||
@ -486,6 +526,7 @@ __inline Function::Function(Id id, Id resultType, Id functionType, Id firstParam
|
||||
linkType(linkage)
|
||||
{
|
||||
// OpFunction
|
||||
functionInstruction.reserveOperands(2);
|
||||
functionInstruction.addImmediateOperand(FunctionControlMaskNone);
|
||||
functionInstruction.addIdOperand(functionType);
|
||||
parent.mapInstruction(&functionInstruction);
|
||||
|
5
thirdparty/glslang/glslang/Include/Common.h
vendored
5
thirdparty/glslang/glslang/Include/Common.h
vendored
@ -159,6 +159,11 @@ template<class T> inline T* NewPoolObject(T, int instances)
|
||||
return new(GetThreadPoolAllocator().allocate(instances * sizeof(T))) T[instances];
|
||||
}
|
||||
|
||||
inline bool StartsWith(TString const &str, const char *prefix)
|
||||
{
|
||||
return str.compare(0, strlen(prefix), prefix) == 0;
|
||||
}
|
||||
|
||||
//
|
||||
// Pool allocator versions of vectors, lists, and maps
|
||||
//
|
||||
|
24
thirdparty/glslang/glslang/Include/InfoSink.h
vendored
24
thirdparty/glslang/glslang/Include/InfoSink.h
vendored
@ -36,6 +36,7 @@
|
||||
#define _INFOSINK_INCLUDED_
|
||||
|
||||
#include "../Include/Common.h"
|
||||
#include <filesystem>
|
||||
#include <cmath>
|
||||
|
||||
namespace glslang {
|
||||
@ -67,7 +68,7 @@ enum TOutputStream {
|
||||
//
|
||||
class TInfoSinkBase {
|
||||
public:
|
||||
TInfoSinkBase() : outputStream(4) {}
|
||||
TInfoSinkBase() : outputStream(4), shaderFileName(nullptr) {}
|
||||
void erase() { sink.erase(); }
|
||||
TInfoSinkBase& operator<<(const TPersistString& t) { append(t); return *this; }
|
||||
TInfoSinkBase& operator<<(char c) { append(1, c); return *this; }
|
||||
@ -94,11 +95,22 @@ public:
|
||||
default: append("UNKNOWN ERROR: "); break;
|
||||
}
|
||||
}
|
||||
void location(const TSourceLoc& loc) {
|
||||
void location(const TSourceLoc& loc, bool absolute = false) {
|
||||
const int maxSize = 24;
|
||||
char locText[maxSize];
|
||||
snprintf(locText, maxSize, ":%d", loc.line);
|
||||
append(loc.getStringNameOrNum(false).c_str());
|
||||
|
||||
if(loc.getFilename() == nullptr && shaderFileName != nullptr && absolute) {
|
||||
//append(std::filesystem::absolute(shaderFileName).string());
|
||||
} else {
|
||||
std::string location = loc.getStringNameOrNum(false);
|
||||
//if (absolute) {
|
||||
// append(std::filesystem::absolute(location).string());
|
||||
//} else {
|
||||
append(location);
|
||||
//}
|
||||
}
|
||||
|
||||
append(locText);
|
||||
append(": ");
|
||||
}
|
||||
@ -119,6 +131,11 @@ public:
|
||||
outputStream = output;
|
||||
}
|
||||
|
||||
void setShaderFileName(const char* file = nullptr)
|
||||
{
|
||||
shaderFileName = file;
|
||||
}
|
||||
|
||||
protected:
|
||||
void append(const char* s);
|
||||
|
||||
@ -131,6 +148,7 @@ protected:
|
||||
void appendToStream(const char* s);
|
||||
TPersistString sink;
|
||||
int outputStream;
|
||||
const char* shaderFileName;
|
||||
};
|
||||
|
||||
} // end namespace glslang
|
||||
|
39
thirdparty/glslang/glslang/Include/Types.h
vendored
39
thirdparty/glslang/glslang/Include/Types.h
vendored
@ -573,7 +573,8 @@ public:
|
||||
}
|
||||
|
||||
const char* semanticName;
|
||||
TStorageQualifier storage : 6;
|
||||
TStorageQualifier storage : 7;
|
||||
static_assert(EvqLast < 64, "need to increase size of TStorageQualifier bitfields!");
|
||||
TBuiltInVariable builtIn : 9;
|
||||
TBuiltInVariable declaredBuiltIn : 9;
|
||||
static_assert(EbvLast < 256, "need to increase size of TBuiltInVariable bitfields!");
|
||||
@ -852,6 +853,8 @@ public:
|
||||
// -2048 as the default value indicating layoutSecondaryViewportRelative is not set
|
||||
layoutSecondaryViewportRelativeOffset = -2048;
|
||||
layoutShaderRecord = false;
|
||||
layoutFullQuads = false;
|
||||
layoutQuadDeriv = false;
|
||||
layoutHitObjectShaderRecordNV = false;
|
||||
layoutBindlessSampler = false;
|
||||
layoutBindlessImage = false;
|
||||
@ -948,6 +951,8 @@ public:
|
||||
bool layoutViewportRelative;
|
||||
int layoutSecondaryViewportRelativeOffset;
|
||||
bool layoutShaderRecord;
|
||||
bool layoutFullQuads;
|
||||
bool layoutQuadDeriv;
|
||||
bool layoutHitObjectShaderRecordNV;
|
||||
|
||||
// GL_EXT_spirv_intrinsics
|
||||
@ -1055,6 +1060,8 @@ public:
|
||||
TLayoutFormat getFormat() const { return layoutFormat; }
|
||||
bool isPushConstant() const { return layoutPushConstant; }
|
||||
bool isShaderRecord() const { return layoutShaderRecord; }
|
||||
bool isFullQuads() const { return layoutFullQuads; }
|
||||
bool isQuadDeriv() const { return layoutQuadDeriv; }
|
||||
bool hasHitObjectShaderRecordNV() const { return layoutHitObjectShaderRecordNV; }
|
||||
bool hasBufferReference() const { return layoutBufferReference; }
|
||||
bool hasBufferReferenceAlign() const
|
||||
@ -1428,13 +1435,25 @@ class TTypeParameters {
|
||||
public:
|
||||
POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
|
||||
|
||||
TTypeParameters() : basicType(EbtVoid), arraySizes(nullptr) {}
|
||||
TTypeParameters() : basicType(EbtVoid), arraySizes(nullptr), spirvType(nullptr) {}
|
||||
|
||||
TBasicType basicType;
|
||||
TArraySizes *arraySizes;
|
||||
TSpirvType *spirvType;
|
||||
|
||||
bool operator==(const TTypeParameters& rhs) const { return basicType == rhs.basicType && *arraySizes == *rhs.arraySizes; }
|
||||
bool operator!=(const TTypeParameters& rhs) const { return basicType != rhs.basicType || *arraySizes != *rhs.arraySizes; }
|
||||
bool operator==(const TTypeParameters& rhs) const
|
||||
{
|
||||
bool same = basicType == rhs.basicType && *arraySizes == *rhs.arraySizes;
|
||||
if (same && basicType == EbtSpirvType) {
|
||||
assert(spirvType && rhs.spirvType);
|
||||
return *spirvType == *rhs.spirvType;
|
||||
}
|
||||
return same;
|
||||
}
|
||||
bool operator!=(const TTypeParameters& rhs) const
|
||||
{
|
||||
return !(*this == rhs);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
@ -1611,6 +1630,10 @@ public:
|
||||
}
|
||||
if (p.isCoopmatKHR() && p.typeParameters && p.typeParameters->arraySizes->getNumDims() > 0) {
|
||||
basicType = p.typeParameters->basicType;
|
||||
if (isSpirvType()) {
|
||||
assert(p.typeParameters->spirvType);
|
||||
spirvType = p.typeParameters->spirvType;
|
||||
}
|
||||
|
||||
if (p.typeParameters->arraySizes->getNumDims() == 4) {
|
||||
const int dimSize = p.typeParameters->arraySizes->getDimSize(3);
|
||||
@ -2206,6 +2229,10 @@ public:
|
||||
|
||||
if (qualifier.layoutShaderRecord)
|
||||
appendStr(" shaderRecordNV");
|
||||
if (qualifier.layoutFullQuads)
|
||||
appendStr(" full_quads");
|
||||
if (qualifier.layoutQuadDeriv)
|
||||
appendStr(" quad_derivatives");
|
||||
if (qualifier.layoutHitObjectShaderRecordNV)
|
||||
appendStr(" hitobjectshaderrecordnv");
|
||||
|
||||
@ -2708,7 +2735,8 @@ public:
|
||||
if (isCoopMatKHR() && right.isCoopMatKHR()) {
|
||||
return ((getBasicType() == right.getBasicType()) || (getBasicType() == EbtCoopmat) ||
|
||||
(right.getBasicType() == EbtCoopmat)) &&
|
||||
typeParameters == nullptr && right.typeParameters != nullptr;
|
||||
((typeParameters == nullptr && right.typeParameters != nullptr) ||
|
||||
(typeParameters != nullptr && right.typeParameters == nullptr));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@ -2814,6 +2842,7 @@ protected:
|
||||
typeParameters = new TTypeParameters;
|
||||
typeParameters->arraySizes = new TArraySizes;
|
||||
*typeParameters->arraySizes = *copyOf.typeParameters->arraySizes;
|
||||
*typeParameters->spirvType = *copyOf.typeParameters->spirvType;
|
||||
typeParameters->basicType = copyOf.basicType;
|
||||
}
|
||||
|
||||
|
@ -1,7 +1,7 @@
|
||||
//
|
||||
// Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
||||
// Copyright (C) 2012-2016 LunarG, Inc.
|
||||
// Copyright (C) 2017 ARM Limited.
|
||||
// Copyright (C) 2017, 2022-2024 Arm Limited.
|
||||
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
// All rights reserved.
|
||||
@ -506,6 +506,8 @@ enum TOperator {
|
||||
EOpSubgroupShuffleXor,
|
||||
EOpSubgroupShuffleUp,
|
||||
EOpSubgroupShuffleDown,
|
||||
EOpSubgroupRotate,
|
||||
EOpSubgroupClusteredRotate,
|
||||
EOpSubgroupAdd,
|
||||
EOpSubgroupMul,
|
||||
EOpSubgroupMin,
|
||||
@ -538,6 +540,8 @@ enum TOperator {
|
||||
EOpSubgroupQuadSwapHorizontal,
|
||||
EOpSubgroupQuadSwapVertical,
|
||||
EOpSubgroupQuadSwapDiagonal,
|
||||
EOpSubgroupQuadAll,
|
||||
EOpSubgroupQuadAny,
|
||||
|
||||
EOpSubgroupPartition,
|
||||
EOpSubgroupPartitionedAdd,
|
||||
@ -1087,6 +1091,10 @@ enum TOperator {
|
||||
EOpWaveActiveCountBits, // Will decompose to subgroupBallotBitCount(subgroupBallot()).
|
||||
EOpWavePrefixCountBits, // Will decompose to subgroupBallotInclusiveBitCount(subgroupBallot()).
|
||||
|
||||
// GL_EXT_expect_assume
|
||||
EOpAssumeEXT,
|
||||
EOpExpectEXT,
|
||||
|
||||
// Shader Clock Ops
|
||||
EOpReadClockSubgroupKHR,
|
||||
EOpReadClockDeviceKHR,
|
||||
@ -1103,6 +1111,12 @@ enum TOperator {
|
||||
EOpImageBoxFilterQCOM,
|
||||
EOpImageBlockMatchSADQCOM,
|
||||
EOpImageBlockMatchSSDQCOM,
|
||||
|
||||
// Image processing2
|
||||
EOpImageBlockMatchWindowSSDQCOM,
|
||||
EOpImageBlockMatchWindowSADQCOM,
|
||||
EOpImageBlockMatchGatherSSDQCOM,
|
||||
EOpImageBlockMatchGatherSADQCOM,
|
||||
};
|
||||
|
||||
enum TLinkType {
|
||||
|
@ -2,7 +2,7 @@
|
||||
// Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
||||
// Copyright (C) 2012-2016 LunarG, Inc.
|
||||
// Copyright (C) 2015-2020 Google, Inc.
|
||||
// Copyright (C) 2017 ARM Limited.
|
||||
// Copyright (C) 2017, 2022-2024 Arm Limited.
|
||||
// Modifications Copyright (C) 2020-2021 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
// All rights reserved.
|
||||
@ -51,7 +51,9 @@
|
||||
// including identifying what extensions are needed if a version does not allow a symbol
|
||||
//
|
||||
|
||||
#include <array>
|
||||
#include "Initialize.h"
|
||||
#include "span.h"
|
||||
|
||||
namespace glslang {
|
||||
|
||||
@ -139,20 +141,17 @@ struct Versioning {
|
||||
EProfile EDesktopProfile = static_cast<EProfile>(ENoProfile | ECoreProfile | ECompatibilityProfile);
|
||||
|
||||
// Declare pointers to put into the table for versioning.
|
||||
const Versioning Es300Desktop130Version[] = { { EEsProfile, 0, 300, 0, nullptr },
|
||||
{ EDesktopProfile, 0, 130, 0, nullptr },
|
||||
{ EBadProfile } };
|
||||
const Versioning* Es300Desktop130 = &Es300Desktop130Version[0];
|
||||
const std::array Es300Desktop130Version = { Versioning{ EEsProfile, 0, 300, 0, nullptr },
|
||||
Versioning{ EDesktopProfile, 0, 130, 0, nullptr },
|
||||
};
|
||||
|
||||
const Versioning Es310Desktop400Version[] = { { EEsProfile, 0, 310, 0, nullptr },
|
||||
{ EDesktopProfile, 0, 400, 0, nullptr },
|
||||
{ EBadProfile } };
|
||||
const Versioning* Es310Desktop400 = &Es310Desktop400Version[0];
|
||||
const std::array Es310Desktop400Version = { Versioning{ EEsProfile, 0, 310, 0, nullptr },
|
||||
Versioning{ EDesktopProfile, 0, 400, 0, nullptr },
|
||||
};
|
||||
|
||||
const Versioning Es310Desktop450Version[] = { { EEsProfile, 0, 310, 0, nullptr },
|
||||
{ EDesktopProfile, 0, 450, 0, nullptr },
|
||||
{ EBadProfile } };
|
||||
const Versioning* Es310Desktop450 = &Es310Desktop450Version[0];
|
||||
const std::array Es310Desktop450Version = { Versioning{ EEsProfile, 0, 310, 0, nullptr },
|
||||
Versioning{ EDesktopProfile, 0, 450, 0, nullptr },
|
||||
};
|
||||
|
||||
// The main descriptor of what a set of function prototypes can look like, and
|
||||
// a pointer to extra versioning information, when needed.
|
||||
@ -162,7 +161,7 @@ struct BuiltInFunction {
|
||||
int numArguments; // number of arguments (overloads with varying arguments need different entries)
|
||||
ArgType types; // ArgType mask
|
||||
ArgClass classes; // the ways this particular function entry manifests
|
||||
const Versioning* versioning; // nullptr means always a valid version
|
||||
const span<const Versioning> versioning; // An empty span means always a valid version
|
||||
};
|
||||
|
||||
// The tables can have the same built-in function name more than one time,
|
||||
@ -174,151 +173,146 @@ struct BuiltInFunction {
|
||||
//
|
||||
// Table is terminated by an OpNull TOperator.
|
||||
|
||||
const BuiltInFunction BaseFunctions[] = {
|
||||
const std::array BaseFunctions = {
|
||||
// TOperator, name, arg-count, ArgType, ArgClass, versioning
|
||||
// --------- ---- --------- ------- -------- ----------
|
||||
{ EOpRadians, "radians", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpDegrees, "degrees", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpSin, "sin", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpCos, "cos", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpTan, "tan", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpAsin, "asin", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpAcos, "acos", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpAtan, "atan", 2, TypeF, ClassRegular, nullptr },
|
||||
{ EOpAtan, "atan", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpPow, "pow", 2, TypeF, ClassRegular, nullptr },
|
||||
{ EOpExp, "exp", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpLog, "log", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpExp2, "exp2", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpLog2, "log2", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpSqrt, "sqrt", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpInverseSqrt, "inversesqrt", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpAbs, "abs", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpSign, "sign", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpFloor, "floor", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpCeil, "ceil", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpFract, "fract", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpMod, "mod", 2, TypeF, ClassLS, nullptr },
|
||||
{ EOpMin, "min", 2, TypeF, ClassLS, nullptr },
|
||||
{ EOpMax, "max", 2, TypeF, ClassLS, nullptr },
|
||||
{ EOpClamp, "clamp", 3, TypeF, ClassLS2, nullptr },
|
||||
{ EOpMix, "mix", 3, TypeF, ClassLS, nullptr },
|
||||
{ EOpStep, "step", 2, TypeF, ClassFS, nullptr },
|
||||
{ EOpSmoothStep, "smoothstep", 3, TypeF, ClassFS2, nullptr },
|
||||
{ EOpNormalize, "normalize", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpFaceForward, "faceforward", 3, TypeF, ClassRegular, nullptr },
|
||||
{ EOpReflect, "reflect", 2, TypeF, ClassRegular, nullptr },
|
||||
{ EOpRefract, "refract", 3, TypeF, ClassXLS, nullptr },
|
||||
{ EOpLength, "length", 1, TypeF, ClassRS, nullptr },
|
||||
{ EOpDistance, "distance", 2, TypeF, ClassRS, nullptr },
|
||||
{ EOpDot, "dot", 2, TypeF, ClassRS, nullptr },
|
||||
{ EOpCross, "cross", 2, TypeF, ClassV3, nullptr },
|
||||
{ EOpLessThan, "lessThan", 2, TypeFI, ClassBNS, nullptr },
|
||||
{ EOpLessThanEqual, "lessThanEqual", 2, TypeFI, ClassBNS, nullptr },
|
||||
{ EOpGreaterThan, "greaterThan", 2, TypeFI, ClassBNS, nullptr },
|
||||
{ EOpGreaterThanEqual, "greaterThanEqual", 2, TypeFI, ClassBNS, nullptr },
|
||||
{ EOpVectorEqual, "equal", 2, TypeFIB, ClassBNS, nullptr },
|
||||
{ EOpVectorNotEqual, "notEqual", 2, TypeFIB, ClassBNS, nullptr },
|
||||
{ EOpAny, "any", 1, TypeB, ClassRSNS, nullptr },
|
||||
{ EOpAll, "all", 1, TypeB, ClassRSNS, nullptr },
|
||||
{ EOpVectorLogicalNot, "not", 1, TypeB, ClassNS, nullptr },
|
||||
{ EOpSinh, "sinh", 1, TypeF, ClassRegular, Es300Desktop130 },
|
||||
{ EOpCosh, "cosh", 1, TypeF, ClassRegular, Es300Desktop130 },
|
||||
{ EOpTanh, "tanh", 1, TypeF, ClassRegular, Es300Desktop130 },
|
||||
{ EOpAsinh, "asinh", 1, TypeF, ClassRegular, Es300Desktop130 },
|
||||
{ EOpAcosh, "acosh", 1, TypeF, ClassRegular, Es300Desktop130 },
|
||||
{ EOpAtanh, "atanh", 1, TypeF, ClassRegular, Es300Desktop130 },
|
||||
{ EOpAbs, "abs", 1, TypeI, ClassRegular, Es300Desktop130 },
|
||||
{ EOpSign, "sign", 1, TypeI, ClassRegular, Es300Desktop130 },
|
||||
{ EOpTrunc, "trunc", 1, TypeF, ClassRegular, Es300Desktop130 },
|
||||
{ EOpRound, "round", 1, TypeF, ClassRegular, Es300Desktop130 },
|
||||
{ EOpRoundEven, "roundEven", 1, TypeF, ClassRegular, Es300Desktop130 },
|
||||
{ EOpModf, "modf", 2, TypeF, ClassLO, Es300Desktop130 },
|
||||
{ EOpMin, "min", 2, TypeIU, ClassLS, Es300Desktop130 },
|
||||
{ EOpMax, "max", 2, TypeIU, ClassLS, Es300Desktop130 },
|
||||
{ EOpClamp, "clamp", 3, TypeIU, ClassLS2, Es300Desktop130 },
|
||||
{ EOpMix, "mix", 3, TypeF, ClassLB, Es300Desktop130 },
|
||||
{ EOpIsInf, "isinf", 1, TypeF, ClassB, Es300Desktop130 },
|
||||
{ EOpIsNan, "isnan", 1, TypeF, ClassB, Es300Desktop130 },
|
||||
{ EOpLessThan, "lessThan", 2, TypeU, ClassBNS, Es300Desktop130 },
|
||||
{ EOpLessThanEqual, "lessThanEqual", 2, TypeU, ClassBNS, Es300Desktop130 },
|
||||
{ EOpGreaterThan, "greaterThan", 2, TypeU, ClassBNS, Es300Desktop130 },
|
||||
{ EOpGreaterThanEqual, "greaterThanEqual", 2, TypeU, ClassBNS, Es300Desktop130 },
|
||||
{ EOpVectorEqual, "equal", 2, TypeU, ClassBNS, Es300Desktop130 },
|
||||
{ EOpVectorNotEqual, "notEqual", 2, TypeU, ClassBNS, Es300Desktop130 },
|
||||
{ EOpAtomicAdd, "atomicAdd", 2, TypeIU, ClassV1FIOCV, Es310Desktop400 },
|
||||
{ EOpAtomicMin, "atomicMin", 2, TypeIU, ClassV1FIOCV, Es310Desktop400 },
|
||||
{ EOpAtomicMax, "atomicMax", 2, TypeIU, ClassV1FIOCV, Es310Desktop400 },
|
||||
{ EOpAtomicAnd, "atomicAnd", 2, TypeIU, ClassV1FIOCV, Es310Desktop400 },
|
||||
{ EOpAtomicOr, "atomicOr", 2, TypeIU, ClassV1FIOCV, Es310Desktop400 },
|
||||
{ EOpAtomicXor, "atomicXor", 2, TypeIU, ClassV1FIOCV, Es310Desktop400 },
|
||||
{ EOpAtomicExchange, "atomicExchange", 2, TypeIU, ClassV1FIOCV, Es310Desktop400 },
|
||||
{ EOpAtomicCompSwap, "atomicCompSwap", 3, TypeIU, ClassV1FIOCV, Es310Desktop400 },
|
||||
{ EOpMix, "mix", 3, TypeB, ClassRegular, Es310Desktop450 },
|
||||
{ EOpMix, "mix", 3, TypeIU, ClassLB, Es310Desktop450 },
|
||||
|
||||
{ EOpNull }
|
||||
BuiltInFunction{ EOpRadians, "radians", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpDegrees, "degrees", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpSin, "sin", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpCos, "cos", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpTan, "tan", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpAsin, "asin", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpAcos, "acos", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpAtan, "atan", 2, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpAtan, "atan", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpPow, "pow", 2, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpExp, "exp", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpLog, "log", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpExp2, "exp2", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpLog2, "log2", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpSqrt, "sqrt", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpInverseSqrt, "inversesqrt", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpAbs, "abs", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpSign, "sign", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpFloor, "floor", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpCeil, "ceil", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpFract, "fract", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpMod, "mod", 2, TypeF, ClassLS, {} },
|
||||
BuiltInFunction{ EOpMin, "min", 2, TypeF, ClassLS, {} },
|
||||
BuiltInFunction{ EOpMax, "max", 2, TypeF, ClassLS, {} },
|
||||
BuiltInFunction{ EOpClamp, "clamp", 3, TypeF, ClassLS2, {} },
|
||||
BuiltInFunction{ EOpMix, "mix", 3, TypeF, ClassLS, {} },
|
||||
BuiltInFunction{ EOpStep, "step", 2, TypeF, ClassFS, {} },
|
||||
BuiltInFunction{ EOpSmoothStep, "smoothstep", 3, TypeF, ClassFS2, {} },
|
||||
BuiltInFunction{ EOpNormalize, "normalize", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpFaceForward, "faceforward", 3, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpReflect, "reflect", 2, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpRefract, "refract", 3, TypeF, ClassXLS, {} },
|
||||
BuiltInFunction{ EOpLength, "length", 1, TypeF, ClassRS, {} },
|
||||
BuiltInFunction{ EOpDistance, "distance", 2, TypeF, ClassRS, {} },
|
||||
BuiltInFunction{ EOpDot, "dot", 2, TypeF, ClassRS, {} },
|
||||
BuiltInFunction{ EOpCross, "cross", 2, TypeF, ClassV3, {} },
|
||||
BuiltInFunction{ EOpLessThan, "lessThan", 2, TypeFI, ClassBNS, {} },
|
||||
BuiltInFunction{ EOpLessThanEqual, "lessThanEqual", 2, TypeFI, ClassBNS, {} },
|
||||
BuiltInFunction{ EOpGreaterThan, "greaterThan", 2, TypeFI, ClassBNS, {} },
|
||||
BuiltInFunction{ EOpGreaterThanEqual, "greaterThanEqual", 2, TypeFI, ClassBNS, {} },
|
||||
BuiltInFunction{ EOpVectorEqual, "equal", 2, TypeFIB, ClassBNS, {} },
|
||||
BuiltInFunction{ EOpVectorNotEqual, "notEqual", 2, TypeFIB, ClassBNS, {} },
|
||||
BuiltInFunction{ EOpAny, "any", 1, TypeB, ClassRSNS, {} },
|
||||
BuiltInFunction{ EOpAll, "all", 1, TypeB, ClassRSNS, {} },
|
||||
BuiltInFunction{ EOpVectorLogicalNot, "not", 1, TypeB, ClassNS, {} },
|
||||
BuiltInFunction{ EOpSinh, "sinh", 1, TypeF, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpCosh, "cosh", 1, TypeF, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpTanh, "tanh", 1, TypeF, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpAsinh, "asinh", 1, TypeF, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpAcosh, "acosh", 1, TypeF, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpAtanh, "atanh", 1, TypeF, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpAbs, "abs", 1, TypeI, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpSign, "sign", 1, TypeI, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpTrunc, "trunc", 1, TypeF, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpRound, "round", 1, TypeF, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpRoundEven, "roundEven", 1, TypeF, ClassRegular, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpModf, "modf", 2, TypeF, ClassLO, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpMin, "min", 2, TypeIU, ClassLS, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpMax, "max", 2, TypeIU, ClassLS, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpClamp, "clamp", 3, TypeIU, ClassLS2, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpMix, "mix", 3, TypeF, ClassLB, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpIsInf, "isinf", 1, TypeF, ClassB, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpIsNan, "isnan", 1, TypeF, ClassB, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpLessThan, "lessThan", 2, TypeU, ClassBNS, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpLessThanEqual, "lessThanEqual", 2, TypeU, ClassBNS, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpGreaterThan, "greaterThan", 2, TypeU, ClassBNS, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpGreaterThanEqual, "greaterThanEqual", 2, TypeU, ClassBNS, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpVectorEqual, "equal", 2, TypeU, ClassBNS, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpVectorNotEqual, "notEqual", 2, TypeU, ClassBNS, {Es300Desktop130Version} },
|
||||
BuiltInFunction{ EOpAtomicAdd, "atomicAdd", 2, TypeIU, ClassV1FIOCV, {Es310Desktop400Version} },
|
||||
BuiltInFunction{ EOpAtomicMin, "atomicMin", 2, TypeIU, ClassV1FIOCV, {Es310Desktop400Version} },
|
||||
BuiltInFunction{ EOpAtomicMax, "atomicMax", 2, TypeIU, ClassV1FIOCV, {Es310Desktop400Version} },
|
||||
BuiltInFunction{ EOpAtomicAnd, "atomicAnd", 2, TypeIU, ClassV1FIOCV, {Es310Desktop400Version} },
|
||||
BuiltInFunction{ EOpAtomicOr, "atomicOr", 2, TypeIU, ClassV1FIOCV, {Es310Desktop400Version} },
|
||||
BuiltInFunction{ EOpAtomicXor, "atomicXor", 2, TypeIU, ClassV1FIOCV, {Es310Desktop400Version} },
|
||||
BuiltInFunction{ EOpAtomicExchange, "atomicExchange", 2, TypeIU, ClassV1FIOCV, {Es310Desktop400Version} },
|
||||
BuiltInFunction{ EOpAtomicCompSwap, "atomicCompSwap", 3, TypeIU, ClassV1FIOCV, {Es310Desktop400Version} },
|
||||
BuiltInFunction{ EOpMix, "mix", 3, TypeB, ClassRegular, {Es310Desktop450Version} },
|
||||
BuiltInFunction{ EOpMix, "mix", 3, TypeIU, ClassLB, {Es310Desktop450Version} },
|
||||
};
|
||||
|
||||
const BuiltInFunction DerivativeFunctions[] = {
|
||||
{ EOpDPdx, "dFdx", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpDPdy, "dFdy", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpFwidth, "fwidth", 1, TypeF, ClassRegular, nullptr },
|
||||
{ EOpNull }
|
||||
const std::array DerivativeFunctions = {
|
||||
BuiltInFunction{ EOpDPdx, "dFdx", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpDPdy, "dFdy", 1, TypeF, ClassRegular, {} },
|
||||
BuiltInFunction{ EOpFwidth, "fwidth", 1, TypeF, ClassRegular, {} },
|
||||
};
|
||||
|
||||
// For functions declared some other way, but still use the table to relate to operator.
|
||||
struct CustomFunction {
|
||||
TOperator op; // operator to map the name to
|
||||
const char* name; // function name
|
||||
const Versioning* versioning; // nullptr means always a valid version
|
||||
const span<const Versioning> versioning; // An empty span means always a valid version
|
||||
};
|
||||
|
||||
const CustomFunction CustomFunctions[] = {
|
||||
{ EOpBarrier, "barrier", nullptr },
|
||||
{ EOpMemoryBarrierShared, "memoryBarrierShared", nullptr },
|
||||
{ EOpGroupMemoryBarrier, "groupMemoryBarrier", nullptr },
|
||||
{ EOpMemoryBarrier, "memoryBarrier", nullptr },
|
||||
{ EOpMemoryBarrierBuffer, "memoryBarrierBuffer", nullptr },
|
||||
{ EOpBarrier, "barrier", {} },
|
||||
{ EOpMemoryBarrierShared, "memoryBarrierShared", {} },
|
||||
{ EOpGroupMemoryBarrier, "groupMemoryBarrier", {} },
|
||||
{ EOpMemoryBarrier, "memoryBarrier", {} },
|
||||
{ EOpMemoryBarrierBuffer, "memoryBarrierBuffer", {} },
|
||||
|
||||
{ EOpPackSnorm2x16, "packSnorm2x16", nullptr },
|
||||
{ EOpUnpackSnorm2x16, "unpackSnorm2x16", nullptr },
|
||||
{ EOpPackUnorm2x16, "packUnorm2x16", nullptr },
|
||||
{ EOpUnpackUnorm2x16, "unpackUnorm2x16", nullptr },
|
||||
{ EOpPackHalf2x16, "packHalf2x16", nullptr },
|
||||
{ EOpUnpackHalf2x16, "unpackHalf2x16", nullptr },
|
||||
{ EOpPackSnorm2x16, "packSnorm2x16", {} },
|
||||
{ EOpUnpackSnorm2x16, "unpackSnorm2x16", {} },
|
||||
{ EOpPackUnorm2x16, "packUnorm2x16", {} },
|
||||
{ EOpUnpackUnorm2x16, "unpackUnorm2x16", {} },
|
||||
{ EOpPackHalf2x16, "packHalf2x16", {} },
|
||||
{ EOpUnpackHalf2x16, "unpackHalf2x16", {} },
|
||||
|
||||
{ EOpMul, "matrixCompMult", nullptr },
|
||||
{ EOpOuterProduct, "outerProduct", nullptr },
|
||||
{ EOpTranspose, "transpose", nullptr },
|
||||
{ EOpDeterminant, "determinant", nullptr },
|
||||
{ EOpMatrixInverse, "inverse", nullptr },
|
||||
{ EOpFloatBitsToInt, "floatBitsToInt", nullptr },
|
||||
{ EOpFloatBitsToUint, "floatBitsToUint", nullptr },
|
||||
{ EOpIntBitsToFloat, "intBitsToFloat", nullptr },
|
||||
{ EOpUintBitsToFloat, "uintBitsToFloat", nullptr },
|
||||
{ EOpMul, "matrixCompMult", {} },
|
||||
{ EOpOuterProduct, "outerProduct", {} },
|
||||
{ EOpTranspose, "transpose", {} },
|
||||
{ EOpDeterminant, "determinant", {} },
|
||||
{ EOpMatrixInverse, "inverse", {} },
|
||||
{ EOpFloatBitsToInt, "floatBitsToInt", {} },
|
||||
{ EOpFloatBitsToUint, "floatBitsToUint", {} },
|
||||
{ EOpIntBitsToFloat, "intBitsToFloat", {} },
|
||||
{ EOpUintBitsToFloat, "uintBitsToFloat", {} },
|
||||
|
||||
{ EOpTextureQuerySize, "textureSize", nullptr },
|
||||
{ EOpTextureQueryLod, "textureQueryLod", nullptr },
|
||||
{ EOpTextureQueryLod, "textureQueryLOD", nullptr }, // extension GL_ARB_texture_query_lod
|
||||
{ EOpTextureQueryLevels, "textureQueryLevels", nullptr },
|
||||
{ EOpTextureQuerySamples, "textureSamples", nullptr },
|
||||
{ EOpTexture, "texture", nullptr },
|
||||
{ EOpTextureProj, "textureProj", nullptr },
|
||||
{ EOpTextureLod, "textureLod", nullptr },
|
||||
{ EOpTextureOffset, "textureOffset", nullptr },
|
||||
{ EOpTextureFetch, "texelFetch", nullptr },
|
||||
{ EOpTextureFetchOffset, "texelFetchOffset", nullptr },
|
||||
{ EOpTextureProjOffset, "textureProjOffset", nullptr },
|
||||
{ EOpTextureLodOffset, "textureLodOffset", nullptr },
|
||||
{ EOpTextureProjLod, "textureProjLod", nullptr },
|
||||
{ EOpTextureProjLodOffset, "textureProjLodOffset", nullptr },
|
||||
{ EOpTextureGrad, "textureGrad", nullptr },
|
||||
{ EOpTextureGradOffset, "textureGradOffset", nullptr },
|
||||
{ EOpTextureProjGrad, "textureProjGrad", nullptr },
|
||||
{ EOpTextureProjGradOffset, "textureProjGradOffset", nullptr },
|
||||
|
||||
{ EOpNull }
|
||||
{ EOpTextureQuerySize, "textureSize", {} },
|
||||
{ EOpTextureQueryLod, "textureQueryLod", {} },
|
||||
{ EOpTextureQueryLod, "textureQueryLOD", {} }, // extension GL_ARB_texture_query_lod
|
||||
{ EOpTextureQueryLevels, "textureQueryLevels", {} },
|
||||
{ EOpTextureQuerySamples, "textureSamples", {} },
|
||||
{ EOpTexture, "texture", {} },
|
||||
{ EOpTextureProj, "textureProj", {} },
|
||||
{ EOpTextureLod, "textureLod", {} },
|
||||
{ EOpTextureOffset, "textureOffset", {} },
|
||||
{ EOpTextureFetch, "texelFetch", {} },
|
||||
{ EOpTextureFetchOffset, "texelFetchOffset", {} },
|
||||
{ EOpTextureProjOffset, "textureProjOffset", {} },
|
||||
{ EOpTextureLodOffset, "textureLodOffset", {} },
|
||||
{ EOpTextureProjLod, "textureProjLod", {} },
|
||||
{ EOpTextureProjLodOffset, "textureProjLodOffset", {} },
|
||||
{ EOpTextureGrad, "textureGrad", {} },
|
||||
{ EOpTextureGradOffset, "textureGradOffset", {} },
|
||||
{ EOpTextureProjGrad, "textureProjGrad", {} },
|
||||
{ EOpTextureProjGradOffset, "textureProjGradOffset", {} },
|
||||
};
|
||||
|
||||
// For the given table of functions, add all the indicated prototypes for each
|
||||
@ -403,13 +397,13 @@ void AddTabledBuiltin(TString& decls, const BuiltInFunction& function)
|
||||
bool ValidVersion(const BuiltInFunction& function, int version, EProfile profile, const SpvVersion& /* spVersion */)
|
||||
{
|
||||
// nullptr means always valid
|
||||
if (function.versioning == nullptr)
|
||||
if (function.versioning.empty())
|
||||
return true;
|
||||
|
||||
// check for what is said about our current profile
|
||||
for (const Versioning* v = function.versioning; v->profiles != EBadProfile; ++v) {
|
||||
if ((v->profiles & profile) != 0) {
|
||||
if (v->minCoreVersion <= version || (v->numExtensions > 0 && v->minExtendedVersion <= version))
|
||||
for (const auto& v : function.versioning) {
|
||||
if ((v.profiles & profile) != 0) {
|
||||
if (v.minCoreVersion <= version || (v.numExtensions > 0 && v.minExtendedVersion <= version))
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -422,12 +416,11 @@ bool ValidVersion(const BuiltInFunction& function, int version, EProfile profile
|
||||
// called once per stage). This is a performance issue only, not a correctness
|
||||
// concern. It is done for quality arising from simplicity, as there are subtleties
|
||||
// to get correct if instead trying to do it surgically.
|
||||
template<class FunctionT>
|
||||
void RelateTabledBuiltins(const FunctionT* functions, TSymbolTable& symbolTable)
|
||||
template<class FunctionContainer>
|
||||
void RelateTabledBuiltins(const FunctionContainer& functions, TSymbolTable& symbolTable)
|
||||
{
|
||||
while (functions->op != EOpNull) {
|
||||
symbolTable.relateToOperator(functions->name, functions->op);
|
||||
++functions;
|
||||
for (const auto& fn : functions) {
|
||||
symbolTable.relateToOperator(fn.name, fn.op);
|
||||
}
|
||||
}
|
||||
|
||||
@ -436,11 +429,10 @@ void RelateTabledBuiltins(const FunctionT* functions, TSymbolTable& symbolTable)
|
||||
// Add declarations for all tables of built-in functions.
|
||||
void TBuiltIns::addTabledBuiltins(int version, EProfile profile, const SpvVersion& spvVersion)
|
||||
{
|
||||
const auto forEachFunction = [&](TString& decls, const BuiltInFunction* function) {
|
||||
while (function->op != EOpNull) {
|
||||
if (ValidVersion(*function, version, profile, spvVersion))
|
||||
AddTabledBuiltin(decls, *function);
|
||||
++function;
|
||||
const auto forEachFunction = [&](TString& decls, const span<const BuiltInFunction>& functions) {
|
||||
for (const auto& fn : functions) {
|
||||
if (ValidVersion(fn, version, profile, spvVersion))
|
||||
AddTabledBuiltin(decls, fn);
|
||||
}
|
||||
};
|
||||
|
||||
@ -1473,6 +1465,20 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
||||
"\n");
|
||||
}
|
||||
|
||||
// NV_shader_atomic_fp16_vector
|
||||
if (profile != EEsProfile && version >= 430) {
|
||||
commonBuiltins.append(
|
||||
"f16vec2 atomicAdd(coherent volatile inout f16vec2, f16vec2);"
|
||||
"f16vec4 atomicAdd(coherent volatile inout f16vec4, f16vec4);"
|
||||
"f16vec2 atomicMin(coherent volatile inout f16vec2, f16vec2);"
|
||||
"f16vec4 atomicMin(coherent volatile inout f16vec4, f16vec4);"
|
||||
"f16vec2 atomicMax(coherent volatile inout f16vec2, f16vec2);"
|
||||
"f16vec4 atomicMax(coherent volatile inout f16vec4, f16vec4);"
|
||||
"f16vec2 atomicExchange(coherent volatile inout f16vec2, f16vec2);"
|
||||
"f16vec4 atomicExchange(coherent volatile inout f16vec4, f16vec4);"
|
||||
"\n");
|
||||
}
|
||||
|
||||
if ((profile == EEsProfile && version >= 300) ||
|
||||
(profile != EEsProfile && version >= 150)) { // GL_ARB_shader_bit_encoding
|
||||
commonBuiltins.append(
|
||||
@ -2107,6 +2113,8 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
||||
"%s subgroupShuffleXor(%s, uint);\n",
|
||||
"%s subgroupShuffleUp(%s, uint delta);\n",
|
||||
"%s subgroupShuffleDown(%s, uint delta);\n",
|
||||
"%s subgroupRotate(%s, uint);\n",
|
||||
"%s subgroupClusteredRotate(%s, uint, uint);\n",
|
||||
"%s subgroupAdd(%s);\n",
|
||||
"%s subgroupMul(%s);\n",
|
||||
"%s subgroupMin(%s);\n",
|
||||
@ -2235,6 +2243,15 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
||||
);
|
||||
}
|
||||
|
||||
// GL_EXT_shader_quad_control
|
||||
if ((profile == EEsProfile && version >= 310) ||
|
||||
(profile != EEsProfile && version >= 140)) {
|
||||
commonBuiltins.append(
|
||||
"bool subgroupQuadAll(bool);\n"
|
||||
"bool subgroupQuadAny(bool);\n"
|
||||
);
|
||||
}
|
||||
|
||||
if (profile != EEsProfile && version >= 460) {
|
||||
commonBuiltins.append(
|
||||
"bool anyInvocation(bool);"
|
||||
@ -4115,6 +4132,37 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
||||
"u16vec4 unpack16(uint64_t);"
|
||||
"i32vec2 unpack32(int64_t);"
|
||||
"u32vec2 unpack32(uint64_t);"
|
||||
|
||||
// GL_EXT_expect_assume
|
||||
"int8_t expectEXT(int8_t, int8_t);"
|
||||
"i8vec2 expectEXT(i8vec2, i8vec2);"
|
||||
"i8vec3 expectEXT(i8vec3, i8vec3);"
|
||||
"i8vec4 expectEXT(i8vec4, i8vec4);"
|
||||
|
||||
"uint8_t expectEXT(uint8_t, uint8_t);"
|
||||
"u8vec2 expectEXT(u8vec2, u8vec2);"
|
||||
"u8vec3 expectEXT(u8vec3, u8vec3);"
|
||||
"u8vec4 expectEXT(u8vec4, u8vec4);"
|
||||
|
||||
"int16_t expectEXT(int16_t, int16_t);"
|
||||
"i16vec2 expectEXT(i16vec2, i16vec2);"
|
||||
"i16vec3 expectEXT(i16vec3, i16vec3);"
|
||||
"i16vec4 expectEXT(i16vec4, i16vec4);"
|
||||
|
||||
"uint16_t expectEXT(uint16_t, uint16_t);"
|
||||
"u16vec2 expectEXT(u16vec2, u16vec2);"
|
||||
"u16vec3 expectEXT(u16vec3, u16vec3);"
|
||||
"u16vec4 expectEXT(u16vec4, u16vec4);"
|
||||
|
||||
"int64_t expectEXT(int64_t, int64_t);"
|
||||
"i64vec2 expectEXT(i64vec2, i64vec2);"
|
||||
"i64vec3 expectEXT(i64vec3, i64vec3);"
|
||||
"i64vec4 expectEXT(i64vec4, i64vec4);"
|
||||
|
||||
"uint64_t expectEXT(uint64_t, uint64_t);"
|
||||
"u64vec2 expectEXT(u64vec2, u64vec2);"
|
||||
"u64vec3 expectEXT(u64vec3, u64vec3);"
|
||||
"u64vec4 expectEXT(u64vec4, u64vec4);"
|
||||
"\n");
|
||||
}
|
||||
|
||||
@ -4153,6 +4201,29 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
||||
|
||||
}
|
||||
|
||||
// GL_EXT_expect_assume
|
||||
if ((profile == EEsProfile && version >= 310) ||
|
||||
((profile != EEsProfile && version >= 140))) {
|
||||
commonBuiltins.append(
|
||||
"void assumeEXT(bool);"
|
||||
|
||||
"bool expectEXT(bool, bool);"
|
||||
"bvec2 expectEXT(bvec2, bvec2);"
|
||||
"bvec3 expectEXT(bvec3, bvec3);"
|
||||
"bvec4 expectEXT(bvec4, bvec4);"
|
||||
|
||||
"int expectEXT(int, int);"
|
||||
"ivec2 expectEXT(ivec2, ivec2);"
|
||||
"ivec3 expectEXT(ivec3, ivec3);"
|
||||
"ivec4 expectEXT(ivec4, ivec4);"
|
||||
|
||||
"uint expectEXT(uint, uint);"
|
||||
"uvec2 expectEXT(uvec2, uvec2);"
|
||||
"uvec3 expectEXT(uvec3, uvec3);"
|
||||
"uvec4 expectEXT(uvec4, uvec4);"
|
||||
"\n");
|
||||
}
|
||||
|
||||
// QCOM_image_processing
|
||||
if ((profile == EEsProfile && version >= 310) ||
|
||||
(profile != EEsProfile && version >= 140)) {
|
||||
@ -4162,6 +4233,11 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
||||
"vec4 textureBoxFilterQCOM(sampler2D, vec2, vec2);"
|
||||
"vec4 textureBlockMatchSADQCOM(sampler2D, uvec2, sampler2D, uvec2, uvec2);"
|
||||
"vec4 textureBlockMatchSSDQCOM(sampler2D, uvec2, sampler2D, uvec2, uvec2);"
|
||||
|
||||
"vec4 textureBlockMatchWindowSSDQCOM(sampler2D, uvec2, sampler2D, uvec2, uvec2);"
|
||||
"vec4 textureBlockMatchWindowSADQCOM(sampler2D, uvec2, sampler2D, uvec2, uvec2);"
|
||||
"vec4 textureBlockMatchGatherSSDQCOM(sampler2D, uvec2, sampler2D, uvec2, uvec2);"
|
||||
"vec4 textureBlockMatchGatherSADQCOM(sampler2D, uvec2, sampler2D, uvec2, uvec2);"
|
||||
"\n");
|
||||
}
|
||||
|
||||
@ -6289,7 +6365,7 @@ void TBuiltIns::add2ndGenerationSamplingImaging(int version, EProfile profile, c
|
||||
{
|
||||
if ((ms || image) && shadow)
|
||||
continue;
|
||||
if (ms && profile != EEsProfile && version < 150)
|
||||
if (ms && profile != EEsProfile && version < 140)
|
||||
continue;
|
||||
if (ms && image && profile == EEsProfile)
|
||||
continue;
|
||||
@ -6621,6 +6697,34 @@ void TBuiltIns::addImageFunctions(TSampler sampler, const TString& typeName, int
|
||||
commonBuiltins.append(imageParams);
|
||||
commonBuiltins.append(", float);\n");
|
||||
}
|
||||
|
||||
// GL_NV_shader_atomic_fp16_vector
|
||||
if (profile != EEsProfile && version >= 430) {
|
||||
const int numFp16Builtins = 4;
|
||||
const char* atomicFp16Func[numFp16Builtins] = {
|
||||
" imageAtomicAdd(volatile coherent ",
|
||||
" imageAtomicMin(volatile coherent ",
|
||||
" imageAtomicMax(volatile coherent ",
|
||||
" imageAtomicExchange(volatile coherent "
|
||||
};
|
||||
const int numFp16DataTypes = 2;
|
||||
const char* atomicFp16DataTypes[numFp16DataTypes] = {
|
||||
"f16vec2",
|
||||
"f16vec4"
|
||||
};
|
||||
// Loop twice to add prototypes with/without scope/semantics
|
||||
for (int j = 0; j < numFp16DataTypes; ++j) {
|
||||
for (int i = 0; i < numFp16Builtins; ++i) {
|
||||
commonBuiltins.append(atomicFp16DataTypes[j]);
|
||||
commonBuiltins.append(atomicFp16Func[i]);
|
||||
commonBuiltins.append(imageParams);
|
||||
commonBuiltins.append(", ");
|
||||
commonBuiltins.append(atomicFp16DataTypes[j]);
|
||||
commonBuiltins.append(");\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (profile != EEsProfile && version >= 450) {
|
||||
commonBuiltins.append("float imageAtomicAdd(volatile coherent ");
|
||||
commonBuiltins.append(imageParams);
|
||||
@ -8027,7 +8131,7 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
symbolTable.setFunctionExtensions("texture2DArrayLod", 1, &E_GL_EXT_texture_array);
|
||||
symbolTable.setFunctionExtensions("shadow1DArrayLod", 1, &E_GL_EXT_texture_array);
|
||||
}
|
||||
// Fall through
|
||||
[[fallthrough]];
|
||||
|
||||
case EShLangTessControl:
|
||||
if (profile == EEsProfile && version >= 310) {
|
||||
@ -8042,7 +8146,7 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
BuiltInVariable("gl_BoundingBox", EbvBoundingBox, symbolTable);
|
||||
}
|
||||
}
|
||||
// Fall through
|
||||
[[fallthrough]];
|
||||
|
||||
case EShLangTessEvaluation:
|
||||
case EShLangGeometry:
|
||||
@ -8628,6 +8732,13 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
BuiltInVariable("gl_SubGroupSizeARB", EbvSubGroupSize, symbolTable);
|
||||
}
|
||||
|
||||
// GL_EXT_expect_assume
|
||||
if ((profile == EEsProfile && version >= 310) ||
|
||||
(profile != EEsProfile && version >= 140)) {
|
||||
symbolTable.setFunctionExtensions("assumeEXT", 1, &E_GL_EXT_expect_assume);
|
||||
symbolTable.setFunctionExtensions("expectEXT", 1, &E_GL_EXT_expect_assume);
|
||||
}
|
||||
|
||||
// GL_KHR_shader_subgroup
|
||||
if ((profile == EEsProfile && version >= 310) ||
|
||||
(profile != EEsProfile && version >= 140)) {
|
||||
@ -8669,6 +8780,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
symbolTable.setFunctionExtensions("subgroupShuffleXor", 1, &E_GL_KHR_shader_subgroup_shuffle);
|
||||
symbolTable.setFunctionExtensions("subgroupShuffleUp", 1, &E_GL_KHR_shader_subgroup_shuffle_relative);
|
||||
symbolTable.setFunctionExtensions("subgroupShuffleDown", 1, &E_GL_KHR_shader_subgroup_shuffle_relative);
|
||||
symbolTable.setFunctionExtensions("subgroupRotate", 1, &E_GL_KHR_shader_subgroup_rotate);
|
||||
symbolTable.setFunctionExtensions("subgroupClusteredRotate", 1, &E_GL_KHR_shader_subgroup_rotate);
|
||||
symbolTable.setFunctionExtensions("subgroupAdd", 1, &E_GL_KHR_shader_subgroup_arithmetic);
|
||||
symbolTable.setFunctionExtensions("subgroupMul", 1, &E_GL_KHR_shader_subgroup_arithmetic);
|
||||
symbolTable.setFunctionExtensions("subgroupMin", 1, &E_GL_KHR_shader_subgroup_arithmetic);
|
||||
@ -8787,6 +8900,13 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
symbolTable.setVariableExtensions("gl_ShadingRateFlag4HorizontalPixelsEXT", 1, &E_GL_EXT_fragment_shading_rate);
|
||||
}
|
||||
|
||||
// GL_EXT_shader_quad_control
|
||||
if ((profile != EEsProfile && version >= 140) ||
|
||||
(profile == EEsProfile && version >= 310)) {
|
||||
symbolTable.setFunctionExtensions("subgroupQuadAll", 1, &E_GL_KHR_shader_subgroup_vote);
|
||||
symbolTable.setFunctionExtensions("subgroupQuadAny", 1, &E_GL_KHR_shader_subgroup_vote);
|
||||
}
|
||||
|
||||
// GL_EXT_shader_tile_image
|
||||
symbolTable.setFunctionExtensions("stencilAttachmentReadEXT", 1, &E_GL_EXT_shader_tile_image);
|
||||
symbolTable.setFunctionExtensions("depthAttachmentReadEXT", 1, &E_GL_EXT_shader_tile_image);
|
||||
@ -8794,10 +8914,16 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
|
||||
if ((profile == EEsProfile && version >= 310) ||
|
||||
(profile != EEsProfile && version >= 140)) {
|
||||
|
||||
symbolTable.setFunctionExtensions("textureWeightedQCOM", 1, &E_GL_QCOM_image_processing);
|
||||
symbolTable.setFunctionExtensions("textureBoxFilterQCOM", 1, &E_GL_QCOM_image_processing);
|
||||
symbolTable.setFunctionExtensions("textureBlockMatchSADQCOM", 1, &E_GL_QCOM_image_processing);
|
||||
symbolTable.setFunctionExtensions("textureBlockMatchSSDQCOM", 1, &E_GL_QCOM_image_processing);
|
||||
|
||||
symbolTable.setFunctionExtensions("textureBlockMatchWindowSSDQCOM", 1, &E_GL_QCOM_image_processing2);
|
||||
symbolTable.setFunctionExtensions("textureBlockMatchWindowSADQCOM", 1, &E_GL_QCOM_image_processing2);
|
||||
symbolTable.setFunctionExtensions("textureBlockMatchGatherSSDQCOM", 1, &E_GL_QCOM_image_processing2);
|
||||
symbolTable.setFunctionExtensions("textureBlockMatchGatherSADQCOM", 1, &E_GL_QCOM_image_processing2);
|
||||
}
|
||||
break;
|
||||
|
||||
@ -9720,6 +9846,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
symbolTable.relateToOperator("averageRounded", EOpAverageRounded);
|
||||
symbolTable.relateToOperator("multiply32x16", EOpMul32x16);
|
||||
symbolTable.relateToOperator("debugPrintfEXT", EOpDebugPrintf);
|
||||
symbolTable.relateToOperator("assumeEXT", EOpAssumeEXT);
|
||||
symbolTable.relateToOperator("expectEXT", EOpExpectEXT);
|
||||
|
||||
|
||||
if (PureOperatorBuiltins) {
|
||||
@ -9923,6 +10051,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
symbolTable.relateToOperator("subgroupShuffleXor", EOpSubgroupShuffleXor);
|
||||
symbolTable.relateToOperator("subgroupShuffleUp", EOpSubgroupShuffleUp);
|
||||
symbolTable.relateToOperator("subgroupShuffleDown", EOpSubgroupShuffleDown);
|
||||
symbolTable.relateToOperator("subgroupRotate", EOpSubgroupRotate);
|
||||
symbolTable.relateToOperator("subgroupClusteredRotate", EOpSubgroupClusteredRotate);
|
||||
symbolTable.relateToOperator("subgroupAdd", EOpSubgroupAdd);
|
||||
symbolTable.relateToOperator("subgroupMul", EOpSubgroupMul);
|
||||
symbolTable.relateToOperator("subgroupMin", EOpSubgroupMin);
|
||||
@ -9985,12 +10115,24 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
symbolTable.relateToOperator("shadow2DProjEXT", EOpTextureProj);
|
||||
}
|
||||
|
||||
// GL_EXT_shader_quad_control
|
||||
if ((profile == EEsProfile && version >= 310) ||
|
||||
(profile != EEsProfile && version >= 140)) {
|
||||
symbolTable.relateToOperator("subgroupQuadAll", EOpSubgroupQuadAll);
|
||||
symbolTable.relateToOperator("subgroupQuadAny", EOpSubgroupQuadAny);
|
||||
}
|
||||
|
||||
if ((profile == EEsProfile && version >= 310) ||
|
||||
(profile != EEsProfile && version >= 140)) {
|
||||
symbolTable.relateToOperator("textureWeightedQCOM", EOpImageSampleWeightedQCOM);
|
||||
symbolTable.relateToOperator("textureBoxFilterQCOM", EOpImageBoxFilterQCOM);
|
||||
symbolTable.relateToOperator("textureBlockMatchSADQCOM", EOpImageBlockMatchSADQCOM);
|
||||
symbolTable.relateToOperator("textureBlockMatchSSDQCOM", EOpImageBlockMatchSSDQCOM);
|
||||
|
||||
symbolTable.relateToOperator("textureBlockMatchWindowSSDQCOM", EOpImageBlockMatchWindowSSDQCOM);
|
||||
symbolTable.relateToOperator("textureBlockMatchWindowSADQCOM", EOpImageBlockMatchWindowSADQCOM);
|
||||
symbolTable.relateToOperator("textureBlockMatchGatherSSDQCOM", EOpImageBlockMatchGatherSSDQCOM);
|
||||
symbolTable.relateToOperator("textureBlockMatchGatherSADQCOM", EOpImageBlockMatchGatherSADQCOM);
|
||||
}
|
||||
|
||||
if (profile != EEsProfile && spvVersion.spv == 0) {
|
||||
@ -10105,7 +10247,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
||||
if (profile != EEsProfile && version >= 460) {
|
||||
symbolTable.relateToOperator("fetchMicroTriangleVertexPositionNV", EOpFetchMicroTriangleVertexPositionNV);
|
||||
symbolTable.relateToOperator("fetchMicroTriangleVertexBarycentricNV", EOpFetchMicroTriangleVertexBarycentricNV);
|
||||
} // fallthrough
|
||||
}
|
||||
[[fallthrough]];
|
||||
case EShLangClosestHit:
|
||||
case EShLangMiss:
|
||||
if (profile != EEsProfile && version >= 460) {
|
||||
|
@ -376,6 +376,7 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child,
|
||||
case EOpNegative:
|
||||
if (child->getType().getBasicType() == EbtStruct || child->getType().isArray())
|
||||
return nullptr;
|
||||
break;
|
||||
default: break; // some compilers want this
|
||||
}
|
||||
|
||||
@ -1277,6 +1278,7 @@ void TIntermediate::addBiShapeConversion(TOperator op, TIntermTyped*& lhsNode, T
|
||||
// matrix multiply does not change shapes
|
||||
if (lhsNode->isMatrix() && rhsNode->isMatrix())
|
||||
return;
|
||||
[[fallthrough]];
|
||||
case EOpAdd:
|
||||
case EOpSub:
|
||||
case EOpDiv:
|
||||
@ -3489,6 +3491,7 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
|
||||
// check for non-Boolean operands
|
||||
if (left->getBasicType() == EbtBool || right->getBasicType() == EbtBool)
|
||||
return false;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
@ -3532,13 +3535,14 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
|
||||
if (left->getType() == right->getType())
|
||||
return true;
|
||||
|
||||
// Fall through
|
||||
[[fallthrough]];
|
||||
|
||||
case EOpMul:
|
||||
case EOpMulAssign:
|
||||
// At least the basic type has to match
|
||||
if (left->getBasicType() != right->getBasicType())
|
||||
return false;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
@ -3681,7 +3685,7 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
|
||||
case EOpAssign:
|
||||
if (left->getVectorSize() != right->getVectorSize() || left->getMatrixCols() != right->getMatrixCols() || left->getMatrixRows() != right->getMatrixRows())
|
||||
return false;
|
||||
// fall through
|
||||
[[fallthrough]];
|
||||
|
||||
case EOpAdd:
|
||||
case EOpSub:
|
||||
|
@ -59,7 +59,7 @@ void TParseContextBase::outputMessage(const TSourceLoc& loc, const char* szReaso
|
||||
safe_vsprintf(szExtraInfo, maxSize, szExtraInfoFormat, args);
|
||||
|
||||
infoSink.info.prefix(prefix);
|
||||
infoSink.info.location(loc);
|
||||
infoSink.info.location(loc, messages & EShMsgAbsolutePath);
|
||||
infoSink.info << "'" << szToken << "' : " << szReason << " " << szExtraInfo << "\n";
|
||||
|
||||
if (prefix == EPrefixError) {
|
||||
@ -257,6 +257,7 @@ void TParseContextBase::rValueErrorCheck(const TSourceLoc& loc, const char* op,
|
||||
case EOpVectorSwizzle:
|
||||
case EOpMatrixSwizzle:
|
||||
rValueErrorCheck(loc, op, binaryNode->getLeft());
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
@ -598,6 +598,10 @@ TIntermTyped* TParseContext::handleBracketDereference(const TSourceLoc& loc, TIn
|
||||
indexValue >= resources.maxCullDistances) {
|
||||
error(loc, "gl_CullDistance", "[", "array index out of range '%d'", indexValue);
|
||||
}
|
||||
else if (base->getQualifier().builtIn == EbvSampleMask &&
|
||||
indexValue >= (resources.maxSamples + 31) / 32) {
|
||||
error(loc, "gl_SampleMask", "[", "array index out of range '%d'", indexValue);
|
||||
}
|
||||
// For 2D per-view builtin arrays, update the inner dimension size in parent type
|
||||
if (base->getQualifier().isPerView() && base->getQualifier().builtIn != EbvNone) {
|
||||
TIntermBinary* binaryNode = base->getAsBinaryNode();
|
||||
@ -632,7 +636,7 @@ TIntermTyped* TParseContext::handleBracketDereference(const TSourceLoc& loc, TIn
|
||||
else {
|
||||
// input/output blocks either don't exist or can't be variably indexed
|
||||
}
|
||||
} else if (language == EShLangFragment && base->getQualifier().isPipeOutput())
|
||||
} else if (language == EShLangFragment && base->getQualifier().isPipeOutput() && base->getQualifier().builtIn != EbvSampleMask)
|
||||
requireProfile(base->getLoc(), ~EEsProfile, "variable indexing fragment shader output array");
|
||||
else if (base->getBasicType() == EbtSampler && version >= 130) {
|
||||
const char* explanation = "variable indexing sampler array";
|
||||
@ -1351,6 +1355,10 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
|
||||
// - a user function.
|
||||
|
||||
// Error check for a function requiring specific extensions present.
|
||||
if (builtIn &&
|
||||
(fnCandidate->getBuiltInOp() == EOpSubgroupQuadAll || fnCandidate->getBuiltInOp() == EOpSubgroupQuadAny))
|
||||
requireExtensions(loc, 1, &E_GL_EXT_shader_quad_control, fnCandidate->getName().c_str());
|
||||
|
||||
if (builtIn && fnCandidate->getNumExtensions())
|
||||
requireExtensions(loc, fnCandidate->getNumExtensions(), fnCandidate->getExtensions(), fnCandidate->getName().c_str());
|
||||
|
||||
@ -1360,7 +1368,10 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
|
||||
requireInt16Arithmetic(loc, "built-in function", "(u)int16 types can only be in uniform block or buffer storage");
|
||||
if (builtIn && fnCandidate->getType().contains8BitInt())
|
||||
requireInt8Arithmetic(loc, "built-in function", "(u)int8 types can only be in uniform block or buffer storage");
|
||||
|
||||
if (builtIn && (fnCandidate->getBuiltInOp() == EOpTextureFetch || fnCandidate->getBuiltInOp() == EOpTextureQuerySize)) {
|
||||
if ((*fnCandidate)[0].type->getSampler().isMultiSample() && version <= 140)
|
||||
requireExtensions(loc, 1, &E_GL_ARB_texture_multisample, fnCandidate->getName().c_str());
|
||||
}
|
||||
if (arguments != nullptr) {
|
||||
// Make sure qualifications work for these arguments.
|
||||
TIntermAggregate* aggregate = arguments->getAsAggregate();
|
||||
@ -1756,6 +1767,11 @@ TIntermTyped* TParseContext::handleLengthMethod(const TSourceLoc& loc, TFunction
|
||||
name == "gl_MeshPrimitivesNV") {
|
||||
length = getIoArrayImplicitSize(type.getQualifier());
|
||||
}
|
||||
} else if (const auto typed = intermNode->getAsTyped()) {
|
||||
if (typed->getQualifier().builtIn == EbvSampleMask) {
|
||||
requireProfile(loc, EEsProfile, "the array size of gl_SampleMask and gl_SampleMaskIn is ceil(gl_MaxSamples/32)");
|
||||
length = (resources.maxSamples + 31) / 32;
|
||||
}
|
||||
}
|
||||
if (length == 0) {
|
||||
if (intermNode->getAsSymbolNode() && isIoResizeArray(type))
|
||||
@ -2512,15 +2528,26 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
|
||||
error(loc, "only supported on image with format r64i", fnCandidate.getName().c_str(), "");
|
||||
else if (callNode.getType().getBasicType() == EbtUint64 && imageType.getQualifier().getFormat() != ElfR64ui)
|
||||
error(loc, "only supported on image with format r64ui", fnCandidate.getName().c_str(), "");
|
||||
} else if(callNode.getType().getBasicType() == EbtFloat16 &&
|
||||
((callNode.getType().getVectorSize() == 2 && arg0->getType().getQualifier().getFormat() == ElfRg16f) ||
|
||||
(callNode.getType().getVectorSize() == 4 && arg0->getType().getQualifier().getFormat() == ElfRgba16f))) {
|
||||
if (StartsWith(fnCandidate.getName(), "imageAtomicAdd") ||
|
||||
StartsWith(fnCandidate.getName(), "imageAtomicExchange") ||
|
||||
StartsWith(fnCandidate.getName(), "imageAtomicMin") ||
|
||||
StartsWith(fnCandidate.getName(), "imageAtomicMax")) {
|
||||
requireExtensions(loc, 1, &E_GL_NV_shader_atomic_fp16_vector, fnCandidate.getName().c_str());
|
||||
} else {
|
||||
error(loc, "f16vec2/4 operation not supported on: ", fnCandidate.getName().c_str(), "");
|
||||
}
|
||||
} else if (imageType.getSampler().type == EbtFloat) {
|
||||
if (fnCandidate.getName().compare(0, 19, "imageAtomicExchange") == 0) {
|
||||
if (StartsWith(fnCandidate.getName(), "imageAtomicExchange")) {
|
||||
// imageAtomicExchange doesn't require an extension
|
||||
} else if ((fnCandidate.getName().compare(0, 14, "imageAtomicAdd") == 0) ||
|
||||
(fnCandidate.getName().compare(0, 15, "imageAtomicLoad") == 0) ||
|
||||
(fnCandidate.getName().compare(0, 16, "imageAtomicStore") == 0)) {
|
||||
} else if (StartsWith(fnCandidate.getName(), "imageAtomicAdd") ||
|
||||
StartsWith(fnCandidate.getName(), "imageAtomicLoad") ||
|
||||
StartsWith(fnCandidate.getName(), "imageAtomicStore")) {
|
||||
requireExtensions(loc, 1, &E_GL_EXT_shader_atomic_float, fnCandidate.getName().c_str());
|
||||
} else if ((fnCandidate.getName().compare(0, 14, "imageAtomicMin") == 0) ||
|
||||
(fnCandidate.getName().compare(0, 14, "imageAtomicMax") == 0)) {
|
||||
} else if (StartsWith(fnCandidate.getName(), "imageAtomicMin") ||
|
||||
StartsWith(fnCandidate.getName(), "imageAtomicMax")) {
|
||||
requireExtensions(loc, 1, &E_GL_EXT_shader_atomic_float2, fnCandidate.getName().c_str());
|
||||
} else {
|
||||
error(loc, "only supported on integer images", fnCandidate.getName().c_str(), "");
|
||||
@ -2570,6 +2597,11 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
|
||||
const char* const extensions[2] = { E_GL_NV_shader_atomic_int64,
|
||||
E_GL_EXT_shader_atomic_int64 };
|
||||
requireExtensions(loc, 2, extensions, fnCandidate.getName().c_str());
|
||||
} else if ((callNode.getOp() == EOpAtomicAdd || callNode.getOp() == EOpAtomicExchange ||
|
||||
callNode.getOp() == EOpAtomicMin || callNode.getOp() == EOpAtomicMax) &&
|
||||
arg0->getType().getBasicType() == EbtFloat16 &&
|
||||
(arg0->getType().getVectorSize() == 2 || arg0->getType().getVectorSize() == 4 )) {
|
||||
requireExtensions(loc, 1, &E_GL_NV_shader_atomic_fp16_vector, fnCandidate.getName().c_str());
|
||||
} else if ((callNode.getOp() == EOpAtomicAdd || callNode.getOp() == EOpAtomicExchange) &&
|
||||
(arg0->getType().getBasicType() == EbtFloat ||
|
||||
arg0->getType().getBasicType() == EbtDouble)) {
|
||||
@ -3978,6 +4010,18 @@ void TParseContext::globalQualifierFixCheck(const TSourceLoc& loc, TQualifier& q
|
||||
// Storage qualifier isn't ready for memberQualifierCheck, we should skip invariantCheck for it.
|
||||
if (!isMemberCheck || structNestingLevel > 0)
|
||||
invariantCheck(loc, qualifier);
|
||||
|
||||
if (qualifier.isFullQuads()) {
|
||||
if (qualifier.storage != EvqVaryingIn)
|
||||
error(loc, "can only apply to input layout", "full_quads ", "");
|
||||
intermediate.setReqFullQuadsMode();
|
||||
}
|
||||
|
||||
if (qualifier.isQuadDeriv()) {
|
||||
if (qualifier.storage != EvqVaryingIn)
|
||||
error(loc, "can only apply to input layout", "quad_derivatives", "");
|
||||
intermediate.setQuadDerivMode();
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
@ -5851,6 +5895,15 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
|
||||
publicType.shaderQualifiers.layoutOverrideCoverage = true;
|
||||
return;
|
||||
}
|
||||
if (id == "full_quads")
|
||||
{
|
||||
const char* feature = "full_quads qualifier";
|
||||
requireProfile(loc, ECompatibilityProfile | ECoreProfile | EEsProfile, feature);
|
||||
profileRequires(loc, ECoreProfile | ECompatibilityProfile, 140, E_GL_EXT_shader_quad_control, feature);
|
||||
profileRequires(loc, EEsProfile, 310, E_GL_EXT_shader_quad_control, feature);
|
||||
publicType.qualifier.layoutFullQuads = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (language == EShLangVertex ||
|
||||
language == EShLangTessControl ||
|
||||
@ -5900,6 +5953,16 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
|
||||
return;
|
||||
}
|
||||
|
||||
if (id == "quad_derivatives")
|
||||
{
|
||||
const char* feature = "quad_derivatives qualifier";
|
||||
requireProfile(loc, ECompatibilityProfile | ECoreProfile | EEsProfile, feature);
|
||||
profileRequires(loc, ECoreProfile | ECompatibilityProfile, 140, E_GL_EXT_shader_quad_control, feature);
|
||||
profileRequires(loc, EEsProfile, 310, E_GL_EXT_shader_quad_control, feature);
|
||||
publicType.qualifier.layoutQuadDeriv = true;
|
||||
return;
|
||||
}
|
||||
|
||||
error(loc, "unrecognized layout identifier, or qualifier requires assignment (e.g., binding = 4)", id.c_str(), "");
|
||||
}
|
||||
|
||||
@ -6201,7 +6264,7 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
|
||||
error(loc, "needs a literal integer", "max_primitives", "");
|
||||
return;
|
||||
}
|
||||
// Fall through
|
||||
[[fallthrough]];
|
||||
|
||||
case EShLangTask:
|
||||
// Fall through
|
||||
@ -6328,6 +6391,10 @@ void TParseContext::mergeObjectLayoutQualifiers(TQualifier& dst, const TQualifie
|
||||
dst.layoutSecondaryViewportRelativeOffset = src.layoutSecondaryViewportRelativeOffset;
|
||||
if (src.layoutShaderRecord)
|
||||
dst.layoutShaderRecord = true;
|
||||
if (src.layoutFullQuads)
|
||||
dst.layoutFullQuads = true;
|
||||
if (src.layoutQuadDeriv)
|
||||
dst.layoutQuadDeriv = true;
|
||||
if (src.layoutBindlessSampler)
|
||||
dst.layoutBindlessSampler = true;
|
||||
if (src.layoutBindlessImage)
|
||||
@ -6501,10 +6568,10 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
|
||||
int repeated = intermediate.addUsedLocation(qualifier, type, typeCollision);
|
||||
if (repeated >= 0 && ! typeCollision)
|
||||
error(loc, "overlapping use of location", "location", "%d", repeated);
|
||||
// "fragment-shader outputs/tileImageEXT ... if two variables are placed within the same
|
||||
// location, they must have the same underlying type (floating-point or integer)"
|
||||
if (typeCollision && language == EShLangFragment && (qualifier.isPipeOutput() || qualifier.storage == EvqTileImageEXT))
|
||||
error(loc, "fragment outputs or tileImageEXTs sharing the same location", "location", "%d must be the same basic type", repeated);
|
||||
// When location aliasing, the aliases sharing the location must have the same underlying numerical type and bit width(
|
||||
// floating - point or integer, 32 - bit versus 64 - bit,etc.)
|
||||
if (typeCollision && (qualifier.isPipeInput() || qualifier.isPipeOutput() || qualifier.storage == EvqTileImageEXT))
|
||||
error(loc, "the aliases sharing the location", "location", "%d must be the same basic type and interpolation qualification", repeated);
|
||||
}
|
||||
|
||||
if (qualifier.hasXfbOffset() && qualifier.hasXfbBuffer()) {
|
||||
@ -7273,7 +7340,7 @@ TIntermTyped* TParseContext::vkRelaxedRemapFunctionCall(const TSourceLoc& loc, T
|
||||
realFunc.addParameter(TParameter().copyParam((*function)[i]));
|
||||
}
|
||||
|
||||
TParameter tmpP = { nullptr, &uintType };
|
||||
TParameter tmpP = { nullptr, &uintType, {} };
|
||||
realFunc.addParameter(TParameter().copyParam(tmpP));
|
||||
arguments = intermediate.growAggregate(arguments, intermediate.addConstantUnion(1, loc, true));
|
||||
|
||||
@ -7290,7 +7357,7 @@ TIntermTyped* TParseContext::vkRelaxedRemapFunctionCall(const TSourceLoc& loc, T
|
||||
realFunc.addParameter(TParameter().copyParam((*function)[i]));
|
||||
}
|
||||
|
||||
TParameter tmpP = { nullptr, &uintType };
|
||||
TParameter tmpP = { nullptr, &uintType, {} };
|
||||
realFunc.addParameter(TParameter().copyParam(tmpP));
|
||||
arguments = intermediate.growAggregate(arguments, intermediate.addConstantUnion(-1, loc, true));
|
||||
|
||||
@ -7350,6 +7417,7 @@ void TParseContext::coopMatTypeParametersCheck(const TSourceLoc& loc, const TPub
|
||||
case EbtUint:
|
||||
case EbtUint8:
|
||||
case EbtUint16:
|
||||
case EbtSpirvType:
|
||||
break;
|
||||
default:
|
||||
error(loc, "coopmat invalid basic type", TType::getBasicString(publicType.typeParameters->basicType), "");
|
||||
@ -7573,6 +7641,7 @@ struct AccessChainTraverser : public TIntermTraverser {
|
||||
{}
|
||||
|
||||
TString path = "";
|
||||
TStorageQualifier topLevelStorageQualifier = TStorageQualifier::EvqLast;
|
||||
|
||||
bool visitBinary(TVisit, TIntermBinary* binary) override {
|
||||
if (binary->getOp() == EOpIndexDirectStruct)
|
||||
@ -7603,6 +7672,8 @@ struct AccessChainTraverser : public TIntermTraverser {
|
||||
}
|
||||
|
||||
void visitSymbol(TIntermSymbol* symbol) override {
|
||||
if (symbol->getType().isOpaque())
|
||||
topLevelStorageQualifier = symbol->getQualifier().storage;
|
||||
if (!IsAnonymous(symbol->getName()))
|
||||
path.append(symbol->getName());
|
||||
}
|
||||
@ -7613,7 +7684,16 @@ TIntermNode* TParseContext::vkRelaxedRemapFunctionArgument(const TSourceLoc& loc
|
||||
AccessChainTraverser accessChainTraverser{};
|
||||
intermTyped->traverse(&accessChainTraverser);
|
||||
|
||||
TParameter param = { NewPoolTString(accessChainTraverser.path.c_str()), new TType };
|
||||
if (accessChainTraverser.topLevelStorageQualifier == TStorageQualifier::EvqUniform)
|
||||
{
|
||||
TParameter param = { 0, new TType, {} };
|
||||
param.type->shallowCopy(intermTyped->getType());
|
||||
|
||||
function->addParameter(param);
|
||||
return intermTyped;
|
||||
}
|
||||
|
||||
TParameter param = { NewPoolTString(accessChainTraverser.path.c_str()), new TType, {} };
|
||||
param.type->shallowCopy(intermTyped->getType());
|
||||
|
||||
std::vector<int> newParams = {};
|
||||
@ -7732,7 +7812,8 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
|
||||
error(loc, "unexpected number type parameters", identifier.c_str(), "");
|
||||
}
|
||||
if (publicType.typeParameters) {
|
||||
if (!isTypeFloat(publicType.typeParameters->basicType) && !isTypeInt(publicType.typeParameters->basicType)) {
|
||||
if (!isTypeFloat(publicType.typeParameters->basicType) &&
|
||||
!isTypeInt(publicType.typeParameters->basicType) && publicType.typeParameters->basicType != EbtSpirvType) {
|
||||
error(loc, "expected 8, 16, 32, or 64 bit signed or unsigned integer or 16, 32, or 64 bit float type", identifier.c_str(), "");
|
||||
}
|
||||
}
|
||||
@ -8371,6 +8452,7 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T
|
||||
intermediate.addBuiltInFunctionCall(node->getLoc(), EOpConstructUVec2, false, newSrcNode, type);
|
||||
return newNode;
|
||||
}
|
||||
[[fallthrough]];
|
||||
case EOpConstructUVec3:
|
||||
case EOpConstructUVec4:
|
||||
case EOpConstructUint:
|
||||
@ -8392,6 +8474,7 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T
|
||||
intermediate.addBuiltInFunctionCall(node->getLoc(), EOpPackUint2x32, true, node, type);
|
||||
return newNode;
|
||||
}
|
||||
[[fallthrough]];
|
||||
case EOpConstructDVec2:
|
||||
case EOpConstructDVec3:
|
||||
case EOpConstructDVec4:
|
||||
@ -8544,7 +8627,7 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T
|
||||
TIntermTyped* newNode = intermediate.addBuiltInFunctionCall(node->getLoc(), EOpConvPtrToUint64, true, node, type);
|
||||
return newNode;
|
||||
}
|
||||
// fall through
|
||||
[[fallthrough]];
|
||||
case EOpConstructU64Vec2:
|
||||
case EOpConstructU64Vec3:
|
||||
case EOpConstructU64Vec4:
|
||||
@ -9609,7 +9692,7 @@ void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, con
|
||||
error(loc, "cannot apply to 'out'", TQualifier::getGeometryString(publicType.shaderQualifiers.geometry), "");
|
||||
break;
|
||||
}
|
||||
// Fall through
|
||||
[[fallthrough]];
|
||||
case ElgPoints:
|
||||
case ElgLineStrip:
|
||||
case ElgTriangleStrip:
|
||||
|
@ -633,6 +633,7 @@ bool DeduceVersionProfile(TInfoSink& infoSink, EShLanguage stage, bool versionNo
|
||||
infoSink.info.message(EPrefixError, "#version: mesh/task shaders require es profile with version 320 or above, or non-es profile with version 450 or above");
|
||||
version = profile == EEsProfile ? 320 : 450;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1433,7 +1434,8 @@ int ShCompile(
|
||||
int /*debugOptions*/,
|
||||
int defaultVersion, // use 100 for ES environment, 110 for desktop
|
||||
bool forwardCompatible, // give errors for use of deprecated features
|
||||
EShMessages messages // warnings/errors/AST; things to print out
|
||||
EShMessages messages, // warnings/errors/AST; things to print out,
|
||||
const char *shaderFileName // the filename
|
||||
)
|
||||
{
|
||||
// Map the generic handle to the C++ object
|
||||
@ -1449,6 +1451,9 @@ int ShCompile(
|
||||
|
||||
compiler->infoSink.info.erase();
|
||||
compiler->infoSink.debug.erase();
|
||||
compiler->infoSink.info.setShaderFileName(shaderFileName);
|
||||
compiler->infoSink.debug.setShaderFileName(shaderFileName);
|
||||
|
||||
|
||||
TIntermediate intermediate(compiler->getLanguage());
|
||||
TShader::ForbidIncluder includer;
|
||||
|
@ -149,6 +149,7 @@ void TType::buildMangledName(TString& mangledName) const
|
||||
mangledName += '-';
|
||||
(*structure)[i].type->buildMangledName(mangledName);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
@ -1,7 +1,7 @@
|
||||
//
|
||||
// Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
||||
// Copyright (C) 2012-2013 LunarG, Inc.
|
||||
// Copyright (C) 2017 ARM Limited.
|
||||
// Copyright (C) 2017, 2022-2024 Arm Limited.
|
||||
// Copyright (C) 2015-2020 Google, Inc.
|
||||
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
@ -235,6 +235,7 @@ void TParseVersions::initializeExtensionBehavior()
|
||||
extensionBehavior[E_GL_KHR_shader_subgroup_ballot] = EBhDisable;
|
||||
extensionBehavior[E_GL_KHR_shader_subgroup_shuffle] = EBhDisable;
|
||||
extensionBehavior[E_GL_KHR_shader_subgroup_shuffle_relative] = EBhDisable;
|
||||
extensionBehavior[E_GL_KHR_shader_subgroup_rotate] = EBhDisable;
|
||||
extensionBehavior[E_GL_KHR_shader_subgroup_clustered] = EBhDisable;
|
||||
extensionBehavior[E_GL_KHR_shader_subgroup_quad] = EBhDisable;
|
||||
extensionBehavior[E_GL_KHR_memory_scope_semantics] = EBhDisable;
|
||||
@ -258,14 +259,19 @@ void TParseVersions::initializeExtensionBehavior()
|
||||
extensionBehavior[E_GL_EXT_shader_16bit_storage] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_shader_8bit_storage] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_subgroup_uniform_control_flow] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_maximal_reconvergence] = EBhDisable;
|
||||
|
||||
extensionBehavior[E_GL_EXT_fragment_shader_barycentric] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_expect_assume] = EBhDisable;
|
||||
|
||||
extensionBehavior[E_GL_EXT_control_flow_attributes2] = EBhDisable;
|
||||
|
||||
extensionBehavior[E_GL_KHR_cooperative_matrix] = EBhDisable;
|
||||
|
||||
// #line and #include
|
||||
extensionBehavior[E_GL_GOOGLE_cpp_style_line_directive] = EBhDisable;
|
||||
extensionBehavior[E_GL_GOOGLE_include_directive] = EBhDisable;
|
||||
extensionBehavior[E_GL_ARB_shading_language_include] = EBhDisable;
|
||||
|
||||
extensionBehavior[E_GL_AMD_shader_ballot] = EBhDisable;
|
||||
extensionBehavior[E_GL_AMD_shader_trinary_minmax] = EBhDisable;
|
||||
@ -302,12 +308,14 @@ void TParseVersions::initializeExtensionBehavior()
|
||||
extensionBehavior[E_GL_NV_integer_cooperative_matrix] = EBhDisable;
|
||||
extensionBehavior[E_GL_NV_shader_invocation_reorder] = EBhDisable;
|
||||
extensionBehavior[E_GL_NV_displacement_micromap] = EBhDisable;
|
||||
extensionBehavior[E_GL_NV_shader_atomic_fp16_vector] = EBhDisable;
|
||||
|
||||
// ARM
|
||||
extensionBehavior[E_GL_ARM_shader_core_builtins] = EBhDisable;
|
||||
|
||||
// QCOM
|
||||
extensionBehavior[E_GL_QCOM_image_processing] = EBhDisable;
|
||||
extensionBehavior[E_GL_QCOM_image_processing2] = EBhDisable;
|
||||
|
||||
// AEP
|
||||
extensionBehavior[E_GL_ANDROID_extension_pack_es31a] = EBhDisable;
|
||||
@ -356,6 +364,7 @@ void TParseVersions::initializeExtensionBehavior()
|
||||
extensionBehavior[E_GL_EXT_spirv_intrinsics] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_mesh_shader] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_opacity_micromap] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_shader_quad_control] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_ray_tracing_position_fetch] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_shader_tile_image] = EBhDisable;
|
||||
extensionBehavior[E_GL_EXT_texture_shadow_lod] = EBhDisable;
|
||||
@ -438,6 +447,7 @@ void TParseVersions::getPreamble(std::string& preamble)
|
||||
"#define GL_EXT_shader_non_constant_global_initializers 1\n"
|
||||
|
||||
"#define GL_QCOM_image_processing 1\n"
|
||||
"#define GL_QCOM_image_processing2 1\n"
|
||||
;
|
||||
|
||||
if (version >= 300) {
|
||||
@ -446,6 +456,7 @@ void TParseVersions::getPreamble(std::string& preamble)
|
||||
if (version >= 310) {
|
||||
preamble += "#define GL_EXT_null_initializer 1\n";
|
||||
preamble += "#define GL_EXT_subgroup_uniform_control_flow 1\n";
|
||||
preamble += "#define GL_EXT_maximal_reconvergence 1\n";
|
||||
}
|
||||
|
||||
} else { // !isEsProfile()
|
||||
@ -563,6 +574,7 @@ void TParseVersions::getPreamble(std::string& preamble)
|
||||
"#define GL_NV_shader_invocation_reorder 1\n"
|
||||
|
||||
"#define GL_QCOM_image_processing 1\n"
|
||||
"#define GL_QCOM_image_processing2 1\n"
|
||||
|
||||
"#define GL_EXT_shader_explicit_arithmetic_types 1\n"
|
||||
"#define GL_EXT_shader_explicit_arithmetic_types_int8 1\n"
|
||||
@ -582,7 +594,10 @@ void TParseVersions::getPreamble(std::string& preamble)
|
||||
"#define GL_EXT_shader_atomic_float2 1\n"
|
||||
|
||||
"#define GL_EXT_fragment_shader_barycentric 1\n"
|
||||
"#define GL_EXT_shader_quad_control 1\n"
|
||||
"#define GL_EXT_texture_array 1\n"
|
||||
|
||||
"#define GL_EXT_control_flow_attributes2 1\n"
|
||||
;
|
||||
|
||||
if (spvVersion.spv == 0) {
|
||||
@ -599,6 +614,7 @@ void TParseVersions::getPreamble(std::string& preamble)
|
||||
if (version >= 140) {
|
||||
preamble += "#define GL_EXT_null_initializer 1\n";
|
||||
preamble += "#define GL_EXT_subgroup_uniform_control_flow 1\n";
|
||||
preamble += "#define GL_EXT_maximal_reconvergence 1\n";
|
||||
}
|
||||
if (version >= 130) {
|
||||
preamble +="#define GL_FRAGMENT_PRECISION_HIGH 1\n";
|
||||
@ -758,7 +774,7 @@ void TParseVersions::profileRequires(const TSourceLoc& loc, int profileMask, int
|
||||
switch (getExtensionBehavior(extensions[i])) {
|
||||
case EBhWarn:
|
||||
infoSink.info.message(EPrefixWarning, ("extension " + TString(extensions[i]) + " is being used for " + featureDesc).c_str(), loc);
|
||||
// fall through
|
||||
[[fallthrough]];
|
||||
case EBhRequire:
|
||||
case EBhEnable:
|
||||
okay = true;
|
||||
@ -975,6 +991,8 @@ void TParseVersions::updateExtensionBehavior(int line, const char* extension, co
|
||||
updateExtensionBehavior(line, "GL_OES_shader_io_blocks", behaviorString);
|
||||
else if (strcmp(extension, "GL_GOOGLE_include_directive") == 0)
|
||||
updateExtensionBehavior(line, "GL_GOOGLE_cpp_style_line_directive", behaviorString);
|
||||
else if (strcmp(extension, "GL_ARB_shading_language_include") == 0)
|
||||
updateExtensionBehavior(line, "GL_GOOGLE_cpp_style_line_directive", behaviorString);
|
||||
// subgroup_* to subgroup_basic
|
||||
else if (strcmp(extension, "GL_KHR_shader_subgroup_vote") == 0)
|
||||
updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
|
||||
|
@ -1,7 +1,7 @@
|
||||
//
|
||||
// Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
||||
// Copyright (C) 2012-2013 LunarG, Inc.
|
||||
// Copyright (C) 2017 ARM Limited.
|
||||
// Copyright (C) 2017, 2022-2024 Arm Limited.
|
||||
// Copyright (C) 2015-2018 Google, Inc.
|
||||
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
@ -171,6 +171,7 @@ const char* const E_GL_KHR_shader_subgroup_arithmetic = "GL_KHR_shader_sub
|
||||
const char* const E_GL_KHR_shader_subgroup_ballot = "GL_KHR_shader_subgroup_ballot";
|
||||
const char* const E_GL_KHR_shader_subgroup_shuffle = "GL_KHR_shader_subgroup_shuffle";
|
||||
const char* const E_GL_KHR_shader_subgroup_shuffle_relative = "GL_KHR_shader_subgroup_shuffle_relative";
|
||||
const char* const E_GL_KHR_shader_subgroup_rotate = "GL_KHR_shader_subgroup_rotate";
|
||||
const char* const E_GL_KHR_shader_subgroup_clustered = "GL_KHR_shader_subgroup_clustered";
|
||||
const char* const E_GL_KHR_shader_subgroup_quad = "GL_KHR_shader_subgroup_quad";
|
||||
const char* const E_GL_KHR_memory_scope_semantics = "GL_KHR_memory_scope_semantics";
|
||||
@ -215,8 +216,12 @@ const char* const E_GL_EXT_spirv_intrinsics = "GL_EXT_spirv_intr
|
||||
const char* const E_GL_EXT_fragment_shader_barycentric = "GL_EXT_fragment_shader_barycentric";
|
||||
const char* const E_GL_EXT_mesh_shader = "GL_EXT_mesh_shader";
|
||||
const char* const E_GL_EXT_opacity_micromap = "GL_EXT_opacity_micromap";
|
||||
const char* const E_GL_EXT_shader_quad_control = "GL_EXT_shader_quad_control";
|
||||
const char* const E_GL_EXT_draw_instanced = "GL_EXT_draw_instanced";
|
||||
const char* const E_GL_EXT_texture_array = "GL_EXT_texture_array";
|
||||
const char* const E_GL_EXT_maximal_reconvergence = "GL_EXT_maximal_reconvergence";
|
||||
const char* const E_GL_EXT_expect_assume = "GL_EXT_expect_assume";
|
||||
const char* const E_GL_EXT_control_flow_attributes2 = "GL_EXT_control_flow_attributes2";
|
||||
|
||||
// Arrays of extensions for the above viewportEXTs duplications
|
||||
|
||||
@ -237,6 +242,7 @@ const int Num_OVR_multiview_EXTs = sizeof(OVR_multiview_EXTs) / sizeof(OVR_multi
|
||||
// #line and #include
|
||||
const char* const E_GL_GOOGLE_cpp_style_line_directive = "GL_GOOGLE_cpp_style_line_directive";
|
||||
const char* const E_GL_GOOGLE_include_directive = "GL_GOOGLE_include_directive";
|
||||
const char* const E_GL_ARB_shading_language_include = "GL_ARB_shading_language_include";
|
||||
|
||||
const char* const E_GL_AMD_shader_ballot = "GL_AMD_shader_ballot";
|
||||
const char* const E_GL_AMD_shader_trinary_minmax = "GL_AMD_shader_trinary_minmax";
|
||||
@ -274,6 +280,7 @@ const char* const E_GL_NV_integer_cooperative_matrix = "GL_NV_integer
|
||||
const char* const E_GL_NV_shader_invocation_reorder = "GL_NV_shader_invocation_reorder";
|
||||
const char* const E_GL_EXT_ray_tracing_position_fetch = "GL_EXT_ray_tracing_position_fetch";
|
||||
const char* const E_GL_NV_displacement_micromap = "GL_NV_displacement_micromap";
|
||||
const char* const E_GL_NV_shader_atomic_fp16_vector = "GL_NV_shader_atomic_fp16_vector";
|
||||
|
||||
// ARM
|
||||
const char* const E_GL_ARM_shader_core_builtins = "GL_ARM_shader_core_builtins";
|
||||
@ -285,6 +292,7 @@ const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]);
|
||||
|
||||
|
||||
const char* const E_GL_QCOM_image_processing = "GL_QCOM_image_processing";
|
||||
const char* const E_GL_QCOM_image_processing2 = "GL_QCOM_image_processing2";
|
||||
|
||||
// AEP
|
||||
const char* const E_GL_ANDROID_extension_pack_es31a = "GL_ANDROID_extension_pack_es31a";
|
||||
|
@ -125,6 +125,8 @@ TAttributeType TParseContext::attributeFromName(const TString& name) const
|
||||
return EatSubgroupUniformControlFlow;
|
||||
else if (name == "export")
|
||||
return EatExport;
|
||||
else if (name == "maximally_reconverges")
|
||||
return EatMaximallyReconverges;
|
||||
else
|
||||
return EatNone;
|
||||
}
|
||||
@ -360,6 +362,10 @@ void TParseContext::handleFunctionAttributes(const TSourceLoc& loc, const TAttri
|
||||
requireExtensions(loc, 1, &E_GL_EXT_subgroup_uniform_control_flow, "attribute");
|
||||
intermediate.setSubgroupUniformControlFlow();
|
||||
break;
|
||||
case EatMaximallyReconverges:
|
||||
requireExtensions(loc, 1, &E_GL_EXT_maximal_reconvergence, "attribute");
|
||||
intermediate.setMaximallyReconverges();
|
||||
break;
|
||||
default:
|
||||
warn(loc, "attribute does not apply to a function", "", "");
|
||||
break;
|
||||
|
@ -121,6 +121,7 @@ namespace glslang {
|
||||
EatNonReadable,
|
||||
EatSubgroupUniformControlFlow,
|
||||
EatExport,
|
||||
EatMaximallyReconverges,
|
||||
};
|
||||
|
||||
class TIntermAggregate;
|
||||
|
@ -494,7 +494,7 @@ function_call_header_with_parameters
|
||||
}
|
||||
else
|
||||
{
|
||||
TParameter param = { 0, new TType };
|
||||
TParameter param = { 0, new TType, {} };
|
||||
param.type->shallowCopy($2->getType());
|
||||
|
||||
$1.function->addParameter(param);
|
||||
@ -508,12 +508,15 @@ function_call_header_with_parameters
|
||||
&& $3->getType().containsOpaque())
|
||||
{
|
||||
TIntermNode* remappedNode = parseContext.vkRelaxedRemapFunctionArgument($2.loc, $1.function, $3);
|
||||
$$.intermNode = parseContext.intermediate.mergeAggregate($1.intermNode, remappedNode, $2.loc);
|
||||
if (remappedNode == $3)
|
||||
$$.intermNode = parseContext.intermediate.growAggregate($1.intermNode, $3, $2.loc);
|
||||
else
|
||||
$$.intermNode = parseContext.intermediate.mergeAggregate($1.intermNode, remappedNode, $2.loc);
|
||||
$$.function = $1.function;
|
||||
}
|
||||
else
|
||||
{
|
||||
TParameter param = { 0, new TType };
|
||||
TParameter param = { 0, new TType, {} };
|
||||
param.type->shallowCopy($3->getType());
|
||||
|
||||
$1.function->addParameter(param);
|
||||
@ -964,18 +967,24 @@ function_prototype
|
||||
$$.function = $1;
|
||||
if (parseContext.compileOnly) $$.function->setExport();
|
||||
$$.loc = $2.loc;
|
||||
const char * extensions[2] = { E_GL_EXT_subgroup_uniform_control_flow, E_GL_EXT_maximal_reconvergence };
|
||||
parseContext.requireExtensions($2.loc, 2, extensions, "attribute");
|
||||
parseContext.handleFunctionAttributes($2.loc, *$3);
|
||||
}
|
||||
| attribute function_declarator RIGHT_PAREN {
|
||||
$$.function = $2;
|
||||
if (parseContext.compileOnly) $$.function->setExport();
|
||||
$$.loc = $3.loc;
|
||||
const char * extensions[2] = { E_GL_EXT_subgroup_uniform_control_flow, E_GL_EXT_maximal_reconvergence };
|
||||
parseContext.requireExtensions($3.loc, 2, extensions, "attribute");
|
||||
parseContext.handleFunctionAttributes($3.loc, *$1);
|
||||
}
|
||||
| attribute function_declarator RIGHT_PAREN attribute {
|
||||
$$.function = $2;
|
||||
if (parseContext.compileOnly) $$.function->setExport();
|
||||
$$.loc = $3.loc;
|
||||
const char * extensions[2] = { E_GL_EXT_subgroup_uniform_control_flow, E_GL_EXT_maximal_reconvergence };
|
||||
parseContext.requireExtensions($3.loc, 2, extensions, "attribute");
|
||||
parseContext.handleFunctionAttributes($3.loc, *$1);
|
||||
parseContext.handleFunctionAttributes($3.loc, *$4);
|
||||
}
|
||||
@ -1062,7 +1071,7 @@ parameter_declarator
|
||||
}
|
||||
parseContext.reservedErrorCheck($2.loc, *$2.string);
|
||||
|
||||
TParameter param = {$2.string, new TType($1)};
|
||||
TParameter param = {$2.string, new TType($1), {}};
|
||||
$$.loc = $2.loc;
|
||||
$$.param = param;
|
||||
}
|
||||
@ -1080,7 +1089,7 @@ parameter_declarator
|
||||
parseContext.arraySizeRequiredCheck($3.loc, *$3.arraySizes);
|
||||
parseContext.reservedErrorCheck($2.loc, *$2.string);
|
||||
|
||||
TParameter param = { $2.string, type };
|
||||
TParameter param = { $2.string, type, {} };
|
||||
|
||||
$$.loc = $2.loc;
|
||||
$$.param = param;
|
||||
@ -1133,7 +1142,7 @@ parameter_declaration
|
||||
|
||||
parameter_type_specifier
|
||||
: type_specifier {
|
||||
TParameter param = { 0, new TType($1) };
|
||||
TParameter param = { 0, new TType($1), {} };
|
||||
$$.param = param;
|
||||
if ($1.arraySizes)
|
||||
parseContext.arraySizeRequiredCheck($1.loc, *$1.arraySizes);
|
||||
@ -1750,6 +1759,7 @@ type_parameter_specifier_list
|
||||
: type_specifier {
|
||||
$$ = new TTypeParameters;
|
||||
$$->arraySizes = new TArraySizes;
|
||||
$$->spirvType = $1.spirvType;
|
||||
$$->basicType = $1.basicType;
|
||||
}
|
||||
| unary_expression {
|
||||
@ -3944,7 +3954,8 @@ iteration_statement
|
||||
$$ = $1;
|
||||
}
|
||||
| attribute iteration_statement_nonattributed {
|
||||
parseContext.requireExtensions($2->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute");
|
||||
const char * extensions[2] = { E_GL_EXT_control_flow_attributes, E_GL_EXT_control_flow_attributes2 };
|
||||
parseContext.requireExtensions($2->getLoc(), 2, extensions, "attribute");
|
||||
parseContext.handleLoopAttributes(*$1, $2);
|
||||
$$ = $2;
|
||||
}
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -1,7 +1,7 @@
|
||||
//
|
||||
// Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
||||
// Copyright (C) 2012-2016 LunarG, Inc.
|
||||
// Copyright (C) 2017 ARM Limited.
|
||||
// Copyright (C) 2017, 2022-2024 Arm Limited.
|
||||
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
// All rights reserved.
|
||||
@ -565,6 +565,8 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
|
||||
case EOpSubgroupShuffleXor: out.debug << "subgroupShuffleXor"; break;
|
||||
case EOpSubgroupShuffleUp: out.debug << "subgroupShuffleUp"; break;
|
||||
case EOpSubgroupShuffleDown: out.debug << "subgroupShuffleDown"; break;
|
||||
case EOpSubgroupRotate: out.debug << "subgroupRotate"; break;
|
||||
case EOpSubgroupClusteredRotate: out.debug << "subgroupClusteredRotate"; break;
|
||||
case EOpSubgroupAdd: out.debug << "subgroupAdd"; break;
|
||||
case EOpSubgroupMul: out.debug << "subgroupMul"; break;
|
||||
case EOpSubgroupMin: out.debug << "subgroupMin"; break;
|
||||
@ -597,6 +599,8 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
|
||||
case EOpSubgroupQuadSwapHorizontal: out.debug << "subgroupQuadSwapHorizontal"; break;
|
||||
case EOpSubgroupQuadSwapVertical: out.debug << "subgroupQuadSwapVertical"; break;
|
||||
case EOpSubgroupQuadSwapDiagonal: out.debug << "subgroupQuadSwapDiagonal"; break;
|
||||
case EOpSubgroupQuadAll: out.debug << "subgroupQuadAll"; break;
|
||||
case EOpSubgroupQuadAny: out.debug << "subgroupQuadAny"; break;
|
||||
|
||||
case EOpSubgroupPartition: out.debug << "subgroupPartitionNV"; break;
|
||||
case EOpSubgroupPartitionedAdd: out.debug << "subgroupPartitionedAddNV"; break;
|
||||
@ -1000,6 +1004,8 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
|
||||
case EOpSubgroupShuffleXor: out.debug << "subgroupShuffleXor"; break;
|
||||
case EOpSubgroupShuffleUp: out.debug << "subgroupShuffleUp"; break;
|
||||
case EOpSubgroupShuffleDown: out.debug << "subgroupShuffleDown"; break;
|
||||
case EOpSubgroupRotate: out.debug << "subgroupRotate"; break;
|
||||
case EOpSubgroupClusteredRotate: out.debug << "subgroupClusteredRotate"; break;
|
||||
case EOpSubgroupAdd: out.debug << "subgroupAdd"; break;
|
||||
case EOpSubgroupMul: out.debug << "subgroupMul"; break;
|
||||
case EOpSubgroupMin: out.debug << "subgroupMin"; break;
|
||||
@ -1032,6 +1038,8 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
|
||||
case EOpSubgroupQuadSwapHorizontal: out.debug << "subgroupQuadSwapHorizontal"; break;
|
||||
case EOpSubgroupQuadSwapVertical: out.debug << "subgroupQuadSwapVertical"; break;
|
||||
case EOpSubgroupQuadSwapDiagonal: out.debug << "subgroupQuadSwapDiagonal"; break;
|
||||
case EOpSubgroupQuadAll: out.debug << "subgroupQuadAll"; break;
|
||||
case EOpSubgroupQuadAny: out.debug << "subgroupQuadAny"; break;
|
||||
|
||||
case EOpSubgroupPartition: out.debug << "subgroupPartitionNV"; break;
|
||||
case EOpSubgroupPartitionedAdd: out.debug << "subgroupPartitionedAddNV"; break;
|
||||
@ -1512,6 +1520,9 @@ void TIntermediate::output(TInfoSink& infoSink, bool tree)
|
||||
if (getSubgroupUniformControlFlow())
|
||||
infoSink.debug << "subgroup_uniform_control_flow\n";
|
||||
|
||||
if (getMaximallyReconverges())
|
||||
infoSink.debug << "maximally_reconverges\n";
|
||||
|
||||
switch (language) {
|
||||
case EShLangVertex:
|
||||
break;
|
||||
@ -1576,7 +1587,7 @@ void TIntermediate::output(TInfoSink& infoSink, bool tree)
|
||||
infoSink.debug << "max_vertices = " << vertices << "\n";
|
||||
infoSink.debug << "max_primitives = " << primitives << "\n";
|
||||
infoSink.debug << "output primitive = " << TQualifier::getGeometryString(outputPrimitive) << "\n";
|
||||
// Fall through
|
||||
[[fallthrough]];
|
||||
case EShLangTask:
|
||||
// Fall through
|
||||
case EShLangCompute:
|
||||
|
@ -85,7 +85,7 @@ public:
|
||||
addGlobalReference(base->getAccessName());
|
||||
|
||||
if (target) {
|
||||
TVarEntryInfo ent = {base->getId(), base, ! traverseAll};
|
||||
TVarEntryInfo ent = {base->getId(), base, ! traverseAll, {}, {}, {}, {}, {}, {}, {}};
|
||||
ent.stage = intermediate.getStage();
|
||||
TVarLiveMap::iterator at = target->find(
|
||||
ent.symbol->getAccessName()); // std::lower_bound(target->begin(), target->end(), ent, TVarEntryInfo::TOrderById());
|
||||
@ -124,7 +124,7 @@ public:
|
||||
else
|
||||
return;
|
||||
|
||||
TVarEntryInfo ent = { base->getId() };
|
||||
TVarEntryInfo ent = { base->getId(), {}, {}, {}, {}, {}, {}, {}, {}, {} };
|
||||
// Fix a defect, when block has no instance name, we need to find its block name
|
||||
TVarLiveMap::const_iterator at = source->find(base->getAccessName());
|
||||
if (at == source->end())
|
||||
|
@ -1350,7 +1350,7 @@ void TIntermediate::finalCheck(TInfoSink& infoSink, bool keepUncalled)
|
||||
error(infoSink, "At least one shader must specify a layout(max_vertices = value)");
|
||||
if (primitives == TQualifier::layoutNotSet)
|
||||
error(infoSink, "At least one shader must specify a layout(max_primitives = value)");
|
||||
// fall through
|
||||
[[fallthrough]];
|
||||
case EShLangTask:
|
||||
if (numTaskNVBlocks > 1)
|
||||
error(infoSink, "Only one taskNV interface block is allowed per shader");
|
||||
@ -1689,7 +1689,7 @@ int TIntermediate::addUsedLocation(const TQualifier& qualifier, const TType& typ
|
||||
// First range:
|
||||
TRange locationRange(qualifier.layoutLocation, qualifier.layoutLocation);
|
||||
TRange componentRange(0, 3);
|
||||
TIoRange range(locationRange, componentRange, type.getBasicType(), 0);
|
||||
TIoRange range(locationRange, componentRange, type.getBasicType(), 0, qualifier.centroid, qualifier.smooth, qualifier.flat);
|
||||
|
||||
// check for collisions
|
||||
collision = checkLocationRange(set, range, type, typeCollision);
|
||||
@ -1699,7 +1699,7 @@ int TIntermediate::addUsedLocation(const TQualifier& qualifier, const TType& typ
|
||||
// Second range:
|
||||
TRange locationRange2(qualifier.layoutLocation + 1, qualifier.layoutLocation + 1);
|
||||
TRange componentRange2(0, 1);
|
||||
TIoRange range2(locationRange2, componentRange2, type.getBasicType(), 0);
|
||||
TIoRange range2(locationRange2, componentRange2, type.getBasicType(), 0, qualifier.centroid, qualifier.smooth, qualifier.flat);
|
||||
|
||||
// check for collisions
|
||||
collision = checkLocationRange(set, range2, type, typeCollision);
|
||||
@ -1725,7 +1725,7 @@ int TIntermediate::addUsedLocation(const TQualifier& qualifier, const TType& typ
|
||||
TBasicType basicTy = type.getBasicType();
|
||||
if (basicTy == EbtSampler && type.getSampler().isAttachmentEXT())
|
||||
basicTy = type.getSampler().type;
|
||||
TIoRange range(locationRange, componentRange, basicTy, qualifier.hasIndex() ? qualifier.getIndex() : 0);
|
||||
TIoRange range(locationRange, componentRange, basicTy, qualifier.hasIndex() ? qualifier.getIndex() : 0, qualifier.centroid, qualifier.smooth, qualifier.flat);
|
||||
|
||||
// check for collisions, except for vertex inputs on desktop targeting OpenGL
|
||||
if (! (!isEsProfile() && language == EShLangVertex && qualifier.isPipeInput()) || spvVersion.vulkan > 0)
|
||||
@ -1748,7 +1748,11 @@ int TIntermediate::checkLocationRange(int set, const TIoRange& range, const TTyp
|
||||
if (range.overlap(usedIo[set][r])) {
|
||||
// there is a collision; pick one
|
||||
return std::max(range.location.start, usedIo[set][r].location.start);
|
||||
} else if (range.location.overlap(usedIo[set][r].location) && type.getBasicType() != usedIo[set][r].basicType) {
|
||||
} else if (range.location.overlap(usedIo[set][r].location) &&
|
||||
(type.getBasicType() != usedIo[set][r].basicType ||
|
||||
type.getQualifier().centroid != usedIo[set][r].centroid ||
|
||||
type.getQualifier().smooth != usedIo[set][r].smooth ||
|
||||
type.getQualifier().flat != usedIo[set][r].flat)) {
|
||||
// aliased-type mismatch
|
||||
typeCollision = true;
|
||||
return std::max(range.location.start, usedIo[set][r].location.start);
|
||||
@ -2217,9 +2221,9 @@ int TIntermediate::getBaseAlignment(const TType& type, int& size, int& stride, T
|
||||
}
|
||||
|
||||
// To aid the basic HLSL rule about crossing vec4 boundaries.
|
||||
bool TIntermediate::improperStraddle(const TType& type, int size, int offset)
|
||||
bool TIntermediate::improperStraddle(const TType& type, int size, int offset, bool vectorLike)
|
||||
{
|
||||
if (! type.isVector() || type.isArray())
|
||||
if (! vectorLike || type.isArray())
|
||||
return false;
|
||||
|
||||
return size <= 16 ? offset / 16 != (offset + size - 1) / 16
|
||||
|
@ -123,8 +123,10 @@ struct TRange {
|
||||
// within the same location range, component range, and index value. Locations don't alias unless
|
||||
// all other dimensions of their range overlap.
|
||||
struct TIoRange {
|
||||
TIoRange(TRange location, TRange component, TBasicType basicType, int index)
|
||||
: location(location), component(component), basicType(basicType), index(index) { }
|
||||
TIoRange(TRange location, TRange component, TBasicType basicType, int index, bool centroid, bool smooth, bool flat)
|
||||
: location(location), component(component), basicType(basicType), index(index), centroid(centroid), smooth(smooth), flat(flat)
|
||||
{
|
||||
}
|
||||
bool overlap(const TIoRange& rhs) const
|
||||
{
|
||||
return location.overlap(rhs.location) && component.overlap(rhs.component) && index == rhs.index;
|
||||
@ -133,6 +135,9 @@ struct TIoRange {
|
||||
TRange component;
|
||||
TBasicType basicType;
|
||||
int index;
|
||||
bool centroid;
|
||||
bool smooth;
|
||||
bool flat;
|
||||
};
|
||||
|
||||
// An offset range is a 2-D rectangle; the set of (binding, offset) pairs all lying
|
||||
@ -345,10 +350,12 @@ public:
|
||||
needToLegalize(false),
|
||||
binaryDoubleOutput(false),
|
||||
subgroupUniformControlFlow(false),
|
||||
maximallyReconverges(false),
|
||||
usePhysicalStorageBuffer(false),
|
||||
spirvRequirement(nullptr),
|
||||
spirvExecutionMode(nullptr),
|
||||
uniformLocationBase(0)
|
||||
uniformLocationBase(0),
|
||||
quadDerivMode(false), reqFullQuadsMode(false)
|
||||
{
|
||||
localSize[0] = 1;
|
||||
localSize[1] = 1;
|
||||
@ -857,6 +864,10 @@ public:
|
||||
|
||||
void setXfbMode() { xfbMode = true; }
|
||||
bool getXfbMode() const { return xfbMode; }
|
||||
void setQuadDerivMode(bool mode = true) { quadDerivMode = mode; }
|
||||
bool getQuadDerivMode() const { return quadDerivMode; }
|
||||
void setReqFullQuadsMode(bool mode = true) { reqFullQuadsMode = mode; }
|
||||
bool getReqFullQuadsMode() const { return reqFullQuadsMode; }
|
||||
void setMultiStream() { multiStream = true; }
|
||||
bool isMultiStream() const { return multiStream; }
|
||||
bool setOutputPrimitive(TLayoutGeometry p)
|
||||
@ -963,6 +974,9 @@ public:
|
||||
void setSubgroupUniformControlFlow() { subgroupUniformControlFlow = true; }
|
||||
bool getSubgroupUniformControlFlow() const { return subgroupUniformControlFlow; }
|
||||
|
||||
void setMaximallyReconverges() { maximallyReconverges = true; }
|
||||
bool getMaximallyReconverges() const { return maximallyReconverges; }
|
||||
|
||||
// GL_EXT_spirv_intrinsics
|
||||
void insertSpirvRequirement(const TSpirvRequirement* spirvReq);
|
||||
bool hasSpirvRequirement() const { return spirvRequirement != nullptr; }
|
||||
@ -1048,7 +1062,7 @@ public:
|
||||
static int getBaseAlignment(const TType&, int& size, int& stride, TLayoutPacking layoutPacking, bool rowMajor);
|
||||
static int getScalarAlignment(const TType&, int& size, int& stride, bool rowMajor);
|
||||
static int getMemberAlignment(const TType&, int& size, int& stride, TLayoutPacking layoutPacking, bool rowMajor);
|
||||
static bool improperStraddle(const TType& type, int size, int offset);
|
||||
static bool improperStraddle(const TType& type, int size, int offset, bool vectorLike);
|
||||
static void updateOffset(const TType& parentType, const TType& memberType, int& offset, int& memberSize);
|
||||
static int getOffset(const TType& type, int index);
|
||||
static int getBlockSize(const TType& blockType);
|
||||
@ -1226,6 +1240,7 @@ protected:
|
||||
bool needToLegalize;
|
||||
bool binaryDoubleOutput;
|
||||
bool subgroupUniformControlFlow;
|
||||
bool maximallyReconverges;
|
||||
bool usePhysicalStorageBuffer;
|
||||
|
||||
TSpirvRequirement* spirvRequirement;
|
||||
@ -1234,12 +1249,14 @@ protected:
|
||||
std::map<TString, AstRefType> bindlessImageModeCaller;
|
||||
std::unordered_map<std::string, int> uniformLocationOverrides;
|
||||
int uniformLocationBase;
|
||||
bool quadDerivMode;
|
||||
bool reqFullQuadsMode;
|
||||
TNumericFeatures numericFeatures;
|
||||
std::unordered_map<std::string, TBlockStorageClass> blockBackingOverrides;
|
||||
|
||||
std::unordered_set<int> usedConstantId; // specialization constant ids used
|
||||
std::vector<TOffsetRange> usedAtomics; // sets of bindings used by atomic counters
|
||||
std::vector<TIoRange> usedIo[4]; // sets of used locations, one for each of in, out, uniform, and buffers
|
||||
std::vector<TIoRange> usedIo[5]; // sets of used locations, one for each of in, out, uniform, and buffers
|
||||
std::vector<TRange> usedIoRT[4]; // sets of used location, one for rayPayload/rayPayloadIN,
|
||||
// one for callableData/callableDataIn, one for hitObjectAttributeNV and
|
||||
// one for shaderrecordhitobjectNV
|
||||
|
@ -83,6 +83,11 @@ public:
|
||||
const char* featureDesc);
|
||||
virtual void ppRequireExtensions(const TSourceLoc&, int numExtensions, const char* const extensions[],
|
||||
const char* featureDesc);
|
||||
template<typename Container>
|
||||
constexpr void ppRequireExtensions(const TSourceLoc& loc, Container extensions, const char* featureDesc) {
|
||||
ppRequireExtensions(loc, static_cast<int>(extensions.size()), extensions.data(), featureDesc);
|
||||
}
|
||||
|
||||
virtual TExtensionBehavior getExtensionBehavior(const char*);
|
||||
virtual bool extensionTurnedOn(const char* const extension);
|
||||
virtual bool extensionsTurnedOn(int numExtensions, const char* const extensions[]);
|
||||
|
@ -973,7 +973,8 @@ int TPpContext::readCPPline(TPpToken* ppToken)
|
||||
break;
|
||||
case PpAtomInclude:
|
||||
if(!parseContext.isReadingHLSL()) {
|
||||
parseContext.ppRequireExtensions(ppToken->loc, 1, &E_GL_GOOGLE_include_directive, "#include");
|
||||
const std::array exts = { E_GL_GOOGLE_include_directive, E_GL_ARB_shading_language_include };
|
||||
parseContext.ppRequireExtensions(ppToken->loc, exts, "#include");
|
||||
}
|
||||
token = CPPinclude(ppToken);
|
||||
break;
|
||||
|
@ -220,7 +220,9 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken)
|
||||
}
|
||||
if (ch >= '0' && ch <= '9') {
|
||||
while (ch >= '0' && ch <= '9') {
|
||||
exponent = exponent * 10 + (ch - '0');
|
||||
if (exponent < 500) {
|
||||
exponent = exponent * 10 + (ch - '0');
|
||||
}
|
||||
saveName(ch);
|
||||
ch = getChar();
|
||||
}
|
||||
|
@ -704,69 +704,73 @@ public:
|
||||
case EbtFloat:
|
||||
switch ((int)sampler.dim) {
|
||||
case Esd1D:
|
||||
switch ((int)sampler.shadow) {
|
||||
case false: return sampler.arrayed ? GL_SAMPLER_1D_ARRAY : GL_SAMPLER_1D;
|
||||
case true: return sampler.arrayed ? GL_SAMPLER_1D_ARRAY_SHADOW : GL_SAMPLER_1D_SHADOW;
|
||||
}
|
||||
if (sampler.shadow)
|
||||
return sampler.arrayed ? GL_SAMPLER_1D_ARRAY_SHADOW : GL_SAMPLER_1D_SHADOW;
|
||||
else
|
||||
return sampler.arrayed ? GL_SAMPLER_1D_ARRAY : GL_SAMPLER_1D;
|
||||
case Esd2D:
|
||||
switch ((int)sampler.ms) {
|
||||
case false:
|
||||
switch ((int)sampler.shadow) {
|
||||
case false: return sampler.arrayed ? GL_SAMPLER_2D_ARRAY : GL_SAMPLER_2D;
|
||||
case true: return sampler.arrayed ? GL_SAMPLER_2D_ARRAY_SHADOW : GL_SAMPLER_2D_SHADOW;
|
||||
}
|
||||
case true: return sampler.arrayed ? GL_SAMPLER_2D_MULTISAMPLE_ARRAY : GL_SAMPLER_2D_MULTISAMPLE;
|
||||
if (sampler.ms) {
|
||||
return sampler.arrayed ? GL_SAMPLER_2D_MULTISAMPLE_ARRAY : GL_SAMPLER_2D_MULTISAMPLE;
|
||||
} else {
|
||||
if (sampler.shadow)
|
||||
return sampler.arrayed ? GL_SAMPLER_2D_ARRAY_SHADOW : GL_SAMPLER_2D_SHADOW;
|
||||
else
|
||||
return sampler.arrayed ? GL_SAMPLER_2D_ARRAY : GL_SAMPLER_2D;
|
||||
}
|
||||
case Esd3D:
|
||||
return GL_SAMPLER_3D;
|
||||
case EsdCube:
|
||||
switch ((int)sampler.shadow) {
|
||||
case false: return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY : GL_SAMPLER_CUBE;
|
||||
case true: return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW : GL_SAMPLER_CUBE_SHADOW;
|
||||
}
|
||||
if (sampler.shadow)
|
||||
return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW : GL_SAMPLER_CUBE_SHADOW;
|
||||
else
|
||||
return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY : GL_SAMPLER_CUBE;
|
||||
case EsdRect:
|
||||
return sampler.shadow ? GL_SAMPLER_2D_RECT_SHADOW : GL_SAMPLER_2D_RECT;
|
||||
case EsdBuffer:
|
||||
return GL_SAMPLER_BUFFER;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
case EbtFloat16:
|
||||
switch ((int)sampler.dim) {
|
||||
case Esd1D:
|
||||
switch ((int)sampler.shadow) {
|
||||
case false: return sampler.arrayed ? GL_FLOAT16_SAMPLER_1D_ARRAY_AMD : GL_FLOAT16_SAMPLER_1D_AMD;
|
||||
case true: return sampler.arrayed ? GL_FLOAT16_SAMPLER_1D_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_1D_SHADOW_AMD;
|
||||
}
|
||||
if (sampler.shadow)
|
||||
return sampler.arrayed ? GL_FLOAT16_SAMPLER_1D_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_1D_SHADOW_AMD;
|
||||
else
|
||||
return sampler.arrayed ? GL_FLOAT16_SAMPLER_1D_ARRAY_AMD : GL_FLOAT16_SAMPLER_1D_AMD;
|
||||
case Esd2D:
|
||||
switch ((int)sampler.ms) {
|
||||
case false:
|
||||
switch ((int)sampler.shadow) {
|
||||
case false: return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_ARRAY_AMD : GL_FLOAT16_SAMPLER_2D_AMD;
|
||||
case true: return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_2D_SHADOW_AMD;
|
||||
}
|
||||
case true: return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_ARRAY_AMD : GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_AMD;
|
||||
if (sampler.ms) {
|
||||
return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_ARRAY_AMD : GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_AMD;
|
||||
} else {
|
||||
if (sampler.shadow)
|
||||
return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_2D_SHADOW_AMD;
|
||||
else
|
||||
return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_ARRAY_AMD : GL_FLOAT16_SAMPLER_2D_AMD;
|
||||
}
|
||||
case Esd3D:
|
||||
return GL_FLOAT16_SAMPLER_3D_AMD;
|
||||
case EsdCube:
|
||||
switch ((int)sampler.shadow) {
|
||||
case false: return sampler.arrayed ? GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_AMD : GL_FLOAT16_SAMPLER_CUBE_AMD;
|
||||
case true: return sampler.arrayed ? GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_CUBE_SHADOW_AMD;
|
||||
}
|
||||
if (sampler.shadow)
|
||||
return sampler.arrayed ? GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_CUBE_SHADOW_AMD;
|
||||
else
|
||||
return sampler.arrayed ? GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_AMD : GL_FLOAT16_SAMPLER_CUBE_AMD;
|
||||
case EsdRect:
|
||||
return sampler.shadow ? GL_FLOAT16_SAMPLER_2D_RECT_SHADOW_AMD : GL_FLOAT16_SAMPLER_2D_RECT_AMD;
|
||||
case EsdBuffer:
|
||||
return GL_FLOAT16_SAMPLER_BUFFER_AMD;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
case EbtInt:
|
||||
switch ((int)sampler.dim) {
|
||||
case Esd1D:
|
||||
return sampler.arrayed ? GL_INT_SAMPLER_1D_ARRAY : GL_INT_SAMPLER_1D;
|
||||
case Esd2D:
|
||||
switch ((int)sampler.ms) {
|
||||
case false: return sampler.arrayed ? GL_INT_SAMPLER_2D_ARRAY : GL_INT_SAMPLER_2D;
|
||||
case true: return sampler.arrayed ? GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
|
||||
: GL_INT_SAMPLER_2D_MULTISAMPLE;
|
||||
}
|
||||
if (sampler.ms)
|
||||
return sampler.arrayed ? GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
|
||||
: GL_INT_SAMPLER_2D_MULTISAMPLE;
|
||||
else
|
||||
return sampler.arrayed ? GL_INT_SAMPLER_2D_ARRAY : GL_INT_SAMPLER_2D;
|
||||
case Esd3D:
|
||||
return GL_INT_SAMPLER_3D;
|
||||
case EsdCube:
|
||||
@ -775,17 +779,19 @@ public:
|
||||
return GL_INT_SAMPLER_2D_RECT;
|
||||
case EsdBuffer:
|
||||
return GL_INT_SAMPLER_BUFFER;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
case EbtUint:
|
||||
switch ((int)sampler.dim) {
|
||||
case Esd1D:
|
||||
return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_1D_ARRAY : GL_UNSIGNED_INT_SAMPLER_1D;
|
||||
case Esd2D:
|
||||
switch ((int)sampler.ms) {
|
||||
case false: return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_ARRAY : GL_UNSIGNED_INT_SAMPLER_2D;
|
||||
case true: return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
|
||||
: GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE;
|
||||
}
|
||||
if (sampler.ms)
|
||||
return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
|
||||
: GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE;
|
||||
else
|
||||
return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_ARRAY : GL_UNSIGNED_INT_SAMPLER_2D;
|
||||
case Esd3D:
|
||||
return GL_UNSIGNED_INT_SAMPLER_3D;
|
||||
case EsdCube:
|
||||
@ -794,6 +800,8 @@ public:
|
||||
return GL_UNSIGNED_INT_SAMPLER_2D_RECT;
|
||||
case EsdBuffer:
|
||||
return GL_UNSIGNED_INT_SAMPLER_BUFFER;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
default:
|
||||
return 0;
|
||||
@ -806,10 +814,10 @@ public:
|
||||
case Esd1D:
|
||||
return sampler.arrayed ? GL_IMAGE_1D_ARRAY : GL_IMAGE_1D;
|
||||
case Esd2D:
|
||||
switch ((int)sampler.ms) {
|
||||
case false: return sampler.arrayed ? GL_IMAGE_2D_ARRAY : GL_IMAGE_2D;
|
||||
case true: return sampler.arrayed ? GL_IMAGE_2D_MULTISAMPLE_ARRAY : GL_IMAGE_2D_MULTISAMPLE;
|
||||
}
|
||||
if (sampler.ms)
|
||||
return sampler.arrayed ? GL_IMAGE_2D_MULTISAMPLE_ARRAY : GL_IMAGE_2D_MULTISAMPLE;
|
||||
else
|
||||
return sampler.arrayed ? GL_IMAGE_2D_ARRAY : GL_IMAGE_2D;
|
||||
case Esd3D:
|
||||
return GL_IMAGE_3D;
|
||||
case EsdCube:
|
||||
@ -818,16 +826,18 @@ public:
|
||||
return GL_IMAGE_2D_RECT;
|
||||
case EsdBuffer:
|
||||
return GL_IMAGE_BUFFER;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
case EbtFloat16:
|
||||
switch ((int)sampler.dim) {
|
||||
case Esd1D:
|
||||
return sampler.arrayed ? GL_FLOAT16_IMAGE_1D_ARRAY_AMD : GL_FLOAT16_IMAGE_1D_AMD;
|
||||
case Esd2D:
|
||||
switch ((int)sampler.ms) {
|
||||
case false: return sampler.arrayed ? GL_FLOAT16_IMAGE_2D_ARRAY_AMD : GL_FLOAT16_IMAGE_2D_AMD;
|
||||
case true: return sampler.arrayed ? GL_FLOAT16_IMAGE_2D_MULTISAMPLE_ARRAY_AMD : GL_FLOAT16_IMAGE_2D_MULTISAMPLE_AMD;
|
||||
}
|
||||
if (sampler.ms)
|
||||
return sampler.arrayed ? GL_FLOAT16_IMAGE_2D_MULTISAMPLE_ARRAY_AMD : GL_FLOAT16_IMAGE_2D_MULTISAMPLE_AMD;
|
||||
else
|
||||
return sampler.arrayed ? GL_FLOAT16_IMAGE_2D_ARRAY_AMD : GL_FLOAT16_IMAGE_2D_AMD;
|
||||
case Esd3D:
|
||||
return GL_FLOAT16_IMAGE_3D_AMD;
|
||||
case EsdCube:
|
||||
@ -836,16 +846,18 @@ public:
|
||||
return GL_FLOAT16_IMAGE_2D_RECT_AMD;
|
||||
case EsdBuffer:
|
||||
return GL_FLOAT16_IMAGE_BUFFER_AMD;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
case EbtInt:
|
||||
switch ((int)sampler.dim) {
|
||||
case Esd1D:
|
||||
return sampler.arrayed ? GL_INT_IMAGE_1D_ARRAY : GL_INT_IMAGE_1D;
|
||||
case Esd2D:
|
||||
switch ((int)sampler.ms) {
|
||||
case false: return sampler.arrayed ? GL_INT_IMAGE_2D_ARRAY : GL_INT_IMAGE_2D;
|
||||
case true: return sampler.arrayed ? GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY : GL_INT_IMAGE_2D_MULTISAMPLE;
|
||||
}
|
||||
if (sampler.ms)
|
||||
return sampler.arrayed ? GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY : GL_INT_IMAGE_2D_MULTISAMPLE;
|
||||
else
|
||||
return sampler.arrayed ? GL_INT_IMAGE_2D_ARRAY : GL_INT_IMAGE_2D;
|
||||
case Esd3D:
|
||||
return GL_INT_IMAGE_3D;
|
||||
case EsdCube:
|
||||
@ -854,17 +866,19 @@ public:
|
||||
return GL_INT_IMAGE_2D_RECT;
|
||||
case EsdBuffer:
|
||||
return GL_INT_IMAGE_BUFFER;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
case EbtUint:
|
||||
switch ((int)sampler.dim) {
|
||||
case Esd1D:
|
||||
return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_1D_ARRAY : GL_UNSIGNED_INT_IMAGE_1D;
|
||||
case Esd2D:
|
||||
switch ((int)sampler.ms) {
|
||||
case false: return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_ARRAY : GL_UNSIGNED_INT_IMAGE_2D;
|
||||
case true: return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY
|
||||
: GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE;
|
||||
}
|
||||
if (sampler.ms)
|
||||
return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY
|
||||
: GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE;
|
||||
else
|
||||
return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_ARRAY : GL_UNSIGNED_INT_IMAGE_2D;
|
||||
case Esd3D:
|
||||
return GL_UNSIGNED_INT_IMAGE_3D;
|
||||
case EsdCube:
|
||||
@ -873,6 +887,8 @@ public:
|
||||
return GL_UNSIGNED_INT_IMAGE_2D_RECT;
|
||||
case EsdBuffer:
|
||||
return GL_UNSIGNED_INT_IMAGE_BUFFER;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
default:
|
||||
return 0;
|
||||
@ -937,6 +953,7 @@ public:
|
||||
case 4: return GL_FLOAT_MAT4;
|
||||
default: return 0;
|
||||
}
|
||||
default: return 0;
|
||||
}
|
||||
case EbtDouble:
|
||||
switch (type.getMatrixCols()) {
|
||||
@ -961,6 +978,7 @@ public:
|
||||
case 4: return GL_DOUBLE_MAT4;
|
||||
default: return 0;
|
||||
}
|
||||
default: return 0;
|
||||
}
|
||||
case EbtFloat16:
|
||||
switch (type.getMatrixCols()) {
|
||||
@ -985,6 +1003,7 @@ public:
|
||||
case 4: return GL_FLOAT16_MAT4_AMD;
|
||||
default: return 0;
|
||||
}
|
||||
default: return 0;
|
||||
}
|
||||
default:
|
||||
return 0;
|
||||
|
92
thirdparty/glslang/glslang/MachineIndependent/span.h
vendored
Normal file
92
thirdparty/glslang/glslang/MachineIndependent/span.h
vendored
Normal file
@ -0,0 +1,92 @@
|
||||
#pragma once
|
||||
|
||||
//
|
||||
// Copyright (C) 2023 LunarG, Inc.
|
||||
//
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions
|
||||
// are met:
|
||||
//
|
||||
// Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
//
|
||||
// Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
//
|
||||
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
|
||||
// Partial implementation of std::span for C++11
|
||||
// Replace with std::span if repo standard is bumped to C++20
|
||||
//
|
||||
// This code was copied from https://github.com/KhronosGroup/Vulkan-ValidationLayers/blob/main/layers/containers/custom_containers.h
|
||||
template <typename T>
|
||||
class span {
|
||||
public:
|
||||
using pointer = T *;
|
||||
using const_pointer = T const *;
|
||||
using iterator = pointer;
|
||||
using const_iterator = const_pointer;
|
||||
|
||||
span() = default;
|
||||
span(pointer start, size_t n) : data_(start), count_(n) {}
|
||||
template <typename Iterator>
|
||||
span(Iterator start, Iterator end) : data_(&(*start)), count_(end - start) {}
|
||||
template <typename Container>
|
||||
span(Container &c) : data_(c.data()), count_(c.size()) {}
|
||||
|
||||
iterator begin() { return data_; }
|
||||
const_iterator begin() const { return data_; }
|
||||
|
||||
iterator end() { return data_ + count_; }
|
||||
const_iterator end() const { return data_ + count_; }
|
||||
|
||||
T &operator[](int i) { return data_[i]; }
|
||||
const T &operator[](int i) const { return data_[i]; }
|
||||
|
||||
T &front() { return *data_; }
|
||||
const T &front() const { return *data_; }
|
||||
|
||||
T &back() { return *(data_ + (count_ - 1)); }
|
||||
const T &back() const { return *(data_ + (count_ - 1)); }
|
||||
|
||||
size_t size() const { return count_; }
|
||||
bool empty() const { return count_ == 0; }
|
||||
|
||||
pointer data() { return data_; }
|
||||
const_pointer data() const { return data_; }
|
||||
|
||||
private:
|
||||
pointer data_ = {};
|
||||
size_t count_ = 0;
|
||||
};
|
||||
|
||||
//
|
||||
// Allow type inference that using the constructor doesn't allow in C++11
|
||||
template <typename T>
|
||||
span<T> make_span(T *begin, size_t count) {
|
||||
return span<T>(begin, count);
|
||||
}
|
||||
template <typename T>
|
||||
span<T> make_span(T *begin, T *end) {
|
||||
return make_span<T>(begin, end);
|
||||
}
|
@ -1,74 +0,0 @@
|
||||
//
|
||||
// Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions
|
||||
// are met:
|
||||
//
|
||||
// Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
//
|
||||
// Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
//
|
||||
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
|
||||
#include "InitializeDll.h"
|
||||
|
||||
#define STRICT
|
||||
#define VC_EXTRALEAN 1
|
||||
#include <windows.h>
|
||||
#include <assert.h>
|
||||
|
||||
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
|
||||
{
|
||||
switch (fdwReason)
|
||||
{
|
||||
case DLL_PROCESS_ATTACH:
|
||||
|
||||
if (! glslang::InitProcess())
|
||||
return FALSE;
|
||||
break;
|
||||
case DLL_THREAD_ATTACH:
|
||||
|
||||
if (! glslang::InitThread())
|
||||
return FALSE;
|
||||
break;
|
||||
|
||||
case DLL_THREAD_DETACH:
|
||||
|
||||
if (! glslang::DetachThread())
|
||||
return FALSE;
|
||||
break;
|
||||
|
||||
case DLL_PROCESS_DETACH:
|
||||
|
||||
glslang::DetachProcess();
|
||||
break;
|
||||
|
||||
default:
|
||||
assert(0 && "DllMain(): Reason for calling DLL Main is unknown");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
38
thirdparty/glslang/glslang/Public/ShaderLang.h
vendored
38
thirdparty/glslang/glslang/Public/ShaderLang.h
vendored
@ -252,23 +252,24 @@ typedef enum {
|
||||
// Message choices for what errors and warnings are given.
|
||||
//
|
||||
enum EShMessages : unsigned {
|
||||
EShMsgDefault = 0, // default is to give all required errors and extra warnings
|
||||
EShMsgRelaxedErrors = (1 << 0), // be liberal in accepting input
|
||||
EShMsgSuppressWarnings = (1 << 1), // suppress all warnings, except those required by the specification
|
||||
EShMsgAST = (1 << 2), // print the AST intermediate representation
|
||||
EShMsgSpvRules = (1 << 3), // issue messages for SPIR-V generation
|
||||
EShMsgVulkanRules = (1 << 4), // issue messages for Vulkan-requirements of GLSL for SPIR-V
|
||||
EShMsgOnlyPreprocessor = (1 << 5), // only print out errors produced by the preprocessor
|
||||
EShMsgReadHlsl = (1 << 6), // use HLSL parsing rules and semantics
|
||||
EShMsgCascadingErrors = (1 << 7), // get cascading errors; risks error-recovery issues, instead of an early exit
|
||||
EShMsgKeepUncalled = (1 << 8), // for testing, don't eliminate uncalled functions
|
||||
EShMsgHlslOffsets = (1 << 9), // allow block offsets to follow HLSL rules instead of GLSL rules
|
||||
EShMsgDebugInfo = (1 << 10), // save debug information
|
||||
EShMsgHlslEnable16BitTypes = (1 << 11), // enable use of 16-bit types in SPIR-V for HLSL
|
||||
EShMsgHlslLegalization = (1 << 12), // enable HLSL Legalization messages
|
||||
EShMsgHlslDX9Compatible = (1 << 13), // enable HLSL DX9 compatible mode (for samplers and semantics)
|
||||
EShMsgBuiltinSymbolTable = (1 << 14), // print the builtin symbol table
|
||||
EShMsgEnhanced = (1 << 15), // enhanced message readability
|
||||
EShMsgDefault = 0, // default is to give all required errors and extra warnings
|
||||
EShMsgRelaxedErrors = (1 << 0), // be liberal in accepting input
|
||||
EShMsgSuppressWarnings = (1 << 1), // suppress all warnings, except those required by the specification
|
||||
EShMsgAST = (1 << 2), // print the AST intermediate representation
|
||||
EShMsgSpvRules = (1 << 3), // issue messages for SPIR-V generation
|
||||
EShMsgVulkanRules = (1 << 4), // issue messages for Vulkan-requirements of GLSL for SPIR-V
|
||||
EShMsgOnlyPreprocessor = (1 << 5), // only print out errors produced by the preprocessor
|
||||
EShMsgReadHlsl = (1 << 6), // use HLSL parsing rules and semantics
|
||||
EShMsgCascadingErrors = (1 << 7), // get cascading errors; risks error-recovery issues, instead of an early exit
|
||||
EShMsgKeepUncalled = (1 << 8), // for testing, don't eliminate uncalled functions
|
||||
EShMsgHlslOffsets = (1 << 9), // allow block offsets to follow HLSL rules instead of GLSL rules
|
||||
EShMsgDebugInfo = (1 << 10), // save debug information
|
||||
EShMsgHlslEnable16BitTypes = (1 << 11), // enable use of 16-bit types in SPIR-V for HLSL
|
||||
EShMsgHlslLegalization = (1 << 12), // enable HLSL Legalization messages
|
||||
EShMsgHlslDX9Compatible = (1 << 13), // enable HLSL DX9 compatible mode (for samplers and semantics)
|
||||
EShMsgBuiltinSymbolTable = (1 << 14), // print the builtin symbol table
|
||||
EShMsgEnhanced = (1 << 15), // enhanced message readability
|
||||
EShMsgAbsolutePath = (1 << 16), // Output Absolute path for messages
|
||||
LAST_ELEMENT_MARKER(EShMsgCount),
|
||||
};
|
||||
|
||||
@ -335,7 +336,8 @@ GLSLANG_EXPORT int ShCompile(const ShHandle, const char* const shaderStrings[],
|
||||
int, // debugOptions unused
|
||||
int defaultVersion = 110, // use 100 for ES environment, overridden by #version in shader
|
||||
bool forwardCompatible = false, // give errors for use of deprecated features
|
||||
EShMessages messages = EShMsgDefault // warnings and errors
|
||||
EShMessages messages = EShMsgDefault, // warnings and errors
|
||||
const char* fileName = nullptr
|
||||
);
|
||||
|
||||
GLSLANG_EXPORT int ShLinkExt(
|
||||
|
2
thirdparty/glslang/glslang/build_info.h
vendored
2
thirdparty/glslang/glslang/build_info.h
vendored
@ -35,7 +35,7 @@
|
||||
#define GLSLANG_BUILD_INFO
|
||||
|
||||
#define GLSLANG_VERSION_MAJOR 14
|
||||
#define GLSLANG_VERSION_MINOR 0
|
||||
#define GLSLANG_VERSION_MINOR 2
|
||||
#define GLSLANG_VERSION_PATCH 0
|
||||
#define GLSLANG_VERSION_FLAVOR ""
|
||||
|
||||
|
24
thirdparty/glslang/glslang/patches/disable-absolute-paths-for-apple-compat.patch
vendored
Normal file
24
thirdparty/glslang/glslang/patches/disable-absolute-paths-for-apple-compat.patch
vendored
Normal file
@ -0,0 +1,24 @@
|
||||
diff --git a/thirdparty/glslang/glslang/Include/InfoSink.h b/thirdparty/glslang/glslang/Include/InfoSink.h
|
||||
index 23f495dcb7..b1b537df54 100644
|
||||
--- a/thirdparty/glslang/glslang/Include/InfoSink.h
|
||||
+++ b/thirdparty/glslang/glslang/Include/InfoSink.h
|
||||
@@ -101,14 +101,14 @@ public:
|
||||
snprintf(locText, maxSize, ":%d", loc.line);
|
||||
|
||||
if(loc.getFilename() == nullptr && shaderFileName != nullptr && absolute) {
|
||||
- append(std::filesystem::absolute(shaderFileName).string());
|
||||
+ //append(std::filesystem::absolute(shaderFileName).string());
|
||||
} else {
|
||||
std::string location = loc.getStringNameOrNum(false);
|
||||
- if (absolute) {
|
||||
- append(std::filesystem::absolute(location).string());
|
||||
- } else {
|
||||
+ //if (absolute) {
|
||||
+ // append(std::filesystem::absolute(location).string());
|
||||
+ //} else {
|
||||
append(location);
|
||||
- }
|
||||
+ //}
|
||||
}
|
||||
|
||||
append(locText);
|
@ -1,217 +1,84 @@
|
||||
diff --git a/thirdparty/spirv-reflect/spirv_reflect.c b/thirdparty/spirv-reflect/spirv_reflect.c
|
||||
index 3b9d6bfecc..e97d1b0438 100644
|
||||
index b4f6bc17c2..c96dd85439 100644
|
||||
--- a/thirdparty/spirv-reflect/spirv_reflect.c
|
||||
+++ b/thirdparty/spirv-reflect/spirv_reflect.c
|
||||
@@ -122,6 +122,9 @@ typedef struct SpvReflectPrvDecorations {
|
||||
SpvReflectPrvNumberDecoration component;
|
||||
SpvReflectPrvNumberDecoration offset;
|
||||
SpvReflectPrvNumberDecoration uav_counter_buffer;
|
||||
+// -- GODOT begin --
|
||||
+ SpvReflectPrvNumberDecoration specialization_constant;
|
||||
+// -- GODOT end --
|
||||
SpvReflectPrvStringDecoration semantic;
|
||||
uint32_t array_stride;
|
||||
uint32_t matrix_stride;
|
||||
@@ -708,6 +711,9 @@ static SpvReflectResult ParseNodes(SpvReflectPrvParser* p_parser) {
|
||||
p_parser->nodes[i].decorations.offset.value = (uint32_t)INVALID_VALUE;
|
||||
p_parser->nodes[i].decorations.uav_counter_buffer.value = (uint32_t)INVALID_VALUE;
|
||||
p_parser->nodes[i].decorations.built_in = (SpvBuiltIn)INVALID_VALUE;
|
||||
+// -- GODOT begin --
|
||||
+ p_parser->nodes[i].decorations.specialization_constant.value = (SpvBuiltIn)INVALID_VALUE;
|
||||
+// -- GODOT end --
|
||||
}
|
||||
// Mark source file id node
|
||||
p_parser->source_file_id = (uint32_t)INVALID_VALUE;
|
||||
@@ -907,7 +913,13 @@ static SpvReflectResult ParseNodes(SpvReflectPrvParser* p_parser) {
|
||||
|
||||
case SpvOpSpecConstantTrue:
|
||||
case SpvOpSpecConstantFalse:
|
||||
- case SpvOpSpecConstant:
|
||||
+// -- GODOT begin --
|
||||
+ case SpvOpSpecConstant: {
|
||||
+ CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
|
||||
+ CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
|
||||
+ p_node->is_type = true;
|
||||
+ } break;
|
||||
+// -- GODOT end --
|
||||
case SpvOpSpecConstantComposite:
|
||||
case SpvOpSpecConstantOp: {
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
|
||||
@@ -1385,6 +1397,9 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser) {
|
||||
default: {
|
||||
skip = true;
|
||||
} break;
|
||||
+// -- GODOT begin --
|
||||
+ case SpvDecorationSpecId:
|
||||
+// -- GODOT end --
|
||||
case SpvDecorationRelaxedPrecision:
|
||||
case SpvDecorationBlock:
|
||||
case SpvDecorationBufferBlock:
|
||||
@@ -1542,6 +1557,14 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser) {
|
||||
p_target_decorations->input_attachment_index.word_offset = word_offset;
|
||||
@@ -1571,6 +1571,10 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser, SpvRefle
|
||||
} break;
|
||||
|
||||
case SpvDecorationSpecId: {
|
||||
+// -- GODOT begin --
|
||||
+ case SpvDecorationSpecId: {
|
||||
+ uint32_t word_offset = p_node->word_offset + member_offset+ 3;
|
||||
+ CHECKED_READU32(p_parser, word_offset, p_target_decorations->specialization_constant.value);
|
||||
+ p_target_decorations->specialization_constant.word_offset = word_offset;
|
||||
+ } break;
|
||||
+ CHECKED_READU32(p_parser, word_offset, p_target_decorations->spec_id);
|
||||
+// -- GODOT end --
|
||||
+
|
||||
case SpvReflectDecorationHlslCounterBufferGOOGLE: {
|
||||
uint32_t word_offset = p_node->word_offset + member_offset + 3;
|
||||
CHECKED_READU32(p_parser, word_offset, p_target_decorations->uav_counter_buffer.value);
|
||||
@@ -1851,6 +1874,13 @@ static SpvReflectResult ParseType(SpvReflectPrvParser* p_parser, SpvReflectPrvNo
|
||||
case SpvOpTypeAccelerationStructureKHR: {
|
||||
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_ACCELERATION_STRUCTURE;
|
||||
spec_constant_count++;
|
||||
} break;
|
||||
+
|
||||
+// -- GODOT begin --
|
||||
+ case SpvOpSpecConstantTrue:
|
||||
+ case SpvOpSpecConstantFalse:
|
||||
+ case SpvOpSpecConstant: {
|
||||
+ } break;
|
||||
+// -- GODOT end --
|
||||
}
|
||||
|
||||
if (result == SPV_REFLECT_RESULT_SUCCESS) {
|
||||
@@ -3522,6 +3552,68 @@ static SpvReflectResult ParseExecutionModes(SpvReflectPrvParser* p_parser, SpvRe
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -1692,21 +1696,45 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser, SpvRefle
|
||||
}
|
||||
for (uint32_t i = 0; i < p_parser->node_count; ++i) {
|
||||
SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
|
||||
- if (p_node->op == SpvOpDecorate) {
|
||||
- uint32_t decoration = (uint32_t)INVALID_VALUE;
|
||||
- CHECKED_READU32(p_parser, p_node->word_offset + 2, decoration);
|
||||
- if (decoration == SpvDecorationSpecId) {
|
||||
- const uint32_t count = p_module->spec_constant_count;
|
||||
- CHECKED_READU32(p_parser, p_node->word_offset + 1, p_module->spec_constants[count].spirv_id);
|
||||
- CHECKED_READU32(p_parser, p_node->word_offset + 3, p_module->spec_constants[count].constant_id);
|
||||
- // If being used for a OpSpecConstantComposite (ex. LocalSizeId), there won't be a name
|
||||
- SpvReflectPrvNode* target_node = FindNode(p_parser, p_module->spec_constants[count].spirv_id);
|
||||
- if (IsNotNull(target_node)) {
|
||||
- p_module->spec_constants[count].name = target_node->name;
|
||||
+// -- GODOT begin --
|
||||
+static SpvReflectResult ParseSpecializationConstants(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
|
||||
+ p_module->specialization_constant_count = 0;
|
||||
+ p_module->specialization_constants = NULL;
|
||||
+ for (size_t i = 0; i < p_parser->node_count; ++i) {
|
||||
+ SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
|
||||
+ if (p_node->op == SpvOpSpecConstantTrue || p_node->op == SpvOpSpecConstantFalse || p_node->op == SpvOpSpecConstant) {
|
||||
+ p_module->specialization_constant_count++;
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ if (p_module->specialization_constant_count == 0) {
|
||||
+ return SPV_REFLECT_RESULT_SUCCESS;
|
||||
+ }
|
||||
+
|
||||
+ p_module->specialization_constants = (SpvReflectSpecializationConstant*)calloc(p_module->specialization_constant_count, sizeof(SpvReflectSpecializationConstant));
|
||||
+
|
||||
+ uint32_t index = 0;
|
||||
+
|
||||
+ for (size_t i = 0; i < p_parser->node_count; ++i) {
|
||||
+ SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
|
||||
+ const uint32_t count = p_module->spec_constant_count;
|
||||
+ switch(p_node->op) {
|
||||
+ default: continue;
|
||||
+ case SpvOpSpecConstantTrue: {
|
||||
+ p_module->specialization_constants[index].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL;
|
||||
+ p_module->specialization_constants[index].default_value.int_bool_value = 1;
|
||||
+ p_module->spec_constants[count].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL;
|
||||
+ p_module->spec_constants[count].default_value.int_bool_value = 1;
|
||||
+ } break;
|
||||
+ case SpvOpSpecConstantFalse: {
|
||||
+ p_module->specialization_constants[index].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL;
|
||||
+ p_module->specialization_constants[index].default_value.int_bool_value = 0;
|
||||
+ p_module->spec_constants[count].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL;
|
||||
+ p_module->spec_constants[count].default_value.int_bool_value = 0;
|
||||
+ } break;
|
||||
+ case SpvOpSpecConstant: {
|
||||
+ SpvReflectResult result = SPV_REFLECT_RESULT_SUCCESS;
|
||||
+ uint32_t element_type_id = (uint32_t)INVALID_VALUE;
|
||||
+ uint32_t default_value = 0;
|
||||
+ IF_READU32(result, p_parser, p_node->word_offset + 1, element_type_id);
|
||||
+ IF_READU32(result, p_parser, p_node->word_offset + 3, default_value);
|
||||
+ CHECKED_READU32(p_parser, p_node->word_offset + 1, element_type_id);
|
||||
+ CHECKED_READU32(p_parser, p_node->word_offset + 3, default_value);
|
||||
+
|
||||
+ SpvReflectPrvNode* p_next_node = FindNode(p_parser, element_type_id);
|
||||
+
|
||||
+ if (p_next_node->op == SpvOpTypeInt) {
|
||||
+ p_module->specialization_constants[index].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_INT;
|
||||
+ p_module->spec_constants[count].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_INT;
|
||||
+ } else if (p_next_node->op == SpvOpTypeFloat) {
|
||||
+ p_module->specialization_constants[index].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_FLOAT;
|
||||
+ p_module->spec_constants[count].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_FLOAT;
|
||||
+ } else {
|
||||
+ return SPV_REFLECT_RESULT_ERROR_PARSE_FAILED;
|
||||
+ }
|
||||
}
|
||||
- p_module->spec_constant_count++;
|
||||
- }
|
||||
+
|
||||
+ p_module->specialization_constants[index].default_value.int_bool_value = default_value; //bits are the same for int and float
|
||||
+ p_module->spec_constants[count].default_value.int_bool_value = default_value; //bits are the same for int and float
|
||||
+ } break;
|
||||
+ }
|
||||
}
|
||||
+
|
||||
+ p_module->specialization_constants[index].name = p_node->name;
|
||||
+ p_module->specialization_constants[index].constant_id = p_node->decorations.specialization_constant.value;
|
||||
+ p_module->specialization_constants[index].spirv_id = p_node->result_id;
|
||||
+ index++;
|
||||
+ }
|
||||
+ p_module->spec_constants[count].name = p_node->name;
|
||||
+ p_module->spec_constants[count].constant_id = p_node->decorations.spec_id;
|
||||
+ p_module->spec_constants[count].spirv_id = p_node->result_id;
|
||||
+
|
||||
+ return SPV_REFLECT_RESULT_SUCCESS;
|
||||
+}
|
||||
+ p_module->spec_constant_count++;
|
||||
+// -- GODOT end --
|
||||
+
|
||||
static SpvReflectResult ParsePushConstantBlocks(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
|
||||
for (size_t i = 0; i < p_parser->node_count; ++i) {
|
||||
SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
|
||||
@@ -3908,6 +4000,12 @@ static SpvReflectResult CreateShaderModule(uint32_t flags, size_t size, const vo
|
||||
result = ParsePushConstantBlocks(&parser, p_module);
|
||||
SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
|
||||
}
|
||||
+// -- GODOT begin --
|
||||
+ if (result == SPV_REFLECT_RESULT_SUCCESS) {
|
||||
+ result = ParseSpecializationConstants(&parser, p_module);
|
||||
+ SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
|
||||
+ }
|
||||
+// -- GODOT end --
|
||||
if (result == SPV_REFLECT_RESULT_SUCCESS) {
|
||||
result = ParseEntryPoints(&parser, p_module);
|
||||
SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
|
||||
@@ -4056,6 +4154,9 @@ void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module) {
|
||||
}
|
||||
SafeFree(p_module->capabilities);
|
||||
SafeFree(p_module->entry_points);
|
||||
+// -- GODOT begin --
|
||||
+ SafeFree(p_module->specialization_constants);
|
||||
+// -- GODOT end --
|
||||
|
||||
// Push constants
|
||||
for (size_t i = 0; i < p_module->push_constant_block_count; ++i) {
|
||||
@@ -4283,6 +4384,36 @@ SpvReflectResult spvReflectEnumerateEntryPointInterfaceVariables(const SpvReflec
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
+// -- GODOT begin --
|
||||
+SpvReflectResult spvReflectEnumerateSpecializationConstants(
|
||||
+ const SpvReflectShaderModule* p_module,
|
||||
+ uint32_t* p_count,
|
||||
+ SpvReflectSpecializationConstant** pp_constants
|
||||
+) {
|
||||
+ if (IsNull(p_module)) {
|
||||
+ return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
|
||||
+ }
|
||||
+ if (IsNull(p_count)) {
|
||||
+ return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
|
||||
+ }
|
||||
+
|
||||
+ if (IsNotNull(pp_constants)) {
|
||||
+ if (*p_count != p_module->specialization_constant_count) {
|
||||
+ return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
|
||||
+ }
|
||||
+
|
||||
+ for (uint32_t index = 0; index < *p_count; ++index) {
|
||||
+ SpvReflectSpecializationConstant *p_const = &p_module->specialization_constants[index];
|
||||
+ pp_constants[index] = p_const;
|
||||
+ }
|
||||
+ } else {
|
||||
+ *p_count = p_module->specialization_constant_count;
|
||||
+ }
|
||||
+
|
||||
+ return SPV_REFLECT_RESULT_SUCCESS;
|
||||
+}
|
||||
+// -- GODOT end --
|
||||
+
|
||||
SpvReflectResult spvReflectEnumerateInputVariables(const SpvReflectShaderModule* p_module, uint32_t* p_count,
|
||||
SpvReflectInterfaceVariable** pp_variables) {
|
||||
if (IsNull(p_module)) {
|
||||
diff --git a/thirdparty/spirv-reflect/spirv_reflect.h b/thirdparty/spirv-reflect/spirv_reflect.h
|
||||
index 08550e8f02..24446f1c1b 100644
|
||||
index 9a42f14eed..4ea0319c5e 100644
|
||||
--- a/thirdparty/spirv-reflect/spirv_reflect.h
|
||||
+++ b/thirdparty/spirv-reflect/spirv_reflect.h
|
||||
@@ -374,6 +374,30 @@ typedef struct SpvReflectTypeDescription {
|
||||
struct SpvReflectTypeDescription* members;
|
||||
} SpvReflectTypeDescription;
|
||||
@@ -568,6 +568,17 @@ typedef struct SpvReflectCapability {
|
||||
} SpvReflectCapability;
|
||||
|
||||
|
||||
+// -- GODOT begin --
|
||||
+/*! @enum SpvReflectSpecializationConstantType
|
||||
@ -222,65 +89,22 @@ index 08550e8f02..24446f1c1b 100644
|
||||
+ SPV_REFLECT_SPECIALIZATION_CONSTANT_INT = 1,
|
||||
+ SPV_REFLECT_SPECIALIZATION_CONSTANT_FLOAT = 2,
|
||||
+} SpvReflectSpecializationConstantType;
|
||||
+// -- GODOT end --
|
||||
+
|
||||
+/*! @struct SpvReflectSpecializationConstant
|
||||
+
|
||||
+*/
|
||||
+typedef struct SpvReflectSpecializationConstant {
|
||||
+ const char* name;
|
||||
+ uint32_t spirv_id;
|
||||
+ uint32_t constant_id;
|
||||
/*! @struct SpvReflectSpecId
|
||||
|
||||
*/
|
||||
@@ -575,6 +586,13 @@ typedef struct SpvReflectSpecializationConstant {
|
||||
uint32_t spirv_id;
|
||||
uint32_t constant_id;
|
||||
const char* name;
|
||||
+// -- GODOT begin --
|
||||
+ SpvReflectSpecializationConstantType constant_type;
|
||||
+ union {
|
||||
+ float float_value;
|
||||
+ uint32_t int_bool_value;
|
||||
+ } default_value;
|
||||
+} SpvReflectSpecializationConstant;
|
||||
+// -- GODOT end --
|
||||
} SpvReflectSpecializationConstant;
|
||||
|
||||
/*! @struct SpvReflectInterfaceVariable
|
||||
@brief The OpVariable that is either an Input or Output to the module
|
||||
@@ -549,6 +573,10 @@ typedef struct SpvReflectShaderModule {
|
||||
SpvReflectInterfaceVariable* interface_variables; // Uses value(s) from first entry point
|
||||
uint32_t push_constant_block_count; // Uses value(s) from first entry point
|
||||
SpvReflectBlockVariable* push_constant_blocks; // Uses value(s) from first entry point
|
||||
+// -- GODOT begin --
|
||||
+ uint32_t specialization_constant_count;
|
||||
+ SpvReflectSpecializationConstant* specialization_constants;
|
||||
+// -- GODOT end --
|
||||
|
||||
struct Internal {
|
||||
SpvReflectModuleFlags module_flags;
|
||||
@@ -821,6 +849,32 @@ SpvReflectResult spvReflectEnumerateInputVariables(
|
||||
SpvReflectInterfaceVariable** pp_variables
|
||||
);
|
||||
|
||||
+// -- GOODT begin --
|
||||
+/*! @fn spvReflectEnumerateSpecializationConstants
|
||||
+ @brief If the module contains multiple entry points, this will only get
|
||||
+ the specialization constants for the first one.
|
||||
+ @param p_module Pointer to an instance of SpvReflectShaderModule.
|
||||
+ @param p_count If pp_constants is NULL, the module's specialization constant
|
||||
+ count will be stored here.
|
||||
+ If pp_variables is not NULL, *p_count must contain
|
||||
+ the module's specialization constant count.
|
||||
+ @param pp_variables If NULL, the module's specialization constant count will be
|
||||
+ written to *p_count.
|
||||
+ If non-NULL, pp_constants must point to an array with
|
||||
+ *p_count entries, where pointers to the module's
|
||||
+ specialization constants will be written. The caller must not
|
||||
+ free the specialization constants written to this array.
|
||||
+ @return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
|
||||
+ Otherwise, the error code indicates the cause of the
|
||||
+ failure.
|
||||
+*/
|
||||
+SpvReflectResult spvReflectEnumerateSpecializationConstants(
|
||||
+ const SpvReflectShaderModule* p_module,
|
||||
+ uint32_t* p_count,
|
||||
+ SpvReflectSpecializationConstant** pp_constants
|
||||
+);
|
||||
+// -- GODOT end --
|
||||
+
|
||||
/*! @fn spvReflectEnumerateEntryPointInputVariables
|
||||
@brief Enumerate the input variables for a given entry point.
|
||||
@param entry_point The name of the entry point to get the input variables for.
|
||||
/*! @struct SpvReflectShaderModule
|
||||
|
676
thirdparty/spirv-reflect/spirv_reflect.c
vendored
676
thirdparty/spirv-reflect/spirv_reflect.c
vendored
@ -28,7 +28,7 @@
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#if defined(__clang__) || defined(__GNUC__) || defined(__APPLE_CC__)
|
||||
#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 7) || defined(__APPLE_CC__)
|
||||
#define FALLTHROUGH __attribute__((fallthrough))
|
||||
#else
|
||||
#define FALLTHROUGH
|
||||
@ -40,16 +40,7 @@
|
||||
#define SPV_REFLECT_ASSERT(COND)
|
||||
#endif
|
||||
|
||||
// Temporary enums until these make it into SPIR-V/Vulkan
|
||||
// clang-format off
|
||||
enum {
|
||||
SpvReflectOpDecorateId = 332,
|
||||
SpvReflectOpDecorateStringGOOGLE = 5632,
|
||||
SpvReflectOpMemberDecorateStringGOOGLE = 5633,
|
||||
SpvReflectDecorationHlslCounterBufferGOOGLE = 5634,
|
||||
SpvReflectDecorationHlslSemanticGOOGLE = 5635,
|
||||
};
|
||||
|
||||
enum {
|
||||
SPIRV_STARTING_WORD_INDEX = 5,
|
||||
SPIRV_WORD_SIZE = sizeof(uint32_t),
|
||||
@ -115,6 +106,7 @@ typedef struct SpvReflectPrvDecorations {
|
||||
bool is_per_task;
|
||||
bool is_weight_texture;
|
||||
bool is_block_match_texture;
|
||||
SpvReflectUserType user_type;
|
||||
SpvReflectPrvNumberDecoration set;
|
||||
SpvReflectPrvNumberDecoration binding;
|
||||
SpvReflectPrvNumberDecoration input_attachment_index;
|
||||
@ -122,12 +114,10 @@ typedef struct SpvReflectPrvDecorations {
|
||||
SpvReflectPrvNumberDecoration component;
|
||||
SpvReflectPrvNumberDecoration offset;
|
||||
SpvReflectPrvNumberDecoration uav_counter_buffer;
|
||||
// -- GODOT begin --
|
||||
SpvReflectPrvNumberDecoration specialization_constant;
|
||||
// -- GODOT end --
|
||||
SpvReflectPrvStringDecoration semantic;
|
||||
uint32_t array_stride;
|
||||
uint32_t matrix_stride;
|
||||
uint32_t spec_id;
|
||||
SpvBuiltIn built_in;
|
||||
} SpvReflectPrvDecorations;
|
||||
|
||||
@ -167,6 +157,7 @@ typedef struct SpvReflectPrvString {
|
||||
// OpAtomicIAdd -> OpAccessChain -> OpVariable
|
||||
// OpAtomicLoad -> OpImageTexelPointer -> OpVariable
|
||||
typedef struct SpvReflectPrvAccessedVariable {
|
||||
SpvReflectPrvNode* p_node;
|
||||
uint32_t result_id;
|
||||
uint32_t variable_ptr;
|
||||
} SpvReflectPrvAccessedVariable;
|
||||
@ -509,7 +500,8 @@ static void ApplyArrayTraits(const SpvReflectTypeDescription* p_type, SpvReflect
|
||||
}
|
||||
|
||||
static bool IsSpecConstant(const SpvReflectPrvNode* p_node) {
|
||||
return (p_node->op == SpvOpSpecConstant || p_node->op == SpvOpSpecConstantOp);
|
||||
return (p_node->op == SpvOpSpecConstant || p_node->op == SpvOpSpecConstantOp || p_node->op == SpvOpSpecConstantTrue ||
|
||||
p_node->op == SpvOpSpecConstantFalse);
|
||||
}
|
||||
|
||||
static SpvReflectPrvNode* FindNode(SpvReflectPrvParser* p_parser, uint32_t result_id) {
|
||||
@ -537,8 +529,8 @@ static SpvReflectTypeDescription* FindType(SpvReflectShaderModule* p_module, uin
|
||||
}
|
||||
|
||||
static SpvReflectPrvAccessChain* FindAccessChain(SpvReflectPrvParser* p_parser, uint32_t id) {
|
||||
uint32_t ac_cnt = p_parser->access_chain_count;
|
||||
for (uint32_t i = 0; i < ac_cnt; i++) {
|
||||
const uint32_t ac_count = p_parser->access_chain_count;
|
||||
for (uint32_t i = 0; i < ac_count; i++) {
|
||||
if (p_parser->access_chains[i].result_id == id) {
|
||||
return &p_parser->access_chains[i];
|
||||
}
|
||||
@ -546,8 +538,10 @@ static SpvReflectPrvAccessChain* FindAccessChain(SpvReflectPrvParser* p_parser,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint32_t FindBaseId(SpvReflectPrvParser* p_parser, SpvReflectPrvAccessChain* ac) {
|
||||
uint32_t base_id = ac->base_id;
|
||||
// Access Chains mostly have their Base ID pointed directly to a OpVariable, but sometimes
|
||||
// it will be through a load and this funciton handles the edge cases how to find that
|
||||
static uint32_t FindAccessChainBaseVariable(SpvReflectPrvParser* p_parser, SpvReflectPrvAccessChain* p_access_chain) {
|
||||
uint32_t base_id = p_access_chain->base_id;
|
||||
SpvReflectPrvNode* base_node = FindNode(p_parser, base_id);
|
||||
// TODO - This is just a band-aid to fix crashes.
|
||||
// Need to understand why here and hopefully remove
|
||||
@ -563,6 +557,10 @@ static uint32_t FindBaseId(SpvReflectPrvParser* p_parser, SpvReflectPrvAccessCha
|
||||
case SpvOpFunctionParameter: {
|
||||
UNCHECKED_READU32(p_parser, base_node->word_offset + 2, base_id);
|
||||
} break;
|
||||
case SpvOpBitcast:
|
||||
// This can be caused by something like GL_EXT_buffer_reference_uvec2 trying to load a pointer.
|
||||
// We currently call from a push constant, so no way to have a reference loop back into the PC block
|
||||
return 0;
|
||||
default: {
|
||||
assert(false);
|
||||
} break;
|
||||
@ -581,8 +579,8 @@ static uint32_t FindBaseId(SpvReflectPrvParser* p_parser, SpvReflectPrvAccessCha
|
||||
return base_id;
|
||||
}
|
||||
|
||||
static SpvReflectBlockVariable* GetRefBlkVar(SpvReflectPrvParser* p_parser, SpvReflectPrvAccessChain* ac) {
|
||||
uint32_t base_id = ac->base_id;
|
||||
static SpvReflectBlockVariable* GetRefBlkVar(SpvReflectPrvParser* p_parser, SpvReflectPrvAccessChain* p_access_chain) {
|
||||
uint32_t base_id = p_access_chain->base_id;
|
||||
SpvReflectPrvNode* base_node = FindNode(p_parser, base_id);
|
||||
assert(base_node->op == SpvOpLoad);
|
||||
UNCHECKED_READU32(p_parser, base_node->word_offset + 3, base_id);
|
||||
@ -710,10 +708,8 @@ static SpvReflectResult ParseNodes(SpvReflectPrvParser* p_parser) {
|
||||
p_parser->nodes[i].decorations.component.value = (uint32_t)INVALID_VALUE;
|
||||
p_parser->nodes[i].decorations.offset.value = (uint32_t)INVALID_VALUE;
|
||||
p_parser->nodes[i].decorations.uav_counter_buffer.value = (uint32_t)INVALID_VALUE;
|
||||
p_parser->nodes[i].decorations.spec_id = (uint32_t)INVALID_VALUE;
|
||||
p_parser->nodes[i].decorations.built_in = (SpvBuiltIn)INVALID_VALUE;
|
||||
// -- GODOT begin --
|
||||
p_parser->nodes[i].decorations.specialization_constant.value = (SpvBuiltIn)INVALID_VALUE;
|
||||
// -- GODOT end --
|
||||
}
|
||||
// Mark source file id node
|
||||
p_parser->source_file_id = (uint32_t)INVALID_VALUE;
|
||||
@ -913,13 +909,7 @@ static SpvReflectResult ParseNodes(SpvReflectPrvParser* p_parser) {
|
||||
|
||||
case SpvOpSpecConstantTrue:
|
||||
case SpvOpSpecConstantFalse:
|
||||
// -- GODOT begin --
|
||||
case SpvOpSpecConstant: {
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
|
||||
p_node->is_type = true;
|
||||
} break;
|
||||
// -- GODOT end --
|
||||
case SpvOpSpecConstant:
|
||||
case SpvOpSpecConstantComposite:
|
||||
case SpvOpSpecConstantOp: {
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
|
||||
@ -960,7 +950,8 @@ static SpvReflectResult ParseNodes(SpvReflectPrvParser* p_parser) {
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + SPIRV_ACCESS_CHAIN_INDEX_OFFSET + index_index, index_id);
|
||||
// Find OpConstant node that contains index value
|
||||
SpvReflectPrvNode* p_index_value_node = FindNode(p_parser, index_id);
|
||||
if ((p_index_value_node != NULL) && (p_index_value_node->op == SpvOpConstant)) {
|
||||
if ((p_index_value_node != NULL) &&
|
||||
(p_index_value_node->op == SpvOpConstant || p_index_value_node->op == SpvOpSpecConstant)) {
|
||||
// Read index value
|
||||
uint32_t index_value = UINT32_MAX;
|
||||
CHECKED_READU32(p_parser, p_index_value_node->word_offset + 3, index_value);
|
||||
@ -997,6 +988,15 @@ static SpvReflectResult ParseNodes(SpvReflectPrvParser* p_parser) {
|
||||
case SpvOpFunctionParameter: {
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
|
||||
} break;
|
||||
case SpvOpBitcast:
|
||||
case SpvOpShiftRightLogical:
|
||||
case SpvOpIAdd:
|
||||
case SpvOpISub:
|
||||
case SpvOpIMul:
|
||||
case SpvOpUDiv:
|
||||
case SpvOpSDiv: {
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
|
||||
} break;
|
||||
}
|
||||
|
||||
if (p_node->is_type) {
|
||||
@ -1168,6 +1168,7 @@ static SpvReflectResult ParseFunction(SpvReflectPrvParser* p_parser, SpvReflectP
|
||||
const uint32_t ptr_index = p_node->word_offset + 3;
|
||||
SpvReflectPrvAccessedVariable* access_ptr = &p_func->accessed_variables[p_func->accessed_variable_count];
|
||||
|
||||
access_ptr->p_node = p_node;
|
||||
// Need to track Result ID as not sure there has been any memory access through here yet
|
||||
CHECKED_READU32(p_parser, result_index, access_ptr->result_id);
|
||||
CHECKED_READU32(p_parser, ptr_index, access_ptr->variable_ptr);
|
||||
@ -1176,11 +1177,12 @@ static SpvReflectResult ParseFunction(SpvReflectPrvParser* p_parser, SpvReflectP
|
||||
case SpvOpStore: {
|
||||
const uint32_t result_index = p_node->word_offset + 2;
|
||||
CHECKED_READU32(p_parser, result_index, p_func->accessed_variables[p_func->accessed_variable_count].variable_ptr);
|
||||
p_func->accessed_variables[p_func->accessed_variable_count].p_node = p_node;
|
||||
(++p_func->accessed_variable_count);
|
||||
} break;
|
||||
case SpvOpCopyMemory:
|
||||
case SpvOpCopyMemorySized: {
|
||||
// There is no result_id is being zero is same as being invalid
|
||||
// There is no result_id or node, being zero is same as being invalid
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 1,
|
||||
p_func->accessed_variables[p_func->accessed_variable_count].variable_ptr);
|
||||
(++p_func->accessed_variable_count);
|
||||
@ -1369,14 +1371,26 @@ static SpvReflectResult ParseNames(SpvReflectPrvParser* p_parser) {
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser) {
|
||||
// Returns true if user_type matches pattern or if user_type begins with pattern and the next character is ':'
|
||||
// For example, UserTypeMatches("rwbuffer", "rwbuffer") will be true, UserTypeMatches("rwbuffer", "rwbuffer:<S>") will be true, and
|
||||
// UserTypeMatches("rwbuffer", "rwbufferfoo") will be false.
|
||||
static bool UserTypeMatches(const char* user_type, const char* pattern) {
|
||||
const size_t pattern_length = strlen(pattern);
|
||||
if (strncmp(user_type, pattern, pattern_length) == 0) {
|
||||
if (user_type[pattern_length] == ':' || user_type[pattern_length] == '\0') {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
|
||||
uint32_t spec_constant_count = 0;
|
||||
for (uint32_t i = 0; i < p_parser->node_count; ++i) {
|
||||
SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
|
||||
|
||||
if (((uint32_t)p_node->op != (uint32_t)SpvOpDecorate) && ((uint32_t)p_node->op != (uint32_t)SpvOpMemberDecorate) &&
|
||||
((uint32_t)p_node->op != (uint32_t)SpvReflectOpDecorateId) &&
|
||||
((uint32_t)p_node->op != (uint32_t)SpvReflectOpDecorateStringGOOGLE) &&
|
||||
((uint32_t)p_node->op != (uint32_t)SpvReflectOpMemberDecorateStringGOOGLE)) {
|
||||
if ((p_node->op != SpvOpDecorate) && (p_node->op != SpvOpMemberDecorate) && (p_node->op != SpvOpDecorateId) &&
|
||||
(p_node->op != SpvOpDecorateString) && (p_node->op != SpvOpMemberDecorateString)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -1397,9 +1411,6 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser) {
|
||||
default: {
|
||||
skip = true;
|
||||
} break;
|
||||
// -- GODOT begin --
|
||||
case SpvDecorationSpecId:
|
||||
// -- GODOT end --
|
||||
case SpvDecorationRelaxedPrecision:
|
||||
case SpvDecorationBlock:
|
||||
case SpvDecorationBufferBlock:
|
||||
@ -1421,10 +1432,12 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser) {
|
||||
case SpvDecorationDescriptorSet:
|
||||
case SpvDecorationOffset:
|
||||
case SpvDecorationInputAttachmentIndex:
|
||||
case SpvDecorationSpecId:
|
||||
case SpvDecorationWeightTextureQCOM:
|
||||
case SpvDecorationBlockMatchTextureQCOM:
|
||||
case SpvReflectDecorationHlslCounterBufferGOOGLE:
|
||||
case SpvReflectDecorationHlslSemanticGOOGLE: {
|
||||
case SpvDecorationUserTypeGOOGLE:
|
||||
case SpvDecorationHlslCounterBufferGOOGLE:
|
||||
case SpvDecorationHlslSemanticGOOGLE: {
|
||||
skip = false;
|
||||
} break;
|
||||
}
|
||||
@ -1432,7 +1445,7 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Find target target node
|
||||
// Find target node
|
||||
uint32_t target_id = 0;
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 1, target_id);
|
||||
SpvReflectPrvNode* p_target_node = FindNode(p_parser, target_id);
|
||||
@ -1446,7 +1459,7 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser) {
|
||||
}
|
||||
// Get decorations
|
||||
SpvReflectPrvDecorations* p_target_decorations = &(p_target_node->decorations);
|
||||
// Update pointer if this is a member member decoration
|
||||
// Update pointer if this is a member decoration
|
||||
if (p_node->op == SpvOpMemberDecorate) {
|
||||
uint32_t member_index = (uint32_t)INVALID_VALUE;
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 2, member_index);
|
||||
@ -1557,21 +1570,21 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser) {
|
||||
p_target_decorations->input_attachment_index.word_offset = word_offset;
|
||||
} break;
|
||||
|
||||
// -- GODOT begin --
|
||||
case SpvDecorationSpecId: {
|
||||
// -- GODOT begin --
|
||||
uint32_t word_offset = p_node->word_offset + member_offset+ 3;
|
||||
CHECKED_READU32(p_parser, word_offset, p_target_decorations->specialization_constant.value);
|
||||
p_target_decorations->specialization_constant.word_offset = word_offset;
|
||||
} break;
|
||||
CHECKED_READU32(p_parser, word_offset, p_target_decorations->spec_id);
|
||||
// -- GODOT end --
|
||||
spec_constant_count++;
|
||||
} break;
|
||||
|
||||
case SpvReflectDecorationHlslCounterBufferGOOGLE: {
|
||||
case SpvDecorationHlslCounterBufferGOOGLE: {
|
||||
uint32_t word_offset = p_node->word_offset + member_offset + 3;
|
||||
CHECKED_READU32(p_parser, word_offset, p_target_decorations->uav_counter_buffer.value);
|
||||
p_target_decorations->uav_counter_buffer.word_offset = word_offset;
|
||||
} break;
|
||||
|
||||
case SpvReflectDecorationHlslSemanticGOOGLE: {
|
||||
case SpvDecorationHlslSemanticGOOGLE: {
|
||||
uint32_t word_offset = p_node->word_offset + member_offset + 3;
|
||||
p_target_decorations->semantic.value = (const char*)(p_parser->spirv_code + word_offset);
|
||||
p_target_decorations->semantic.word_offset = word_offset;
|
||||
@ -1585,7 +1598,145 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser) {
|
||||
p_target_decorations->is_block_match_texture = true;
|
||||
} break;
|
||||
}
|
||||
|
||||
if (p_node->op == SpvOpDecorateString && decoration == SpvDecorationUserTypeGOOGLE) {
|
||||
uint32_t terminator = 0;
|
||||
SpvReflectResult result = ReadStr(p_parser, p_node->word_offset + 3, 0, p_node->word_count, &terminator, NULL);
|
||||
if (result != SPV_REFLECT_RESULT_SUCCESS) {
|
||||
return result;
|
||||
}
|
||||
const char* name = (const char*)(p_parser->spirv_code + p_node->word_offset + 3);
|
||||
if (UserTypeMatches(name, "cbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_CBUFFER;
|
||||
} else if (UserTypeMatches(name, "tbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TBUFFER;
|
||||
} else if (UserTypeMatches(name, "appendstructuredbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_APPEND_STRUCTURED_BUFFER;
|
||||
} else if (UserTypeMatches(name, "buffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_BUFFER;
|
||||
} else if (UserTypeMatches(name, "byteaddressbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_BYTE_ADDRESS_BUFFER;
|
||||
} else if (UserTypeMatches(name, "constantbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_CONSTANT_BUFFER;
|
||||
} else if (UserTypeMatches(name, "consumestructuredbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_CONSUME_STRUCTURED_BUFFER;
|
||||
} else if (UserTypeMatches(name, "inputpatch")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_INPUT_PATCH;
|
||||
} else if (UserTypeMatches(name, "outputpatch")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_OUTPUT_PATCH;
|
||||
} else if (UserTypeMatches(name, "rasterizerorderedbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BUFFER;
|
||||
} else if (UserTypeMatches(name, "rasterizerorderedbyteaddressbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BYTE_ADDRESS_BUFFER;
|
||||
} else if (UserTypeMatches(name, "rasterizerorderedstructuredbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_STRUCTURED_BUFFER;
|
||||
} else if (UserTypeMatches(name, "rasterizerorderedtexture1d")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D;
|
||||
} else if (UserTypeMatches(name, "rasterizerorderedtexture1darray")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D_ARRAY;
|
||||
} else if (UserTypeMatches(name, "rasterizerorderedtexture2d")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D;
|
||||
} else if (UserTypeMatches(name, "rasterizerorderedtexture2darray")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D_ARRAY;
|
||||
} else if (UserTypeMatches(name, "rasterizerorderedtexture3d")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_3D;
|
||||
} else if (UserTypeMatches(name, "raytracingaccelerationstructure")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RAYTRACING_ACCELERATION_STRUCTURE;
|
||||
} else if (UserTypeMatches(name, "rwbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_BUFFER;
|
||||
} else if (UserTypeMatches(name, "rwbyteaddressbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_BYTE_ADDRESS_BUFFER;
|
||||
} else if (UserTypeMatches(name, "rwstructuredbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_STRUCTURED_BUFFER;
|
||||
} else if (UserTypeMatches(name, "rwtexture1d")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D;
|
||||
} else if (UserTypeMatches(name, "rwtexture1darray")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D_ARRAY;
|
||||
} else if (UserTypeMatches(name, "rwtexture2d")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D;
|
||||
} else if (UserTypeMatches(name, "rwtexture2darray")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D_ARRAY;
|
||||
} else if (UserTypeMatches(name, "rwtexture3d")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_3D;
|
||||
} else if (UserTypeMatches(name, "structuredbuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_STRUCTURED_BUFFER;
|
||||
} else if (UserTypeMatches(name, "subpassinput")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_SUBPASS_INPUT;
|
||||
} else if (UserTypeMatches(name, "subpassinputms")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_SUBPASS_INPUT_MS;
|
||||
} else if (UserTypeMatches(name, "texture1d")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_1D;
|
||||
} else if (UserTypeMatches(name, "texture1darray")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_1D_ARRAY;
|
||||
} else if (UserTypeMatches(name, "texture2d")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_2D;
|
||||
} else if (UserTypeMatches(name, "texture2darray")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_2D_ARRAY;
|
||||
} else if (UserTypeMatches(name, "texture2dms")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_2DMS;
|
||||
} else if (UserTypeMatches(name, "texture2dmsarray")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_2DMS_ARRAY;
|
||||
} else if (UserTypeMatches(name, "texture3d")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_3D;
|
||||
} else if (UserTypeMatches(name, "texturebuffer")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_BUFFER;
|
||||
} else if (UserTypeMatches(name, "texturecube")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_CUBE;
|
||||
} else if (UserTypeMatches(name, "texturecubearray")) {
|
||||
p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_CUBE_ARRAY;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (spec_constant_count > 0) {
|
||||
p_module->spec_constants = (SpvReflectSpecializationConstant*)calloc(spec_constant_count, sizeof(*p_module->spec_constants));
|
||||
if (IsNull(p_module->spec_constants)) {
|
||||
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
|
||||
}
|
||||
}
|
||||
for (uint32_t i = 0; i < p_parser->node_count; ++i) {
|
||||
SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
|
||||
// -- GODOT begin --
|
||||
const uint32_t count = p_module->spec_constant_count;
|
||||
switch(p_node->op) {
|
||||
default: continue;
|
||||
case SpvOpSpecConstantTrue: {
|
||||
p_module->spec_constants[count].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL;
|
||||
p_module->spec_constants[count].default_value.int_bool_value = 1;
|
||||
} break;
|
||||
case SpvOpSpecConstantFalse: {
|
||||
p_module->spec_constants[count].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL;
|
||||
p_module->spec_constants[count].default_value.int_bool_value = 0;
|
||||
} break;
|
||||
case SpvOpSpecConstant: {
|
||||
SpvReflectResult result = SPV_REFLECT_RESULT_SUCCESS;
|
||||
uint32_t element_type_id = (uint32_t)INVALID_VALUE;
|
||||
uint32_t default_value = 0;
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 1, element_type_id);
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 3, default_value);
|
||||
|
||||
SpvReflectPrvNode* p_next_node = FindNode(p_parser, element_type_id);
|
||||
|
||||
if (p_next_node->op == SpvOpTypeInt) {
|
||||
p_module->spec_constants[count].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_INT;
|
||||
} else if (p_next_node->op == SpvOpTypeFloat) {
|
||||
p_module->spec_constants[count].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_FLOAT;
|
||||
} else {
|
||||
return SPV_REFLECT_RESULT_ERROR_PARSE_FAILED;
|
||||
}
|
||||
|
||||
p_module->spec_constants[count].default_value.int_bool_value = default_value; //bits are the same for int and float
|
||||
} break;
|
||||
}
|
||||
|
||||
p_module->spec_constants[count].name = p_node->name;
|
||||
p_module->spec_constants[count].constant_id = p_node->decorations.spec_id;
|
||||
p_module->spec_constants[count].spirv_id = p_node->result_id;
|
||||
|
||||
p_module->spec_constant_count++;
|
||||
// -- GODOT end --
|
||||
}
|
||||
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
@ -1747,22 +1898,16 @@ static SpvReflectResult ParseType(SpvReflectPrvParser* p_parser, SpvReflectPrvNo
|
||||
SpvReflectPrvNode* p_length_node = FindNode(p_parser, length_id);
|
||||
if (IsNotNull(p_length_node)) {
|
||||
uint32_t dim_index = p_type->traits.array.dims_count;
|
||||
if (IsSpecConstant(p_length_node)) {
|
||||
p_type->traits.array.dims[dim_index] = (uint32_t)SPV_REFLECT_ARRAY_DIM_SPEC_CONSTANT;
|
||||
p_type->traits.array.spec_constant_op_ids[dim_index] = length_id;
|
||||
uint32_t length = 0;
|
||||
IF_READU32(result, p_parser, p_length_node->word_offset + 3, length);
|
||||
if (result == SPV_REFLECT_RESULT_SUCCESS) {
|
||||
p_type->traits.array.dims[dim_index] = length;
|
||||
p_type->traits.array.dims_count += 1;
|
||||
p_type->traits.array.spec_constant_op_ids[dim_index] =
|
||||
IsSpecConstant(p_length_node) ? p_length_node->decorations.spec_id : (uint32_t)INVALID_VALUE;
|
||||
} else {
|
||||
uint32_t length = 0;
|
||||
IF_READU32(result, p_parser, p_length_node->word_offset + 3, length);
|
||||
if (result == SPV_REFLECT_RESULT_SUCCESS) {
|
||||
// Write the array dim and increment the count and offset
|
||||
p_type->traits.array.dims[dim_index] = length;
|
||||
p_type->traits.array.spec_constant_op_ids[dim_index] = (uint32_t)SPV_REFLECT_ARRAY_DIM_SPEC_CONSTANT;
|
||||
p_type->traits.array.dims_count += 1;
|
||||
} else {
|
||||
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
|
||||
SPV_REFLECT_ASSERT(false);
|
||||
}
|
||||
result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
|
||||
SPV_REFLECT_ASSERT(false);
|
||||
}
|
||||
// Parse next dimension or element type
|
||||
SpvReflectPrvNode* p_next_node = FindNode(p_parser, element_type_id);
|
||||
@ -1783,7 +1928,7 @@ static SpvReflectResult ParseType(SpvReflectPrvParser* p_parser, SpvReflectPrvNo
|
||||
p_type->traits.array.stride = p_node->decorations.array_stride;
|
||||
uint32_t dim_index = p_type->traits.array.dims_count;
|
||||
p_type->traits.array.dims[dim_index] = (uint32_t)SPV_REFLECT_ARRAY_DIM_RUNTIME;
|
||||
p_type->traits.array.spec_constant_op_ids[dim_index] = 0;
|
||||
p_type->traits.array.spec_constant_op_ids[dim_index] = (uint32_t)INVALID_VALUE;
|
||||
p_type->traits.array.dims_count += 1;
|
||||
// Parse next dimension or element type
|
||||
SpvReflectPrvNode* p_next_node = FindNode(p_parser, element_type_id);
|
||||
@ -1874,13 +2019,6 @@ static SpvReflectResult ParseType(SpvReflectPrvParser* p_parser, SpvReflectPrvNo
|
||||
case SpvOpTypeAccelerationStructureKHR: {
|
||||
p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_ACCELERATION_STRUCTURE;
|
||||
} break;
|
||||
|
||||
// -- GODOT begin --
|
||||
case SpvOpSpecConstantTrue:
|
||||
case SpvOpSpecConstantFalse:
|
||||
case SpvOpSpecConstant: {
|
||||
} break;
|
||||
// -- GODOT end --
|
||||
}
|
||||
|
||||
if (result == SPV_REFLECT_RESULT_SUCCESS) {
|
||||
@ -2068,6 +2206,35 @@ static SpvReflectResult ParseDescriptorBindings(SpvReflectPrvParser* p_parser, S
|
||||
p_descriptor->uav_counter_id = p_node->decorations.uav_counter_buffer.value;
|
||||
p_descriptor->type_description = p_type;
|
||||
p_descriptor->decoration_flags = ApplyDecorations(&p_node->decorations);
|
||||
p_descriptor->user_type = p_node->decorations.user_type;
|
||||
|
||||
// Flags like non-writable and non-readable are found as member decorations only.
|
||||
// If all members have one of those decorations set, promote the decoration up
|
||||
// to the whole descriptor.
|
||||
const SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
|
||||
if (IsNotNull(p_type_node) && p_type_node->member_count) {
|
||||
SpvReflectPrvDecorations common_flags = p_type_node->member_decorations[0];
|
||||
|
||||
for (uint32_t m = 1; m < p_type_node->member_count; ++m) {
|
||||
common_flags.is_relaxed_precision &= p_type_node->member_decorations[m].is_relaxed_precision;
|
||||
common_flags.is_block &= p_type_node->member_decorations[m].is_block;
|
||||
common_flags.is_buffer_block &= p_type_node->member_decorations[m].is_buffer_block;
|
||||
common_flags.is_row_major &= p_type_node->member_decorations[m].is_row_major;
|
||||
common_flags.is_column_major &= p_type_node->member_decorations[m].is_column_major;
|
||||
common_flags.is_built_in &= p_type_node->member_decorations[m].is_built_in;
|
||||
common_flags.is_noperspective &= p_type_node->member_decorations[m].is_noperspective;
|
||||
common_flags.is_flat &= p_type_node->member_decorations[m].is_flat;
|
||||
common_flags.is_non_writable &= p_type_node->member_decorations[m].is_non_writable;
|
||||
common_flags.is_non_readable &= p_type_node->member_decorations[m].is_non_readable;
|
||||
common_flags.is_patch &= p_type_node->member_decorations[m].is_patch;
|
||||
common_flags.is_per_vertex &= p_type_node->member_decorations[m].is_per_vertex;
|
||||
common_flags.is_per_task &= p_type_node->member_decorations[m].is_per_task;
|
||||
common_flags.is_weight_texture &= p_type_node->member_decorations[m].is_weight_texture;
|
||||
common_flags.is_block_match_texture &= p_type_node->member_decorations[m].is_block_match_texture;
|
||||
}
|
||||
|
||||
p_descriptor->decoration_flags |= ApplyDecorations(&common_flags);
|
||||
}
|
||||
|
||||
// If this is in the StorageBuffer storage class, it's for sure a storage
|
||||
// buffer descriptor. We need to handle this case earlier because in SPIR-V
|
||||
@ -2572,10 +2739,35 @@ static SpvReflectResult ParseDescriptorBlockVariableSizes(SpvReflectPrvParser* p
|
||||
}
|
||||
}
|
||||
|
||||
// Structs can offset order don't need to match the index order, so first order by offset
|
||||
// example:
|
||||
// OpMemberDecorate %struct 0 Offset 4
|
||||
// OpMemberDecorate %struct 1 Offset 0
|
||||
SpvReflectBlockVariable** pp_member_offset_order =
|
||||
(SpvReflectBlockVariable**)calloc(p_var->member_count, sizeof(SpvReflectBlockVariable*));
|
||||
if (IsNull(pp_member_offset_order)) {
|
||||
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
|
||||
}
|
||||
|
||||
uint32_t bottom_bound = 0;
|
||||
for (uint32_t i = 0; i < p_var->member_count; ++i) {
|
||||
uint32_t lowest_offset = UINT32_MAX;
|
||||
uint32_t member_index = 0;
|
||||
for (uint32_t j = 0; j < p_var->member_count; ++j) {
|
||||
const uint32_t offset = p_var->members[j].offset;
|
||||
if (offset < lowest_offset && offset >= bottom_bound) {
|
||||
member_index = j;
|
||||
lowest_offset = offset;
|
||||
}
|
||||
}
|
||||
pp_member_offset_order[i] = &p_var->members[member_index];
|
||||
bottom_bound = lowest_offset + 1; // 2 index can't share the same offset
|
||||
}
|
||||
|
||||
// Parse padded size using offset difference for all member except for the last entry...
|
||||
for (uint32_t member_index = 0; member_index < (p_var->member_count - 1); ++member_index) {
|
||||
SpvReflectBlockVariable* p_member_var = &p_var->members[member_index];
|
||||
SpvReflectBlockVariable* p_next_member_var = &p_var->members[member_index + 1];
|
||||
for (uint32_t i = 0; i < (p_var->member_count - 1); ++i) {
|
||||
SpvReflectBlockVariable* p_member_var = pp_member_offset_order[i];
|
||||
SpvReflectBlockVariable* p_next_member_var = pp_member_offset_order[i + 1];
|
||||
p_member_var->padded_size = p_next_member_var->offset - p_member_var->offset;
|
||||
if (p_member_var->size > p_member_var->padded_size) {
|
||||
p_member_var->size = p_member_var->padded_size;
|
||||
@ -2584,18 +2776,21 @@ static SpvReflectResult ParseDescriptorBlockVariableSizes(SpvReflectPrvParser* p
|
||||
p_member_var->padded_size = p_member_var->size;
|
||||
}
|
||||
}
|
||||
|
||||
// ...last entry just gets rounded up to near multiple of SPIRV_DATA_ALIGNMENT, which is 16 and
|
||||
// subtract the offset.
|
||||
if (p_var->member_count > 0) {
|
||||
SpvReflectBlockVariable* p_member_var = &p_var->members[p_var->member_count - 1];
|
||||
p_member_var->padded_size = RoundUp(p_member_var->offset + p_member_var->size, SPIRV_DATA_ALIGNMENT) - p_member_var->offset;
|
||||
if (p_member_var->size > p_member_var->padded_size) {
|
||||
p_member_var->size = p_member_var->padded_size;
|
||||
}
|
||||
if (is_parent_rta) {
|
||||
p_member_var->padded_size = p_member_var->size;
|
||||
}
|
||||
// last entry == entry with largest offset value
|
||||
SpvReflectBlockVariable* p_last_member_var = pp_member_offset_order[p_var->member_count - 1];
|
||||
p_last_member_var->padded_size =
|
||||
RoundUp(p_last_member_var->offset + p_last_member_var->size, SPIRV_DATA_ALIGNMENT) - p_last_member_var->offset;
|
||||
if (p_last_member_var->size > p_last_member_var->padded_size) {
|
||||
p_last_member_var->size = p_last_member_var->padded_size;
|
||||
}
|
||||
if (is_parent_rta) {
|
||||
p_last_member_var->padded_size = p_last_member_var->size;
|
||||
}
|
||||
|
||||
SafeFree(pp_member_offset_order);
|
||||
|
||||
// If buffer ref, sizes are same as uint64_t
|
||||
if (is_parent_ref) {
|
||||
@ -2604,7 +2799,7 @@ static SpvReflectResult ParseDescriptorBlockVariableSizes(SpvReflectPrvParser* p
|
||||
}
|
||||
|
||||
// @TODO validate this with assertion
|
||||
p_var->size = p_var->members[p_var->member_count - 1].offset + p_var->members[p_var->member_count - 1].padded_size;
|
||||
p_var->size = p_last_member_var->offset + p_last_member_var->padded_size;
|
||||
p_var->padded_size = p_var->size;
|
||||
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
@ -3172,6 +3367,106 @@ static SpvReflectResult TraverseCallGraph(SpvReflectPrvParser* p_parser, SpvRefl
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
static uint32_t GetUint32Constant(SpvReflectPrvParser* p_parser, uint32_t id) {
|
||||
uint32_t result = (uint32_t)INVALID_VALUE;
|
||||
SpvReflectPrvNode* p_node = FindNode(p_parser, id);
|
||||
if (p_node && p_node->op == SpvOpConstant) {
|
||||
UNCHECKED_READU32(p_parser, p_node->word_offset + 3, result);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool HasByteAddressBufferOffset(SpvReflectPrvNode* p_node, SpvReflectDescriptorBinding* p_binding) {
|
||||
return IsNotNull(p_node) && IsNotNull(p_binding) && p_node->op == SpvOpAccessChain && p_node->word_count == 6 &&
|
||||
(p_binding->user_type == SPV_REFLECT_USER_TYPE_BYTE_ADDRESS_BUFFER ||
|
||||
p_binding->user_type == SPV_REFLECT_USER_TYPE_RW_BYTE_ADDRESS_BUFFER);
|
||||
}
|
||||
|
||||
static SpvReflectResult ParseByteAddressBuffer(SpvReflectPrvParser* p_parser, SpvReflectPrvNode* p_node,
|
||||
SpvReflectDescriptorBinding* p_binding) {
|
||||
const SpvReflectResult not_found = SPV_REFLECT_RESULT_SUCCESS;
|
||||
if (!HasByteAddressBufferOffset(p_node, p_binding)) {
|
||||
return not_found;
|
||||
}
|
||||
|
||||
uint32_t offset = 0; // starting offset
|
||||
|
||||
uint32_t base_id = 0;
|
||||
// expect first index of 2D access is zero
|
||||
UNCHECKED_READU32(p_parser, p_node->word_offset + 4, base_id);
|
||||
if (GetUint32Constant(p_parser, base_id) != 0) {
|
||||
return not_found;
|
||||
}
|
||||
UNCHECKED_READU32(p_parser, p_node->word_offset + 5, base_id);
|
||||
SpvReflectPrvNode* p_next_node = FindNode(p_parser, base_id);
|
||||
if (IsNull(p_next_node)) {
|
||||
return not_found;
|
||||
} else if (p_next_node->op == SpvOpConstant) {
|
||||
// The access chain might just be a constant right to the offset
|
||||
offset = GetUint32Constant(p_parser, base_id);
|
||||
p_binding->byte_address_buffer_offsets[p_binding->byte_address_buffer_offset_count] = offset;
|
||||
p_binding->byte_address_buffer_offset_count++;
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
// there is usually 2 (sometimes 3) instrucitons that make up the arithmetic logic to calculate the offset
|
||||
SpvReflectPrvNode* arithmetic_node_stack[8];
|
||||
uint32_t arithmetic_count = 0;
|
||||
|
||||
while (IsNotNull(p_next_node)) {
|
||||
if (p_next_node->op == SpvOpLoad || p_next_node->op == SpvOpBitcast || p_next_node->op == SpvOpConstant) {
|
||||
break; // arithmetic starts here
|
||||
}
|
||||
arithmetic_node_stack[arithmetic_count++] = p_next_node;
|
||||
if (arithmetic_count >= 8) {
|
||||
return not_found;
|
||||
}
|
||||
|
||||
UNCHECKED_READU32(p_parser, p_next_node->word_offset + 3, base_id);
|
||||
p_next_node = FindNode(p_parser, base_id);
|
||||
}
|
||||
|
||||
const uint32_t count = arithmetic_count;
|
||||
for (uint32_t i = 0; i < count; i++) {
|
||||
p_next_node = arithmetic_node_stack[--arithmetic_count];
|
||||
// All arithmetic ops takes 2 operands, assumption is the 2nd operand has the constant
|
||||
UNCHECKED_READU32(p_parser, p_next_node->word_offset + 4, base_id);
|
||||
uint32_t value = GetUint32Constant(p_parser, base_id);
|
||||
if (value == INVALID_VALUE) {
|
||||
return not_found;
|
||||
}
|
||||
|
||||
switch (p_next_node->op) {
|
||||
case SpvOpShiftRightLogical:
|
||||
offset >>= value;
|
||||
break;
|
||||
case SpvOpIAdd:
|
||||
offset += value;
|
||||
break;
|
||||
case SpvOpISub:
|
||||
offset -= value;
|
||||
break;
|
||||
case SpvOpIMul:
|
||||
offset *= value;
|
||||
break;
|
||||
case SpvOpUDiv:
|
||||
offset /= value;
|
||||
break;
|
||||
case SpvOpSDiv:
|
||||
// OpConstant might be signed, but value should never be negative
|
||||
assert((int32_t)value > 0);
|
||||
offset /= value;
|
||||
break;
|
||||
default:
|
||||
return not_found;
|
||||
}
|
||||
}
|
||||
|
||||
p_binding->byte_address_buffer_offsets[p_binding->byte_address_buffer_offset_count] = offset;
|
||||
p_binding->byte_address_buffer_offset_count++;
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
static SpvReflectResult ParseStaticallyUsedResources(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module,
|
||||
SpvReflectEntryPoint* p_entry, size_t uniform_count, uint32_t* uniforms,
|
||||
size_t push_constant_count, uint32_t* push_constants) {
|
||||
@ -3204,6 +3499,7 @@ static SpvReflectResult ParseStaticallyUsedResources(SpvReflectPrvParser* p_pars
|
||||
called_function_count = 0;
|
||||
result = TraverseCallGraph(p_parser, p_func, &called_function_count, p_called_functions, 0);
|
||||
if (result != SPV_REFLECT_RESULT_SUCCESS) {
|
||||
SafeFree(p_called_functions);
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -3247,30 +3543,77 @@ static SpvReflectResult ParseStaticallyUsedResources(SpvReflectPrvParser* p_pars
|
||||
|
||||
// Do set intersection to find the used uniform and push constants
|
||||
size_t used_uniform_count = 0;
|
||||
SpvReflectResult result0 = IntersectSortedAccessedVariable(p_used_accesses, used_acessed_count, uniforms, uniform_count,
|
||||
&p_entry->used_uniforms, &used_uniform_count);
|
||||
result = IntersectSortedAccessedVariable(p_used_accesses, used_acessed_count, uniforms, uniform_count, &p_entry->used_uniforms,
|
||||
&used_uniform_count);
|
||||
if (result != SPV_REFLECT_RESULT_SUCCESS) {
|
||||
SafeFree(p_used_accesses);
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t used_push_constant_count = 0;
|
||||
SpvReflectResult result1 =
|
||||
IntersectSortedAccessedVariable(p_used_accesses, used_acessed_count, push_constants, push_constant_count,
|
||||
&p_entry->used_push_constants, &used_push_constant_count);
|
||||
result = IntersectSortedAccessedVariable(p_used_accesses, used_acessed_count, push_constants, push_constant_count,
|
||||
&p_entry->used_push_constants, &used_push_constant_count);
|
||||
if (result != SPV_REFLECT_RESULT_SUCCESS) {
|
||||
SafeFree(p_used_accesses);
|
||||
return result;
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < p_module->descriptor_binding_count; ++i) {
|
||||
SpvReflectDescriptorBinding* p_binding = &p_module->descriptor_bindings[i];
|
||||
uint32_t byte_address_buffer_offset_count = 0;
|
||||
|
||||
for (uint32_t j = 0; j < used_acessed_count; j++) {
|
||||
if (p_used_accesses[j].variable_ptr == p_binding->spirv_id) {
|
||||
p_binding->accessed = 1;
|
||||
|
||||
if (HasByteAddressBufferOffset(p_used_accesses[j].p_node, p_binding)) {
|
||||
byte_address_buffer_offset_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// only if SPIR-V has ByteAddressBuffer user type
|
||||
if (byte_address_buffer_offset_count > 0) {
|
||||
bool multi_entrypoint = p_binding->byte_address_buffer_offset_count > 0;
|
||||
if (multi_entrypoint) {
|
||||
// If there is a 2nd entrypoint, we can have multiple entry points, in this case we want to just combine the accessed
|
||||
// offsets and then de-duplicate it
|
||||
uint32_t* prev_byte_address_buffer_offsets = p_binding->byte_address_buffer_offsets;
|
||||
p_binding->byte_address_buffer_offsets =
|
||||
(uint32_t*)calloc(byte_address_buffer_offset_count + p_binding->byte_address_buffer_offset_count, sizeof(uint32_t));
|
||||
memcpy(p_binding->byte_address_buffer_offsets, prev_byte_address_buffer_offsets,
|
||||
sizeof(uint32_t) * p_binding->byte_address_buffer_offset_count);
|
||||
SafeFree(prev_byte_address_buffer_offsets);
|
||||
} else {
|
||||
// possible not all allocated offset slots are used, but this will be a max per binding
|
||||
p_binding->byte_address_buffer_offsets = (uint32_t*)calloc(byte_address_buffer_offset_count, sizeof(uint32_t));
|
||||
}
|
||||
|
||||
if (IsNull(p_binding->byte_address_buffer_offsets)) {
|
||||
SafeFree(p_used_accesses);
|
||||
return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
|
||||
}
|
||||
|
||||
for (uint32_t j = 0; j < used_acessed_count; j++) {
|
||||
if (p_used_accesses[j].variable_ptr == p_binding->spirv_id) {
|
||||
result = ParseByteAddressBuffer(p_parser, p_used_accesses[j].p_node, p_binding);
|
||||
if (result != SPV_REFLECT_RESULT_SUCCESS) {
|
||||
SafeFree(p_used_accesses);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (multi_entrypoint) {
|
||||
qsort(p_binding->byte_address_buffer_offsets, p_binding->byte_address_buffer_offset_count,
|
||||
sizeof(*(p_binding->byte_address_buffer_offsets)), SortCompareUint32);
|
||||
p_binding->byte_address_buffer_offset_count =
|
||||
(uint32_t)DedupSortedUint32(p_binding->byte_address_buffer_offsets, p_binding->byte_address_buffer_offset_count);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SafeFree(p_used_accesses);
|
||||
if (result0 != SPV_REFLECT_RESULT_SUCCESS) {
|
||||
return result0;
|
||||
}
|
||||
if (result1 != SPV_REFLECT_RESULT_SUCCESS) {
|
||||
return result1;
|
||||
}
|
||||
|
||||
p_entry->used_uniform_count = (uint32_t)used_uniform_count;
|
||||
p_entry->used_push_constant_count = (uint32_t)used_push_constant_count;
|
||||
@ -3489,13 +3832,6 @@ static SpvReflectResult ParseExecutionModes(SpvReflectPrvParser* p_parser, SpvRe
|
||||
}
|
||||
} break;
|
||||
|
||||
case SpvExecutionModeInputPoints:
|
||||
case SpvExecutionModeInputLines:
|
||||
case SpvExecutionModeInputLinesAdjacency:
|
||||
case SpvExecutionModeTriangles:
|
||||
case SpvExecutionModeInputTrianglesAdjacency:
|
||||
case SpvExecutionModeQuads:
|
||||
case SpvExecutionModeIsolines:
|
||||
case SpvExecutionModeOutputVertices: {
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 3, p_entry_point->output_vertices);
|
||||
} break;
|
||||
@ -3552,68 +3888,6 @@ static SpvReflectResult ParseExecutionModes(SpvReflectPrvParser* p_parser, SpvRe
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
// -- GODOT begin --
|
||||
static SpvReflectResult ParseSpecializationConstants(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
|
||||
p_module->specialization_constant_count = 0;
|
||||
p_module->specialization_constants = NULL;
|
||||
for (size_t i = 0; i < p_parser->node_count; ++i) {
|
||||
SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
|
||||
if (p_node->op == SpvOpSpecConstantTrue || p_node->op == SpvOpSpecConstantFalse || p_node->op == SpvOpSpecConstant) {
|
||||
p_module->specialization_constant_count++;
|
||||
}
|
||||
}
|
||||
|
||||
if (p_module->specialization_constant_count == 0) {
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
p_module->specialization_constants = (SpvReflectSpecializationConstant*)calloc(p_module->specialization_constant_count, sizeof(SpvReflectSpecializationConstant));
|
||||
|
||||
uint32_t index = 0;
|
||||
|
||||
for (size_t i = 0; i < p_parser->node_count; ++i) {
|
||||
SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
|
||||
switch(p_node->op) {
|
||||
default: continue;
|
||||
case SpvOpSpecConstantTrue: {
|
||||
p_module->specialization_constants[index].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL;
|
||||
p_module->specialization_constants[index].default_value.int_bool_value = 1;
|
||||
} break;
|
||||
case SpvOpSpecConstantFalse: {
|
||||
p_module->specialization_constants[index].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL;
|
||||
p_module->specialization_constants[index].default_value.int_bool_value = 0;
|
||||
} break;
|
||||
case SpvOpSpecConstant: {
|
||||
SpvReflectResult result = SPV_REFLECT_RESULT_SUCCESS;
|
||||
uint32_t element_type_id = (uint32_t)INVALID_VALUE;
|
||||
uint32_t default_value = 0;
|
||||
IF_READU32(result, p_parser, p_node->word_offset + 1, element_type_id);
|
||||
IF_READU32(result, p_parser, p_node->word_offset + 3, default_value);
|
||||
|
||||
SpvReflectPrvNode* p_next_node = FindNode(p_parser, element_type_id);
|
||||
|
||||
if (p_next_node->op == SpvOpTypeInt) {
|
||||
p_module->specialization_constants[index].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_INT;
|
||||
} else if (p_next_node->op == SpvOpTypeFloat) {
|
||||
p_module->specialization_constants[index].constant_type = SPV_REFLECT_SPECIALIZATION_CONSTANT_FLOAT;
|
||||
} else {
|
||||
return SPV_REFLECT_RESULT_ERROR_PARSE_FAILED;
|
||||
}
|
||||
|
||||
p_module->specialization_constants[index].default_value.int_bool_value = default_value; //bits are the same for int and float
|
||||
} break;
|
||||
}
|
||||
|
||||
p_module->specialization_constants[index].name = p_node->name;
|
||||
p_module->specialization_constants[index].constant_id = p_node->decorations.specialization_constant.value;
|
||||
p_module->specialization_constants[index].spirv_id = p_node->result_id;
|
||||
index++;
|
||||
}
|
||||
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
// -- GODOT end --
|
||||
|
||||
static SpvReflectResult ParsePushConstantBlocks(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
|
||||
for (size_t i = 0; i < p_parser->node_count; ++i) {
|
||||
SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
|
||||
@ -3676,7 +3950,7 @@ static SpvReflectResult ParsePushConstantBlocks(SpvReflectPrvParser* p_parser, S
|
||||
for (uint32_t access_chain_index = 0; access_chain_index < p_parser->access_chain_count; ++access_chain_index) {
|
||||
SpvReflectPrvAccessChain* p_access_chain = &(p_parser->access_chains[access_chain_index]);
|
||||
// Skip any access chains that aren't touching this push constant block
|
||||
if (p_push_constant->spirv_id != FindBaseId(p_parser, p_access_chain)) {
|
||||
if (p_push_constant->spirv_id != FindAccessChainBaseVariable(p_parser, p_access_chain)) {
|
||||
continue;
|
||||
}
|
||||
SpvReflectBlockVariable* p_var =
|
||||
@ -3959,7 +4233,7 @@ static SpvReflectResult CreateShaderModule(uint32_t flags, size_t size, const vo
|
||||
SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
|
||||
}
|
||||
if (result == SPV_REFLECT_RESULT_SUCCESS) {
|
||||
result = ParseDecorations(&parser);
|
||||
result = ParseDecorations(&parser, p_module);
|
||||
SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
@ -4000,12 +4274,6 @@ static SpvReflectResult CreateShaderModule(uint32_t flags, size_t size, const vo
|
||||
result = ParsePushConstantBlocks(&parser, p_module);
|
||||
SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
|
||||
}
|
||||
// -- GODOT begin --
|
||||
if (result == SPV_REFLECT_RESULT_SUCCESS) {
|
||||
result = ParseSpecializationConstants(&parser, p_module);
|
||||
SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
|
||||
}
|
||||
// -- GODOT end --
|
||||
if (result == SPV_REFLECT_RESULT_SUCCESS) {
|
||||
result = ParseEntryPoints(&parser, p_module);
|
||||
SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
|
||||
@ -4131,6 +4399,9 @@ void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module) {
|
||||
// Descriptor binding blocks
|
||||
for (size_t i = 0; i < p_module->descriptor_binding_count; ++i) {
|
||||
SpvReflectDescriptorBinding* p_descriptor = &p_module->descriptor_bindings[i];
|
||||
if (IsNotNull(p_descriptor->byte_address_buffer_offsets)) {
|
||||
SafeFree(p_descriptor->byte_address_buffer_offsets);
|
||||
}
|
||||
SafeFreeBlockVariables(&p_descriptor->block);
|
||||
}
|
||||
SafeFree(p_module->descriptor_bindings);
|
||||
@ -4154,9 +4425,7 @@ void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module) {
|
||||
}
|
||||
SafeFree(p_module->capabilities);
|
||||
SafeFree(p_module->entry_points);
|
||||
// -- GODOT begin --
|
||||
SafeFree(p_module->specialization_constants);
|
||||
// -- GODOT end --
|
||||
SafeFree(p_module->spec_constants);
|
||||
|
||||
// Push constants
|
||||
for (size_t i = 0; i < p_module->push_constant_block_count; ++i) {
|
||||
@ -4384,36 +4653,6 @@ SpvReflectResult spvReflectEnumerateEntryPointInterfaceVariables(const SpvReflec
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
// -- GODOT begin --
|
||||
SpvReflectResult spvReflectEnumerateSpecializationConstants(
|
||||
const SpvReflectShaderModule* p_module,
|
||||
uint32_t* p_count,
|
||||
SpvReflectSpecializationConstant** pp_constants
|
||||
) {
|
||||
if (IsNull(p_module)) {
|
||||
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
|
||||
}
|
||||
if (IsNull(p_count)) {
|
||||
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
|
||||
}
|
||||
|
||||
if (IsNotNull(pp_constants)) {
|
||||
if (*p_count != p_module->specialization_constant_count) {
|
||||
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
|
||||
}
|
||||
|
||||
for (uint32_t index = 0; index < *p_count; ++index) {
|
||||
SpvReflectSpecializationConstant *p_const = &p_module->specialization_constants[index];
|
||||
pp_constants[index] = p_const;
|
||||
}
|
||||
} else {
|
||||
*p_count = p_module->specialization_constant_count;
|
||||
}
|
||||
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
// -- GODOT end --
|
||||
|
||||
SpvReflectResult spvReflectEnumerateInputVariables(const SpvReflectShaderModule* p_module, uint32_t* p_count,
|
||||
SpvReflectInterfaceVariable** pp_variables) {
|
||||
if (IsNull(p_module)) {
|
||||
@ -4592,6 +4831,31 @@ SpvReflectResult spvReflectEnumerateEntryPointPushConstantBlocks(const SpvReflec
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
SpvReflectResult spvReflectEnumerateSpecializationConstants(const SpvReflectShaderModule* p_module, uint32_t* p_count,
|
||||
SpvReflectSpecializationConstant** pp_constants) {
|
||||
if (IsNull(p_module)) {
|
||||
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
|
||||
}
|
||||
if (IsNull(p_count)) {
|
||||
return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
|
||||
}
|
||||
|
||||
if (IsNotNull(pp_constants)) {
|
||||
if (*p_count != p_module->spec_constant_count) {
|
||||
return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
|
||||
}
|
||||
|
||||
for (uint32_t index = 0; index < *p_count; ++index) {
|
||||
SpvReflectSpecializationConstant* p_constant = (SpvReflectSpecializationConstant*)&p_module->spec_constants[index];
|
||||
pp_constants[index] = p_constant;
|
||||
}
|
||||
} else {
|
||||
*p_count = p_module->spec_constant_count;
|
||||
}
|
||||
|
||||
return SPV_REFLECT_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
const SpvReflectDescriptorBinding* spvReflectGetDescriptorBinding(const SpvReflectShaderModule* p_module, uint32_t binding_number,
|
||||
uint32_t set_number, SpvReflectResult* p_result) {
|
||||
const SpvReflectDescriptorBinding* p_descriptor = NULL;
|
||||
|
171
thirdparty/spirv-reflect/spirv_reflect.h
vendored
171
thirdparty/spirv-reflect/spirv_reflect.h
vendored
@ -160,6 +160,50 @@ typedef enum SpvReflectDecorationFlagBits {
|
||||
|
||||
typedef uint32_t SpvReflectDecorationFlags;
|
||||
|
||||
// Based of SPV_GOOGLE_user_type
|
||||
typedef enum SpvReflectUserType {
|
||||
SPV_REFLECT_USER_TYPE_INVALID = 0,
|
||||
SPV_REFLECT_USER_TYPE_CBUFFER,
|
||||
SPV_REFLECT_USER_TYPE_TBUFFER,
|
||||
SPV_REFLECT_USER_TYPE_APPEND_STRUCTURED_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_BYTE_ADDRESS_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_CONSTANT_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_CONSUME_STRUCTURED_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_INPUT_PATCH,
|
||||
SPV_REFLECT_USER_TYPE_OUTPUT_PATCH,
|
||||
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BYTE_ADDRESS_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_STRUCTURED_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D,
|
||||
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D_ARRAY,
|
||||
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D,
|
||||
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D_ARRAY,
|
||||
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_3D,
|
||||
SPV_REFLECT_USER_TYPE_RAYTRACING_ACCELERATION_STRUCTURE,
|
||||
SPV_REFLECT_USER_TYPE_RW_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_RW_BYTE_ADDRESS_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_RW_STRUCTURED_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D,
|
||||
SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D_ARRAY,
|
||||
SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D,
|
||||
SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D_ARRAY,
|
||||
SPV_REFLECT_USER_TYPE_RW_TEXTURE_3D,
|
||||
SPV_REFLECT_USER_TYPE_STRUCTURED_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_SUBPASS_INPUT,
|
||||
SPV_REFLECT_USER_TYPE_SUBPASS_INPUT_MS,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_1D,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_1D_ARRAY,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_2D,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_2D_ARRAY,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_2DMS,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_2DMS_ARRAY,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_3D,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_BUFFER,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_CUBE,
|
||||
SPV_REFLECT_USER_TYPE_TEXTURE_CUBE_ARRAY,
|
||||
} SpvReflectUserType;
|
||||
|
||||
/*! @enum SpvReflectResourceType
|
||||
|
||||
*/
|
||||
@ -321,7 +365,6 @@ typedef struct SpvReflectImageTraits {
|
||||
|
||||
typedef enum SpvReflectArrayDimType {
|
||||
SPV_REFLECT_ARRAY_DIM_RUNTIME = 0, // OpTypeRuntimeArray
|
||||
SPV_REFLECT_ARRAY_DIM_SPEC_CONSTANT = 0xFFFFFFFF // specialization constant
|
||||
} SpvReflectArrayDimType;
|
||||
|
||||
typedef struct SpvReflectArrayTraits {
|
||||
@ -374,30 +417,6 @@ typedef struct SpvReflectTypeDescription {
|
||||
struct SpvReflectTypeDescription* members;
|
||||
} SpvReflectTypeDescription;
|
||||
|
||||
// -- GODOT begin --
|
||||
/*! @enum SpvReflectSpecializationConstantType
|
||||
|
||||
*/
|
||||
typedef enum SpvReflectSpecializationConstantType {
|
||||
SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL = 0,
|
||||
SPV_REFLECT_SPECIALIZATION_CONSTANT_INT = 1,
|
||||
SPV_REFLECT_SPECIALIZATION_CONSTANT_FLOAT = 2,
|
||||
} SpvReflectSpecializationConstantType;
|
||||
|
||||
/*! @struct SpvReflectSpecializationConstant
|
||||
|
||||
*/
|
||||
typedef struct SpvReflectSpecializationConstant {
|
||||
const char* name;
|
||||
uint32_t spirv_id;
|
||||
uint32_t constant_id;
|
||||
SpvReflectSpecializationConstantType constant_type;
|
||||
union {
|
||||
float float_value;
|
||||
uint32_t int_bool_value;
|
||||
} default_value;
|
||||
} SpvReflectSpecializationConstant;
|
||||
// -- GODOT end --
|
||||
|
||||
/*! @struct SpvReflectInterfaceVariable
|
||||
@brief The OpVariable that is either an Input or Output to the module
|
||||
@ -475,6 +494,8 @@ typedef struct SpvReflectDescriptorBinding {
|
||||
uint32_t accessed;
|
||||
uint32_t uav_counter_id;
|
||||
struct SpvReflectDescriptorBinding* uav_counter_binding;
|
||||
uint32_t byte_address_buffer_offset_count;
|
||||
uint32_t* byte_address_buffer_offsets;
|
||||
|
||||
SpvReflectTypeDescription* type_description;
|
||||
|
||||
@ -484,6 +505,8 @@ typedef struct SpvReflectDescriptorBinding {
|
||||
} word_offset;
|
||||
|
||||
SpvReflectDecorationFlags decoration_flags;
|
||||
// Requires SPV_GOOGLE_user_type
|
||||
SpvReflectUserType user_type;
|
||||
} SpvReflectDescriptorBinding;
|
||||
|
||||
/*! @struct SpvReflectDescriptorSet
|
||||
@ -544,6 +567,34 @@ typedef struct SpvReflectCapability {
|
||||
uint32_t word_offset;
|
||||
} SpvReflectCapability;
|
||||
|
||||
|
||||
// -- GODOT begin --
|
||||
/*! @enum SpvReflectSpecializationConstantType
|
||||
|
||||
*/
|
||||
typedef enum SpvReflectSpecializationConstantType {
|
||||
SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL = 0,
|
||||
SPV_REFLECT_SPECIALIZATION_CONSTANT_INT = 1,
|
||||
SPV_REFLECT_SPECIALIZATION_CONSTANT_FLOAT = 2,
|
||||
} SpvReflectSpecializationConstantType;
|
||||
// -- GODOT end --
|
||||
|
||||
/*! @struct SpvReflectSpecId
|
||||
|
||||
*/
|
||||
typedef struct SpvReflectSpecializationConstant {
|
||||
uint32_t spirv_id;
|
||||
uint32_t constant_id;
|
||||
const char* name;
|
||||
// -- GODOT begin --
|
||||
SpvReflectSpecializationConstantType constant_type;
|
||||
union {
|
||||
float float_value;
|
||||
uint32_t int_bool_value;
|
||||
} default_value;
|
||||
// -- GODOT end --
|
||||
} SpvReflectSpecializationConstant;
|
||||
|
||||
/*! @struct SpvReflectShaderModule
|
||||
|
||||
*/
|
||||
@ -573,10 +624,8 @@ typedef struct SpvReflectShaderModule {
|
||||
SpvReflectInterfaceVariable* interface_variables; // Uses value(s) from first entry point
|
||||
uint32_t push_constant_block_count; // Uses value(s) from first entry point
|
||||
SpvReflectBlockVariable* push_constant_blocks; // Uses value(s) from first entry point
|
||||
// -- GODOT begin --
|
||||
uint32_t specialization_constant_count;
|
||||
SpvReflectSpecializationConstant* specialization_constants;
|
||||
// -- GODOT end --
|
||||
uint32_t spec_constant_count; // Uses value(s) from first entry point
|
||||
SpvReflectSpecializationConstant* spec_constants; // Uses value(s) from first entry point
|
||||
|
||||
struct Internal {
|
||||
SpvReflectModuleFlags module_flags;
|
||||
@ -849,32 +898,6 @@ SpvReflectResult spvReflectEnumerateInputVariables(
|
||||
SpvReflectInterfaceVariable** pp_variables
|
||||
);
|
||||
|
||||
// -- GOODT begin --
|
||||
/*! @fn spvReflectEnumerateSpecializationConstants
|
||||
@brief If the module contains multiple entry points, this will only get
|
||||
the specialization constants for the first one.
|
||||
@param p_module Pointer to an instance of SpvReflectShaderModule.
|
||||
@param p_count If pp_constants is NULL, the module's specialization constant
|
||||
count will be stored here.
|
||||
If pp_variables is not NULL, *p_count must contain
|
||||
the module's specialization constant count.
|
||||
@param pp_variables If NULL, the module's specialization constant count will be
|
||||
written to *p_count.
|
||||
If non-NULL, pp_constants must point to an array with
|
||||
*p_count entries, where pointers to the module's
|
||||
specialization constants will be written. The caller must not
|
||||
free the specialization constants written to this array.
|
||||
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
|
||||
Otherwise, the error code indicates the cause of the
|
||||
failure.
|
||||
*/
|
||||
SpvReflectResult spvReflectEnumerateSpecializationConstants(
|
||||
const SpvReflectShaderModule* p_module,
|
||||
uint32_t* p_count,
|
||||
SpvReflectSpecializationConstant** pp_constants
|
||||
);
|
||||
// -- GODOT end --
|
||||
|
||||
/*! @fn spvReflectEnumerateEntryPointInputVariables
|
||||
@brief Enumerate the input variables for a given entry point.
|
||||
@param entry_point The name of the entry point to get the input variables for.
|
||||
@ -1014,6 +1037,25 @@ SpvReflectResult spvReflectEnumerateEntryPointPushConstantBlocks(
|
||||
);
|
||||
|
||||
|
||||
/*! @fn spvReflectEnumerateSpecializationConstants
|
||||
@param p_module Pointer to an instance of SpvReflectShaderModule.
|
||||
@param p_count If pp_blocks is NULL, the module's specialization constant
|
||||
count will be stored here. If pp_blocks is not NULL, *p_count
|
||||
must contain the module's specialization constant count.
|
||||
@param pp_constants If NULL, the module's specialization constant count
|
||||
will be written to *p_count. If non-NULL, pp_blocks must
|
||||
point to an array with *p_count entries, where pointers to
|
||||
the module's specialization constant blocks will be written.
|
||||
The caller must not free the variables written to this array.
|
||||
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
|
||||
Otherwise, the error code indicates the cause of the failure.
|
||||
*/
|
||||
SpvReflectResult spvReflectEnumerateSpecializationConstants(
|
||||
const SpvReflectShaderModule* p_module,
|
||||
uint32_t* p_count,
|
||||
SpvReflectSpecializationConstant** pp_constants
|
||||
);
|
||||
|
||||
/*! @fn spvReflectGetDescriptorBinding
|
||||
|
||||
@param p_module Pointer to an instance of SpvReflectShaderModule.
|
||||
@ -1604,6 +1646,7 @@ public:
|
||||
SpvReflectResult EnumeratePushConstants(uint32_t* p_count, SpvReflectBlockVariable** pp_blocks) const {
|
||||
return EnumeratePushConstantBlocks(p_count, pp_blocks);
|
||||
}
|
||||
SpvReflectResult EnumerateSpecializationConstants(uint32_t* p_count, SpvReflectSpecializationConstant** pp_constants) const;
|
||||
|
||||
const SpvReflectDescriptorBinding* GetDescriptorBinding(uint32_t binding_number, uint32_t set_number, SpvReflectResult* p_result = nullptr) const;
|
||||
const SpvReflectDescriptorBinding* GetEntryPointDescriptorBinding(const char* entry_point, uint32_t binding_number, uint32_t set_number, SpvReflectResult* p_result = nullptr) const;
|
||||
@ -2051,6 +2094,24 @@ inline SpvReflectResult ShaderModule::EnumeratePushConstantBlocks(
|
||||
return m_result;
|
||||
}
|
||||
|
||||
/*! @fn EnumerateSpecializationConstants
|
||||
@param p_count
|
||||
@param pp_constants
|
||||
@return
|
||||
*/
|
||||
inline SpvReflectResult ShaderModule::EnumerateSpecializationConstants(
|
||||
uint32_t* p_count,
|
||||
SpvReflectSpecializationConstant** pp_constants
|
||||
) const
|
||||
{
|
||||
m_result = spvReflectEnumerateSpecializationConstants(
|
||||
&m_module,
|
||||
p_count,
|
||||
pp_constants
|
||||
);
|
||||
return m_result;
|
||||
}
|
||||
|
||||
/*! @fn EnumerateEntryPointPushConstantBlocks
|
||||
|
||||
@param entry_point
|
||||
|
161
thirdparty/volk/volk.c
vendored
161
thirdparty/volk/volk.c
vendored
@ -31,6 +31,17 @@ __declspec(dllimport) FARPROC __stdcall GetProcAddress(HMODULE, LPCSTR);
|
||||
__declspec(dllimport) int __stdcall FreeLibrary(HMODULE);
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__)
|
||||
# define VOLK_DISABLE_GCC_PEDANTIC_WARNINGS \
|
||||
_Pragma("GCC diagnostic push") \
|
||||
_Pragma("GCC diagnostic ignored \"-Wpedantic\"")
|
||||
# define VOLK_RESTORE_GCC_PEDANTIC_WARNINGS \
|
||||
_Pragma("GCC diagnostic pop")
|
||||
#else
|
||||
# define VOLK_DISABLE_GCC_PEDANTIC_WARNINGS
|
||||
# define VOLK_RESTORE_GCC_PEDANTIC_WARNINGS
|
||||
#endif
|
||||
|
||||
static void* loadedModule = NULL;
|
||||
static VkInstance loadedInstance = VK_NULL_HANDLE;
|
||||
static VkDevice loadedDevice = VK_NULL_HANDLE;
|
||||
@ -72,6 +83,12 @@ VkResult volkInitialize(void)
|
||||
module = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
|
||||
if (!module)
|
||||
module = dlopen("libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL);
|
||||
// Add support for using Vulkan and MoltenVK in a Framework. App store rules for iOS
|
||||
// strictly enforce no .dylib's. If they aren't found it just falls through
|
||||
if (!module)
|
||||
module = dlopen("vulkan.framework/vulkan", RTLD_NOW | RTLD_LOCAL);
|
||||
if (!module)
|
||||
module = dlopen("MoltenVK.framework/MoltenVK", RTLD_NOW | RTLD_LOCAL);
|
||||
// modern versions of macOS don't search /usr/local/lib automatically contrary to what man dlopen says
|
||||
// Vulkan SDK uses this as the system-wide installation location, so we're going to fallback to this if all else fails
|
||||
if (!module && getenv("DYLD_FALLBACK_LIBRARY_PATH") == NULL)
|
||||
@ -86,8 +103,9 @@ VkResult volkInitialize(void)
|
||||
module = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
|
||||
if (!module)
|
||||
return VK_ERROR_INITIALIZATION_FAILED;
|
||||
|
||||
VOLK_DISABLE_GCC_PEDANTIC_WARNINGS
|
||||
vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(module, "vkGetInstanceProcAddr");
|
||||
VOLK_RESTORE_GCC_PEDANTIC_WARNINGS
|
||||
#endif
|
||||
|
||||
loadedModule = module;
|
||||
@ -889,6 +907,10 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c
|
||||
vkCmdBeginRenderingKHR = (PFN_vkCmdBeginRenderingKHR)load(context, "vkCmdBeginRenderingKHR");
|
||||
vkCmdEndRenderingKHR = (PFN_vkCmdEndRenderingKHR)load(context, "vkCmdEndRenderingKHR");
|
||||
#endif /* defined(VK_KHR_dynamic_rendering) */
|
||||
#if defined(VK_KHR_dynamic_rendering_local_read)
|
||||
vkCmdSetRenderingAttachmentLocationsKHR = (PFN_vkCmdSetRenderingAttachmentLocationsKHR)load(context, "vkCmdSetRenderingAttachmentLocationsKHR");
|
||||
vkCmdSetRenderingInputAttachmentIndicesKHR = (PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)load(context, "vkCmdSetRenderingInputAttachmentIndicesKHR");
|
||||
#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
|
||||
#if defined(VK_KHR_external_fence_fd)
|
||||
vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)load(context, "vkGetFenceFdKHR");
|
||||
vkImportFenceFdKHR = (PFN_vkImportFenceFdKHR)load(context, "vkImportFenceFdKHR");
|
||||
@ -921,6 +943,9 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c
|
||||
vkGetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR)load(context, "vkGetImageMemoryRequirements2KHR");
|
||||
vkGetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR)load(context, "vkGetImageSparseMemoryRequirements2KHR");
|
||||
#endif /* defined(VK_KHR_get_memory_requirements2) */
|
||||
#if defined(VK_KHR_line_rasterization)
|
||||
vkCmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)load(context, "vkCmdSetLineStippleKHR");
|
||||
#endif /* defined(VK_KHR_line_rasterization) */
|
||||
#if defined(VK_KHR_maintenance1)
|
||||
vkTrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)load(context, "vkTrimCommandPoolKHR");
|
||||
#endif /* defined(VK_KHR_maintenance1) */
|
||||
@ -1167,26 +1192,44 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c
|
||||
#if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
|
||||
vkCmdSetAlphaToCoverageEnableEXT = (PFN_vkCmdSetAlphaToCoverageEnableEXT)load(context, "vkCmdSetAlphaToCoverageEnableEXT");
|
||||
vkCmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT)load(context, "vkCmdSetAlphaToOneEnableEXT");
|
||||
vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)load(context, "vkCmdSetColorBlendAdvancedEXT");
|
||||
vkCmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)load(context, "vkCmdSetColorBlendEnableEXT");
|
||||
vkCmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)load(context, "vkCmdSetColorBlendEquationEXT");
|
||||
vkCmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)load(context, "vkCmdSetColorWriteMaskEXT");
|
||||
vkCmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)load(context, "vkCmdSetConservativeRasterizationModeEXT");
|
||||
vkCmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)load(context, "vkCmdSetDepthClampEnableEXT");
|
||||
vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)load(context, "vkCmdSetDepthClipEnableEXT");
|
||||
vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)load(context, "vkCmdSetDepthClipNegativeOneToOneEXT");
|
||||
vkCmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)load(context, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
|
||||
vkCmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)load(context, "vkCmdSetLineRasterizationModeEXT");
|
||||
vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)load(context, "vkCmdSetLineStippleEnableEXT");
|
||||
vkCmdSetLogicOpEnableEXT = (PFN_vkCmdSetLogicOpEnableEXT)load(context, "vkCmdSetLogicOpEnableEXT");
|
||||
vkCmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT)load(context, "vkCmdSetPolygonModeEXT");
|
||||
vkCmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)load(context, "vkCmdSetProvokingVertexModeEXT");
|
||||
vkCmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT)load(context, "vkCmdSetRasterizationSamplesEXT");
|
||||
vkCmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)load(context, "vkCmdSetRasterizationStreamEXT");
|
||||
vkCmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)load(context, "vkCmdSetSampleLocationsEnableEXT");
|
||||
vkCmdSetSampleMaskEXT = (PFN_vkCmdSetSampleMaskEXT)load(context, "vkCmdSetSampleMaskEXT");
|
||||
vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)load(context, "vkCmdSetTessellationDomainOriginEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
|
||||
vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)load(context, "vkCmdSetTessellationDomainOriginEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
|
||||
vkCmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)load(context, "vkCmdSetRasterizationStreamEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
|
||||
vkCmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)load(context, "vkCmdSetConservativeRasterizationModeEXT");
|
||||
vkCmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)load(context, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
|
||||
vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)load(context, "vkCmdSetDepthClipEnableEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
|
||||
vkCmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)load(context, "vkCmdSetSampleLocationsEnableEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
|
||||
vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)load(context, "vkCmdSetColorBlendAdvancedEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
|
||||
vkCmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)load(context, "vkCmdSetProvokingVertexModeEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
|
||||
vkCmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)load(context, "vkCmdSetLineRasterizationModeEXT");
|
||||
vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)load(context, "vkCmdSetLineStippleEnableEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
|
||||
vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)load(context, "vkCmdSetDepthClipNegativeOneToOneEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
|
||||
vkCmdSetViewportWScalingEnableNV = (PFN_vkCmdSetViewportWScalingEnableNV)load(context, "vkCmdSetViewportWScalingEnableNV");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
|
||||
@ -1720,6 +1763,10 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context,
|
||||
table->vkCmdBeginRenderingKHR = (PFN_vkCmdBeginRenderingKHR)load(context, "vkCmdBeginRenderingKHR");
|
||||
table->vkCmdEndRenderingKHR = (PFN_vkCmdEndRenderingKHR)load(context, "vkCmdEndRenderingKHR");
|
||||
#endif /* defined(VK_KHR_dynamic_rendering) */
|
||||
#if defined(VK_KHR_dynamic_rendering_local_read)
|
||||
table->vkCmdSetRenderingAttachmentLocationsKHR = (PFN_vkCmdSetRenderingAttachmentLocationsKHR)load(context, "vkCmdSetRenderingAttachmentLocationsKHR");
|
||||
table->vkCmdSetRenderingInputAttachmentIndicesKHR = (PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)load(context, "vkCmdSetRenderingInputAttachmentIndicesKHR");
|
||||
#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
|
||||
#if defined(VK_KHR_external_fence_fd)
|
||||
table->vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)load(context, "vkGetFenceFdKHR");
|
||||
table->vkImportFenceFdKHR = (PFN_vkImportFenceFdKHR)load(context, "vkImportFenceFdKHR");
|
||||
@ -1752,6 +1799,9 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context,
|
||||
table->vkGetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR)load(context, "vkGetImageMemoryRequirements2KHR");
|
||||
table->vkGetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR)load(context, "vkGetImageSparseMemoryRequirements2KHR");
|
||||
#endif /* defined(VK_KHR_get_memory_requirements2) */
|
||||
#if defined(VK_KHR_line_rasterization)
|
||||
table->vkCmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)load(context, "vkCmdSetLineStippleKHR");
|
||||
#endif /* defined(VK_KHR_line_rasterization) */
|
||||
#if defined(VK_KHR_maintenance1)
|
||||
table->vkTrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)load(context, "vkTrimCommandPoolKHR");
|
||||
#endif /* defined(VK_KHR_maintenance1) */
|
||||
@ -1998,26 +2048,44 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context,
|
||||
#if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
|
||||
table->vkCmdSetAlphaToCoverageEnableEXT = (PFN_vkCmdSetAlphaToCoverageEnableEXT)load(context, "vkCmdSetAlphaToCoverageEnableEXT");
|
||||
table->vkCmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT)load(context, "vkCmdSetAlphaToOneEnableEXT");
|
||||
table->vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)load(context, "vkCmdSetColorBlendAdvancedEXT");
|
||||
table->vkCmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)load(context, "vkCmdSetColorBlendEnableEXT");
|
||||
table->vkCmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)load(context, "vkCmdSetColorBlendEquationEXT");
|
||||
table->vkCmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)load(context, "vkCmdSetColorWriteMaskEXT");
|
||||
table->vkCmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)load(context, "vkCmdSetConservativeRasterizationModeEXT");
|
||||
table->vkCmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)load(context, "vkCmdSetDepthClampEnableEXT");
|
||||
table->vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)load(context, "vkCmdSetDepthClipEnableEXT");
|
||||
table->vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)load(context, "vkCmdSetDepthClipNegativeOneToOneEXT");
|
||||
table->vkCmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)load(context, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
|
||||
table->vkCmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)load(context, "vkCmdSetLineRasterizationModeEXT");
|
||||
table->vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)load(context, "vkCmdSetLineStippleEnableEXT");
|
||||
table->vkCmdSetLogicOpEnableEXT = (PFN_vkCmdSetLogicOpEnableEXT)load(context, "vkCmdSetLogicOpEnableEXT");
|
||||
table->vkCmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT)load(context, "vkCmdSetPolygonModeEXT");
|
||||
table->vkCmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)load(context, "vkCmdSetProvokingVertexModeEXT");
|
||||
table->vkCmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT)load(context, "vkCmdSetRasterizationSamplesEXT");
|
||||
table->vkCmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)load(context, "vkCmdSetRasterizationStreamEXT");
|
||||
table->vkCmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)load(context, "vkCmdSetSampleLocationsEnableEXT");
|
||||
table->vkCmdSetSampleMaskEXT = (PFN_vkCmdSetSampleMaskEXT)load(context, "vkCmdSetSampleMaskEXT");
|
||||
table->vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)load(context, "vkCmdSetTessellationDomainOriginEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
|
||||
table->vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)load(context, "vkCmdSetTessellationDomainOriginEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
|
||||
table->vkCmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)load(context, "vkCmdSetRasterizationStreamEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
|
||||
table->vkCmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)load(context, "vkCmdSetConservativeRasterizationModeEXT");
|
||||
table->vkCmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)load(context, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
|
||||
table->vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)load(context, "vkCmdSetDepthClipEnableEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
|
||||
table->vkCmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)load(context, "vkCmdSetSampleLocationsEnableEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
|
||||
table->vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)load(context, "vkCmdSetColorBlendAdvancedEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
|
||||
table->vkCmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)load(context, "vkCmdSetProvokingVertexModeEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
|
||||
table->vkCmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)load(context, "vkCmdSetLineRasterizationModeEXT");
|
||||
table->vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)load(context, "vkCmdSetLineStippleEnableEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
|
||||
table->vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)load(context, "vkCmdSetDepthClipNegativeOneToOneEXT");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
|
||||
table->vkCmdSetViewportWScalingEnableNV = (PFN_vkCmdSetViewportWScalingEnableNV)load(context, "vkCmdSetViewportWScalingEnableNV");
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
|
||||
@ -2660,6 +2728,10 @@ PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR;
|
||||
PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
|
||||
PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
|
||||
#endif /* defined(VK_KHR_dynamic_rendering) */
|
||||
#if defined(VK_KHR_dynamic_rendering_local_read)
|
||||
PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR;
|
||||
PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR;
|
||||
#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
|
||||
#if defined(VK_KHR_external_fence_capabilities)
|
||||
PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR;
|
||||
#endif /* defined(VK_KHR_external_fence_capabilities) */
|
||||
@ -2721,6 +2793,9 @@ PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparse
|
||||
PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR;
|
||||
PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR;
|
||||
#endif /* defined(VK_KHR_get_surface_capabilities2) */
|
||||
#if defined(VK_KHR_line_rasterization)
|
||||
PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR;
|
||||
#endif /* defined(VK_KHR_line_rasterization) */
|
||||
#if defined(VK_KHR_maintenance1)
|
||||
PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR;
|
||||
#endif /* defined(VK_KHR_maintenance1) */
|
||||
@ -3022,26 +3097,44 @@ PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT;
|
||||
#if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
|
||||
PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
|
||||
PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
|
||||
PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
|
||||
PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
|
||||
PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
|
||||
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
|
||||
PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
|
||||
PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
|
||||
PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
|
||||
PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
|
||||
PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
|
||||
PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
|
||||
PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
|
||||
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
|
||||
PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
|
||||
PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
|
||||
PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
|
||||
PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
|
||||
PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
|
||||
PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
|
||||
PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
|
||||
|
100
thirdparty/volk/volk.h
vendored
100
thirdparty/volk/volk.h
vendored
@ -1,7 +1,7 @@
|
||||
/**
|
||||
* volk
|
||||
*
|
||||
* Copyright (C) 2018-2023, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
|
||||
* Copyright (C) 2018-2024, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
|
||||
* Report bugs and download new versions at https://github.com/zeux/volk
|
||||
*
|
||||
* This library is distributed under the MIT License. See notice at the end of this file.
|
||||
@ -15,7 +15,7 @@
|
||||
#endif
|
||||
|
||||
/* VOLK_GENERATE_VERSION_DEFINE */
|
||||
#define VOLK_HEADER_VERSION 275
|
||||
#define VOLK_HEADER_VERSION 283
|
||||
/* VOLK_GENERATE_VERSION_DEFINE */
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
@ -622,6 +622,10 @@ struct VolkDeviceTable
|
||||
PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
|
||||
PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
|
||||
#endif /* defined(VK_KHR_dynamic_rendering) */
|
||||
#if defined(VK_KHR_dynamic_rendering_local_read)
|
||||
PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR;
|
||||
PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR;
|
||||
#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
|
||||
#if defined(VK_KHR_external_fence_fd)
|
||||
PFN_vkGetFenceFdKHR vkGetFenceFdKHR;
|
||||
PFN_vkImportFenceFdKHR vkImportFenceFdKHR;
|
||||
@ -654,6 +658,9 @@ struct VolkDeviceTable
|
||||
PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
|
||||
PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR;
|
||||
#endif /* defined(VK_KHR_get_memory_requirements2) */
|
||||
#if defined(VK_KHR_line_rasterization)
|
||||
PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR;
|
||||
#endif /* defined(VK_KHR_line_rasterization) */
|
||||
#if defined(VK_KHR_maintenance1)
|
||||
PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR;
|
||||
#endif /* defined(VK_KHR_maintenance1) */
|
||||
@ -900,26 +907,44 @@ struct VolkDeviceTable
|
||||
#if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
|
||||
PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
|
||||
PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
|
||||
PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
|
||||
PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
|
||||
PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
|
||||
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
|
||||
PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
|
||||
PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
|
||||
PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
|
||||
PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
|
||||
PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
|
||||
PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
|
||||
PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
|
||||
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
|
||||
PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
|
||||
PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
|
||||
PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
|
||||
PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
|
||||
PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
|
||||
PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
|
||||
PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
|
||||
@ -1554,6 +1579,10 @@ extern PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR;
|
||||
extern PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
|
||||
extern PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
|
||||
#endif /* defined(VK_KHR_dynamic_rendering) */
|
||||
#if defined(VK_KHR_dynamic_rendering_local_read)
|
||||
extern PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR;
|
||||
extern PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR;
|
||||
#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
|
||||
#if defined(VK_KHR_external_fence_capabilities)
|
||||
extern PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR;
|
||||
#endif /* defined(VK_KHR_external_fence_capabilities) */
|
||||
@ -1615,6 +1644,9 @@ extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDevic
|
||||
extern PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR;
|
||||
extern PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR;
|
||||
#endif /* defined(VK_KHR_get_surface_capabilities2) */
|
||||
#if defined(VK_KHR_line_rasterization)
|
||||
extern PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR;
|
||||
#endif /* defined(VK_KHR_line_rasterization) */
|
||||
#if defined(VK_KHR_maintenance1)
|
||||
extern PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR;
|
||||
#endif /* defined(VK_KHR_maintenance1) */
|
||||
@ -1916,26 +1948,44 @@ extern PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT
|
||||
#if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
|
||||
extern PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
|
||||
extern PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
|
||||
extern PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
extern PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
|
||||
extern PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
|
||||
extern PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
|
||||
extern PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
extern PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
|
||||
extern PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
extern PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
extern PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
extern PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
extern PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
extern PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
|
||||
extern PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
|
||||
extern PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
extern PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
|
||||
extern PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
extern PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
extern PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
|
||||
extern PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
|
||||
extern PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
|
||||
extern PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
|
||||
extern PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
extern PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
|
||||
extern PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
|
||||
extern PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
|
||||
extern PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
|
||||
extern PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
|
||||
extern PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
extern PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
|
||||
extern PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
|
||||
extern PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
|
||||
@ -1996,7 +2046,7 @@ extern PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Copyright (c) 2018-2023 Arseny Kapoulkine
|
||||
* Copyright (c) 2018-2024 Arseny Kapoulkine
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
|
392
thirdparty/vulkan/include/vk_video/vulkan_video_codec_av1std.h
vendored
Normal file
392
thirdparty/vulkan/include/vk_video/vulkan_video_codec_av1std.h
vendored
Normal file
@ -0,0 +1,392 @@
|
||||
#ifndef VULKAN_VIDEO_CODEC_AV1STD_H_
|
||||
#define VULKAN_VIDEO_CODEC_AV1STD_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is generated from the Khronos Vulkan XML API Registry.
|
||||
**
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_av1std 1
|
||||
#include "vulkan_video_codecs_common.h"
|
||||
#define STD_VIDEO_AV1_NUM_REF_FRAMES 8
|
||||
#define STD_VIDEO_AV1_REFS_PER_FRAME 7
|
||||
#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8
|
||||
#define STD_VIDEO_AV1_MAX_TILE_COLS 64
|
||||
#define STD_VIDEO_AV1_MAX_TILE_ROWS 64
|
||||
#define STD_VIDEO_AV1_MAX_SEGMENTS 8
|
||||
#define STD_VIDEO_AV1_SEG_LVL_MAX 8
|
||||
#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7
|
||||
#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2
|
||||
#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2
|
||||
#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2
|
||||
#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4
|
||||
#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2
|
||||
#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8
|
||||
#define STD_VIDEO_AV1_MAX_NUM_PLANES 3
|
||||
#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6
|
||||
#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14
|
||||
#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10
|
||||
#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10
|
||||
#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24
|
||||
#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25
|
||||
|
||||
typedef enum StdVideoAV1Profile {
|
||||
STD_VIDEO_AV1_PROFILE_MAIN = 0,
|
||||
STD_VIDEO_AV1_PROFILE_HIGH = 1,
|
||||
STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2,
|
||||
STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1Profile;
|
||||
|
||||
typedef enum StdVideoAV1Level {
|
||||
STD_VIDEO_AV1_LEVEL_2_0 = 0,
|
||||
STD_VIDEO_AV1_LEVEL_2_1 = 1,
|
||||
STD_VIDEO_AV1_LEVEL_2_2 = 2,
|
||||
STD_VIDEO_AV1_LEVEL_2_3 = 3,
|
||||
STD_VIDEO_AV1_LEVEL_3_0 = 4,
|
||||
STD_VIDEO_AV1_LEVEL_3_1 = 5,
|
||||
STD_VIDEO_AV1_LEVEL_3_2 = 6,
|
||||
STD_VIDEO_AV1_LEVEL_3_3 = 7,
|
||||
STD_VIDEO_AV1_LEVEL_4_0 = 8,
|
||||
STD_VIDEO_AV1_LEVEL_4_1 = 9,
|
||||
STD_VIDEO_AV1_LEVEL_4_2 = 10,
|
||||
STD_VIDEO_AV1_LEVEL_4_3 = 11,
|
||||
STD_VIDEO_AV1_LEVEL_5_0 = 12,
|
||||
STD_VIDEO_AV1_LEVEL_5_1 = 13,
|
||||
STD_VIDEO_AV1_LEVEL_5_2 = 14,
|
||||
STD_VIDEO_AV1_LEVEL_5_3 = 15,
|
||||
STD_VIDEO_AV1_LEVEL_6_0 = 16,
|
||||
STD_VIDEO_AV1_LEVEL_6_1 = 17,
|
||||
STD_VIDEO_AV1_LEVEL_6_2 = 18,
|
||||
STD_VIDEO_AV1_LEVEL_6_3 = 19,
|
||||
STD_VIDEO_AV1_LEVEL_7_0 = 20,
|
||||
STD_VIDEO_AV1_LEVEL_7_1 = 21,
|
||||
STD_VIDEO_AV1_LEVEL_7_2 = 22,
|
||||
STD_VIDEO_AV1_LEVEL_7_3 = 23,
|
||||
STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1Level;
|
||||
|
||||
typedef enum StdVideoAV1FrameType {
|
||||
STD_VIDEO_AV1_FRAME_TYPE_KEY = 0,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_INTER = 1,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1FrameType;
|
||||
|
||||
typedef enum StdVideoAV1ReferenceName {
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1ReferenceName;
|
||||
|
||||
typedef enum StdVideoAV1InterpolationFilter {
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1InterpolationFilter;
|
||||
|
||||
typedef enum StdVideoAV1TxMode {
|
||||
STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0,
|
||||
STD_VIDEO_AV1_TX_MODE_LARGEST = 1,
|
||||
STD_VIDEO_AV1_TX_MODE_SELECT = 2,
|
||||
STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1TxMode;
|
||||
|
||||
typedef enum StdVideoAV1FrameRestorationType {
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1FrameRestorationType;
|
||||
|
||||
typedef enum StdVideoAV1ColorPrimaries {
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = 2,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1ColorPrimaries;
|
||||
|
||||
typedef enum StdVideoAV1TransferCharacteristics {
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1TransferCharacteristics;
|
||||
|
||||
typedef enum StdVideoAV1MatrixCoefficients {
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1MatrixCoefficients;
|
||||
|
||||
typedef enum StdVideoAV1ChromaSamplePosition {
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1ChromaSamplePosition;
|
||||
typedef struct StdVideoAV1ColorConfigFlags {
|
||||
uint32_t mono_chrome : 1;
|
||||
uint32_t color_range : 1;
|
||||
uint32_t separate_uv_delta_q : 1;
|
||||
uint32_t color_description_present_flag : 1;
|
||||
uint32_t reserved : 28;
|
||||
} StdVideoAV1ColorConfigFlags;
|
||||
|
||||
typedef struct StdVideoAV1ColorConfig {
|
||||
StdVideoAV1ColorConfigFlags flags;
|
||||
uint8_t BitDepth;
|
||||
uint8_t subsampling_x;
|
||||
uint8_t subsampling_y;
|
||||
uint8_t reserved1;
|
||||
StdVideoAV1ColorPrimaries color_primaries;
|
||||
StdVideoAV1TransferCharacteristics transfer_characteristics;
|
||||
StdVideoAV1MatrixCoefficients matrix_coefficients;
|
||||
StdVideoAV1ChromaSamplePosition chroma_sample_position;
|
||||
} StdVideoAV1ColorConfig;
|
||||
|
||||
typedef struct StdVideoAV1TimingInfoFlags {
|
||||
uint32_t equal_picture_interval : 1;
|
||||
uint32_t reserved : 31;
|
||||
} StdVideoAV1TimingInfoFlags;
|
||||
|
||||
typedef struct StdVideoAV1TimingInfo {
|
||||
StdVideoAV1TimingInfoFlags flags;
|
||||
uint32_t num_units_in_display_tick;
|
||||
uint32_t time_scale;
|
||||
uint32_t num_ticks_per_picture_minus_1;
|
||||
} StdVideoAV1TimingInfo;
|
||||
|
||||
typedef struct StdVideoAV1LoopFilterFlags {
|
||||
uint32_t loop_filter_delta_enabled : 1;
|
||||
uint32_t loop_filter_delta_update : 1;
|
||||
uint32_t reserved : 30;
|
||||
} StdVideoAV1LoopFilterFlags;
|
||||
|
||||
typedef struct StdVideoAV1LoopFilter {
|
||||
StdVideoAV1LoopFilterFlags flags;
|
||||
uint8_t loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS];
|
||||
uint8_t loop_filter_sharpness;
|
||||
uint8_t update_ref_delta;
|
||||
int8_t loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME];
|
||||
uint8_t update_mode_delta;
|
||||
int8_t loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS];
|
||||
} StdVideoAV1LoopFilter;
|
||||
|
||||
typedef struct StdVideoAV1QuantizationFlags {
|
||||
uint32_t using_qmatrix : 1;
|
||||
uint32_t diff_uv_delta : 1;
|
||||
uint32_t reserved : 30;
|
||||
} StdVideoAV1QuantizationFlags;
|
||||
|
||||
typedef struct StdVideoAV1Quantization {
|
||||
StdVideoAV1QuantizationFlags flags;
|
||||
uint8_t base_q_idx;
|
||||
int8_t DeltaQYDc;
|
||||
int8_t DeltaQUDc;
|
||||
int8_t DeltaQUAc;
|
||||
int8_t DeltaQVDc;
|
||||
int8_t DeltaQVAc;
|
||||
uint8_t qm_y;
|
||||
uint8_t qm_u;
|
||||
uint8_t qm_v;
|
||||
} StdVideoAV1Quantization;
|
||||
|
||||
typedef struct StdVideoAV1Segmentation {
|
||||
uint8_t FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS];
|
||||
int16_t FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX];
|
||||
} StdVideoAV1Segmentation;
|
||||
|
||||
typedef struct StdVideoAV1TileInfoFlags {
|
||||
uint32_t uniform_tile_spacing_flag : 1;
|
||||
uint32_t reserved : 31;
|
||||
} StdVideoAV1TileInfoFlags;
|
||||
|
||||
typedef struct StdVideoAV1TileInfo {
|
||||
StdVideoAV1TileInfoFlags flags;
|
||||
uint8_t TileCols;
|
||||
uint8_t TileRows;
|
||||
uint16_t context_update_tile_id;
|
||||
uint8_t tile_size_bytes_minus_1;
|
||||
uint8_t reserved1[7];
|
||||
const uint16_t* pMiColStarts;
|
||||
const uint16_t* pMiRowStarts;
|
||||
const uint16_t* pWidthInSbsMinus1;
|
||||
const uint16_t* pHeightInSbsMinus1;
|
||||
} StdVideoAV1TileInfo;
|
||||
|
||||
typedef struct StdVideoAV1CDEF {
|
||||
uint8_t cdef_damping_minus_3;
|
||||
uint8_t cdef_bits;
|
||||
uint8_t cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
|
||||
uint8_t cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
|
||||
uint8_t cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
|
||||
uint8_t cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
|
||||
} StdVideoAV1CDEF;
|
||||
|
||||
typedef struct StdVideoAV1LoopRestoration {
|
||||
StdVideoAV1FrameRestorationType FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES];
|
||||
uint16_t LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES];
|
||||
} StdVideoAV1LoopRestoration;
|
||||
|
||||
typedef struct StdVideoAV1GlobalMotion {
|
||||
uint8_t GmType[STD_VIDEO_AV1_NUM_REF_FRAMES];
|
||||
int32_t gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS];
|
||||
} StdVideoAV1GlobalMotion;
|
||||
|
||||
typedef struct StdVideoAV1FilmGrainFlags {
|
||||
uint32_t chroma_scaling_from_luma : 1;
|
||||
uint32_t overlap_flag : 1;
|
||||
uint32_t clip_to_restricted_range : 1;
|
||||
uint32_t update_grain : 1;
|
||||
uint32_t reserved : 28;
|
||||
} StdVideoAV1FilmGrainFlags;
|
||||
|
||||
typedef struct StdVideoAV1FilmGrain {
|
||||
StdVideoAV1FilmGrainFlags flags;
|
||||
uint8_t grain_scaling_minus_8;
|
||||
uint8_t ar_coeff_lag;
|
||||
uint8_t ar_coeff_shift_minus_6;
|
||||
uint8_t grain_scale_shift;
|
||||
uint16_t grain_seed;
|
||||
uint8_t film_grain_params_ref_idx;
|
||||
uint8_t num_y_points;
|
||||
uint8_t point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS];
|
||||
uint8_t point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS];
|
||||
uint8_t num_cb_points;
|
||||
uint8_t point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS];
|
||||
uint8_t point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS];
|
||||
uint8_t num_cr_points;
|
||||
uint8_t point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS];
|
||||
uint8_t point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS];
|
||||
int8_t ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA];
|
||||
int8_t ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA];
|
||||
int8_t ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA];
|
||||
uint8_t cb_mult;
|
||||
uint8_t cb_luma_mult;
|
||||
uint16_t cb_offset;
|
||||
uint8_t cr_mult;
|
||||
uint8_t cr_luma_mult;
|
||||
uint16_t cr_offset;
|
||||
} StdVideoAV1FilmGrain;
|
||||
|
||||
typedef struct StdVideoAV1SequenceHeaderFlags {
|
||||
uint32_t still_picture : 1;
|
||||
uint32_t reduced_still_picture_header : 1;
|
||||
uint32_t use_128x128_superblock : 1;
|
||||
uint32_t enable_filter_intra : 1;
|
||||
uint32_t enable_intra_edge_filter : 1;
|
||||
uint32_t enable_interintra_compound : 1;
|
||||
uint32_t enable_masked_compound : 1;
|
||||
uint32_t enable_warped_motion : 1;
|
||||
uint32_t enable_dual_filter : 1;
|
||||
uint32_t enable_order_hint : 1;
|
||||
uint32_t enable_jnt_comp : 1;
|
||||
uint32_t enable_ref_frame_mvs : 1;
|
||||
uint32_t frame_id_numbers_present_flag : 1;
|
||||
uint32_t enable_superres : 1;
|
||||
uint32_t enable_cdef : 1;
|
||||
uint32_t enable_restoration : 1;
|
||||
uint32_t film_grain_params_present : 1;
|
||||
uint32_t timing_info_present_flag : 1;
|
||||
uint32_t initial_display_delay_present_flag : 1;
|
||||
uint32_t reserved : 13;
|
||||
} StdVideoAV1SequenceHeaderFlags;
|
||||
|
||||
typedef struct StdVideoAV1SequenceHeader {
|
||||
StdVideoAV1SequenceHeaderFlags flags;
|
||||
StdVideoAV1Profile seq_profile;
|
||||
uint8_t frame_width_bits_minus_1;
|
||||
uint8_t frame_height_bits_minus_1;
|
||||
uint16_t max_frame_width_minus_1;
|
||||
uint16_t max_frame_height_minus_1;
|
||||
uint8_t delta_frame_id_length_minus_2;
|
||||
uint8_t additional_frame_id_length_minus_1;
|
||||
uint8_t order_hint_bits_minus_1;
|
||||
uint8_t seq_force_integer_mv;
|
||||
uint8_t seq_force_screen_content_tools;
|
||||
uint8_t reserved1[5];
|
||||
const StdVideoAV1ColorConfig* pColorConfig;
|
||||
const StdVideoAV1TimingInfo* pTimingInfo;
|
||||
} StdVideoAV1SequenceHeader;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
109
thirdparty/vulkan/include/vk_video/vulkan_video_codec_av1std_decode.h
vendored
Normal file
109
thirdparty/vulkan/include/vk_video/vulkan_video_codec_av1std_decode.h
vendored
Normal file
@ -0,0 +1,109 @@
|
||||
#ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_
|
||||
#define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is generated from the Khronos Vulkan XML API Registry.
|
||||
**
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_av1std_decode is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_av1std_decode 1
|
||||
#include "vulkan_video_codec_av1std.h"
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode"
|
||||
typedef struct StdVideoDecodeAV1PictureInfoFlags {
|
||||
uint32_t error_resilient_mode : 1;
|
||||
uint32_t disable_cdf_update : 1;
|
||||
uint32_t use_superres : 1;
|
||||
uint32_t render_and_frame_size_different : 1;
|
||||
uint32_t allow_screen_content_tools : 1;
|
||||
uint32_t is_filter_switchable : 1;
|
||||
uint32_t force_integer_mv : 1;
|
||||
uint32_t frame_size_override_flag : 1;
|
||||
uint32_t buffer_removal_time_present_flag : 1;
|
||||
uint32_t allow_intrabc : 1;
|
||||
uint32_t frame_refs_short_signaling : 1;
|
||||
uint32_t allow_high_precision_mv : 1;
|
||||
uint32_t is_motion_mode_switchable : 1;
|
||||
uint32_t use_ref_frame_mvs : 1;
|
||||
uint32_t disable_frame_end_update_cdf : 1;
|
||||
uint32_t allow_warped_motion : 1;
|
||||
uint32_t reduced_tx_set : 1;
|
||||
uint32_t reference_select : 1;
|
||||
uint32_t skip_mode_present : 1;
|
||||
uint32_t delta_q_present : 1;
|
||||
uint32_t delta_lf_present : 1;
|
||||
uint32_t delta_lf_multi : 1;
|
||||
uint32_t segmentation_enabled : 1;
|
||||
uint32_t segmentation_update_map : 1;
|
||||
uint32_t segmentation_temporal_update : 1;
|
||||
uint32_t segmentation_update_data : 1;
|
||||
uint32_t UsesLr : 1;
|
||||
uint32_t usesChromaLr : 1;
|
||||
uint32_t apply_grain : 1;
|
||||
uint32_t reserved : 3;
|
||||
} StdVideoDecodeAV1PictureInfoFlags;
|
||||
|
||||
typedef struct StdVideoDecodeAV1PictureInfo {
|
||||
StdVideoDecodeAV1PictureInfoFlags flags;
|
||||
StdVideoAV1FrameType frame_type;
|
||||
uint32_t current_frame_id;
|
||||
uint8_t OrderHint;
|
||||
uint8_t primary_ref_frame;
|
||||
uint8_t refresh_frame_flags;
|
||||
uint8_t reserved1;
|
||||
StdVideoAV1InterpolationFilter interpolation_filter;
|
||||
StdVideoAV1TxMode TxMode;
|
||||
uint8_t delta_q_res;
|
||||
uint8_t delta_lf_res;
|
||||
uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES];
|
||||
uint8_t coded_denom;
|
||||
uint8_t reserved2[3];
|
||||
uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
|
||||
uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES];
|
||||
const StdVideoAV1TileInfo* pTileInfo;
|
||||
const StdVideoAV1Quantization* pQuantization;
|
||||
const StdVideoAV1Segmentation* pSegmentation;
|
||||
const StdVideoAV1LoopFilter* pLoopFilter;
|
||||
const StdVideoAV1CDEF* pCDEF;
|
||||
const StdVideoAV1LoopRestoration* pLoopRestoration;
|
||||
const StdVideoAV1GlobalMotion* pGlobalMotion;
|
||||
const StdVideoAV1FilmGrain* pFilmGrain;
|
||||
} StdVideoDecodeAV1PictureInfo;
|
||||
|
||||
typedef struct StdVideoDecodeAV1ReferenceInfoFlags {
|
||||
uint32_t disable_frame_end_update_cdf : 1;
|
||||
uint32_t segmentation_enabled : 1;
|
||||
uint32_t reserved : 30;
|
||||
} StdVideoDecodeAV1ReferenceInfoFlags;
|
||||
|
||||
typedef struct StdVideoDecodeAV1ReferenceInfo {
|
||||
StdVideoDecodeAV1ReferenceInfoFlags flags;
|
||||
uint8_t frame_type;
|
||||
uint8_t RefFrameSignBias;
|
||||
uint8_t OrderHint;
|
||||
uint8_t SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
|
||||
} StdVideoDecodeAV1ReferenceInfo;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
132
thirdparty/vulkan/include/vulkan/vulkan.cppm
vendored
132
thirdparty/vulkan/include/vulkan/vulkan.cppm
vendored
@ -643,9 +643,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagBitsEXT;
|
||||
using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT;
|
||||
|
||||
//=== VK_EXT_line_rasterization ===
|
||||
using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT;
|
||||
|
||||
//=== VK_KHR_pipeline_executable_properties ===
|
||||
using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR;
|
||||
|
||||
@ -839,6 +836,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_MSFT_layered_driver ===
|
||||
using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT;
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT;
|
||||
using VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
|
||||
using VULKAN_HPP_NAMESPACE::TimeDomainKHR;
|
||||
@ -904,15 +905,14 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError;
|
||||
using VULKAN_HPP_NAMESPACE::IncompatibleShaderBinaryEXTError;
|
||||
using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError;
|
||||
#endif /*VULKAN_HPP_NO_EXCEPTIONS*/
|
||||
|
||||
using VULKAN_HPP_NAMESPACE::createResultValueType;
|
||||
using VULKAN_HPP_NAMESPACE::ignore;
|
||||
using VULKAN_HPP_NAMESPACE::resultCheck;
|
||||
using VULKAN_HPP_NAMESPACE::ResultValue;
|
||||
using VULKAN_HPP_NAMESPACE::ResultValueType;
|
||||
using VULKAN_HPP_NAMESPACE::detail::createResultValueType;
|
||||
using VULKAN_HPP_NAMESPACE::detail::ignore;
|
||||
using VULKAN_HPP_NAMESPACE::detail::resultCheck;
|
||||
|
||||
//===========================
|
||||
//=== CONSTEXPR CONSTANTs ===
|
||||
@ -1742,10 +1742,18 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::AMDDeviceCoherentMemoryExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::AMDDeviceCoherentMemorySpecVersion;
|
||||
|
||||
//=== VK_KHR_dynamic_rendering_local_read ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingLocalReadExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingLocalReadSpecVersion;
|
||||
|
||||
//=== VK_EXT_shader_image_atomic_int64 ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTShaderImageAtomicInt64ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTShaderImageAtomicInt64SpecVersion;
|
||||
|
||||
//=== VK_KHR_shader_quad_control ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderQuadControlExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderQuadControlSpecVersion;
|
||||
|
||||
//=== VK_KHR_spirv_1_4 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRSpirv14ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRSpirv14SpecVersion;
|
||||
@ -1864,6 +1872,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::KHRMapMemory2ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRMapMemory2SpecVersion;
|
||||
|
||||
//=== VK_EXT_map_memory_placed ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTMapMemoryPlacedExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTMapMemoryPlacedSpecVersion;
|
||||
|
||||
//=== VK_EXT_shader_atomic_float2 ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloat2ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloat2SpecVersion;
|
||||
@ -2227,6 +2239,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::ARMShaderCorePropertiesExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::ARMShaderCorePropertiesSpecVersion;
|
||||
|
||||
//=== VK_KHR_shader_subgroup_rotate ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupRotateExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupRotateSpecVersion;
|
||||
|
||||
//=== VK_ARM_scheduling_controls ===
|
||||
using VULKAN_HPP_NAMESPACE::ARMSchedulingControlsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::ARMSchedulingControlsSpecVersion;
|
||||
@ -2276,6 +2292,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::GOOGLESurfacelessQueryExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::GOOGLESurfacelessQuerySpecVersion;
|
||||
|
||||
//=== VK_KHR_shader_maximal_reconvergence ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderMaximalReconvergenceExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderMaximalReconvergenceSpecVersion;
|
||||
|
||||
//=== VK_EXT_image_compression_control_swapchain ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSwapchainExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSwapchainSpecVersion;
|
||||
@ -2395,6 +2415,11 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasSpecVersion;
|
||||
|
||||
//=== VK_KHR_video_decode_av1 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1SpecVersion;
|
||||
using VULKAN_HPP_NAMESPACE::MaxVideoAv1ReferencesPerFrameKHR;
|
||||
|
||||
//=== VK_KHR_video_maintenance1 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1SpecVersion;
|
||||
@ -2427,6 +2452,14 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorSpecVersion;
|
||||
|
||||
//=== VK_KHR_load_store_op_none ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneSpecVersion;
|
||||
|
||||
//=== VK_KHR_shader_float_controls2 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2SpecVersion;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferExtensionName;
|
||||
@ -2437,10 +2470,22 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverSpecVersion;
|
||||
|
||||
//=== VK_KHR_index_type_uint8 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8SpecVersion;
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRLineRasterizationExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRLineRasterizationSpecVersion;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsSpecVersion;
|
||||
|
||||
//=== VK_KHR_shader_expect_assume ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderExpectAssumeExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRShaderExpectAssumeSpecVersion;
|
||||
|
||||
//=== VK_KHR_maintenance6 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRMaintenance6ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRMaintenance6SpecVersion;
|
||||
@ -2449,6 +2494,18 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion;
|
||||
|
||||
//=== VK_NV_raw_access_chains ===
|
||||
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion;
|
||||
|
||||
//=== VK_NV_shader_atomic_float16_vector ===
|
||||
using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion;
|
||||
|
||||
//=== VK_NV_ray_tracing_validation ===
|
||||
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationSpecVersion;
|
||||
|
||||
//========================
|
||||
//=== CONSTEXPR VALUEs ===
|
||||
//========================
|
||||
@ -3531,9 +3588,17 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_AMD_device_coherent_memory ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD;
|
||||
|
||||
//=== VK_KHR_dynamic_rendering_local_read ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR;
|
||||
|
||||
//=== VK_EXT_shader_image_atomic_int64 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
|
||||
|
||||
//=== VK_KHR_shader_quad_control ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR;
|
||||
|
||||
//=== VK_EXT_memory_budget ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT;
|
||||
|
||||
@ -3589,17 +3654,9 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_EXT_headless_surface ===
|
||||
using VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT;
|
||||
|
||||
//=== VK_EXT_line_rasterization ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT;
|
||||
|
||||
//=== VK_EXT_shader_atomic_float ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT;
|
||||
|
||||
//=== VK_EXT_index_type_uint8 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT;
|
||||
|
||||
//=== VK_EXT_extended_dynamic_state ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT;
|
||||
|
||||
@ -3629,6 +3686,11 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR;
|
||||
|
||||
//=== VK_EXT_map_memory_placed ===
|
||||
using VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT;
|
||||
|
||||
//=== VK_EXT_shader_atomic_float2 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
|
||||
|
||||
@ -3986,6 +4048,9 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_ARM_shader_core_properties ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM;
|
||||
|
||||
//=== VK_KHR_shader_subgroup_rotate ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR;
|
||||
|
||||
//=== VK_ARM_scheduling_controls ===
|
||||
using VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM;
|
||||
@ -4038,6 +4103,9 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_NV_linear_color_attachment ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV;
|
||||
|
||||
//=== VK_KHR_shader_maximal_reconvergence ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
|
||||
|
||||
//=== VK_EXT_image_compression_control_swapchain ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
|
||||
|
||||
@ -4184,6 +4252,13 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
|
||||
|
||||
//=== VK_KHR_video_decode_av1 ===
|
||||
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR;
|
||||
|
||||
//=== VK_KHR_video_maintenance1 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR;
|
||||
@ -4220,6 +4295,9 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT;
|
||||
using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR;
|
||||
|
||||
//=== VK_KHR_shader_float_controls2 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
using VULKAN_HPP_NAMESPACE::ExternalFormatQNX;
|
||||
@ -4232,10 +4310,25 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_MSFT_layered_driver ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT;
|
||||
|
||||
//=== VK_KHR_index_type_uint8 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR;
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR;
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR;
|
||||
|
||||
//=== VK_KHR_shader_expect_assume ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR;
|
||||
|
||||
//=== VK_KHR_maintenance6 ===
|
||||
using VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR;
|
||||
@ -4250,6 +4343,15 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_NV_descriptor_pool_overallocation ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
|
||||
|
||||
//=== VK_NV_raw_access_chains ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV;
|
||||
|
||||
//=== VK_NV_shader_atomic_float16_vector ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
|
||||
|
||||
//=== VK_NV_ray_tracing_validation ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV;
|
||||
|
||||
//===============
|
||||
//=== HANDLEs ===
|
||||
//===============
|
||||
|
725
thirdparty/vulkan/include/vulkan/vulkan.hpp
vendored
725
thirdparty/vulkan/include/vulkan/vulkan.hpp
vendored
File diff suppressed because it is too large
Load Diff
403
thirdparty/vulkan/include/vulkan/vulkan_core.h
vendored
403
thirdparty/vulkan/include/vulkan/vulkan_core.h
vendored
@ -69,7 +69,7 @@ extern "C" {
|
||||
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
|
||||
|
||||
// Version of this file
|
||||
#define VK_HEADER_VERSION 275
|
||||
#define VK_HEADER_VERSION 283
|
||||
|
||||
// Complete version of this file
|
||||
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
|
||||
@ -184,7 +184,7 @@ typedef enum VkResult {
|
||||
VK_OPERATION_NOT_DEFERRED_KHR = 1000268003,
|
||||
VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000,
|
||||
VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000,
|
||||
VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000,
|
||||
VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000,
|
||||
VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
|
||||
VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
|
||||
VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION,
|
||||
@ -193,6 +193,7 @@ typedef enum VkResult {
|
||||
VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
|
||||
VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED,
|
||||
VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED,
|
||||
VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT,
|
||||
VK_RESULT_MAX_ENUM = 0x7FFFFFFF
|
||||
} VkResult;
|
||||
|
||||
@ -718,7 +719,11 @@ typedef enum VkStructureType {
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR = 1000232000,
|
||||
VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR = 1000232001,
|
||||
VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR = 1000232002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
|
||||
VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
|
||||
@ -743,11 +748,7 @@ typedef enum VkStructureType {
|
||||
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
|
||||
VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
|
||||
VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
|
||||
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
|
||||
VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
|
||||
@ -767,6 +768,9 @@ typedef enum VkStructureType {
|
||||
VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = 1000270009,
|
||||
VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000,
|
||||
VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT = 1000272000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT = 1000272001,
|
||||
VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT = 1000272002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000,
|
||||
VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000,
|
||||
VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001,
|
||||
@ -959,6 +963,7 @@ typedef enum VkStructureType {
|
||||
VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = 1000416000,
|
||||
VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002,
|
||||
@ -985,6 +990,7 @@ typedef enum VkStructureType {
|
||||
VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001,
|
||||
VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001,
|
||||
@ -1059,6 +1065,11 @@ typedef enum VkStructureType {
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000,
|
||||
VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001,
|
||||
VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000,
|
||||
VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001,
|
||||
VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003,
|
||||
VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004,
|
||||
VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000,
|
||||
VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000,
|
||||
@ -1075,13 +1086,19 @@ typedef enum VkStructureType {
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = 1000525000,
|
||||
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = 1000190001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = 1000190002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR = 1000528000,
|
||||
VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000,
|
||||
VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001,
|
||||
VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002,
|
||||
VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR = 1000265000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR = 1000259000,
|
||||
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR = 1000259001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR = 1000259002,
|
||||
VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR = 1000544000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR = 1000545000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR = 1000545001,
|
||||
VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR = 1000545002,
|
||||
@ -1092,6 +1109,9 @@ typedef enum VkStructureType {
|
||||
VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007,
|
||||
VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
|
||||
VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
|
||||
@ -1227,7 +1247,11 @@ typedef enum VkStructureType {
|
||||
VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
|
||||
VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
|
||||
VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR,
|
||||
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES,
|
||||
@ -1304,6 +1328,7 @@ typedef enum VkImageLayout {
|
||||
VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
|
||||
VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
|
||||
VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003,
|
||||
VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR = 1000232000,
|
||||
VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000,
|
||||
VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001,
|
||||
VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002,
|
||||
@ -1651,7 +1676,7 @@ typedef enum VkFormat {
|
||||
VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
|
||||
VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
|
||||
VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
|
||||
VK_FORMAT_R16G16_S10_5_NV = 1000464000,
|
||||
VK_FORMAT_R16G16_SFIXED5_NV = 1000464000,
|
||||
VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = 1000470000,
|
||||
VK_FORMAT_A8_UNORM_KHR = 1000470001,
|
||||
VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK,
|
||||
@ -1708,6 +1733,7 @@ typedef enum VkFormat {
|
||||
VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM,
|
||||
VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16,
|
||||
VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16,
|
||||
VK_FORMAT_R16G16_S10_5_NV = VK_FORMAT_R16G16_SFIXED5_NV,
|
||||
VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
|
||||
} VkFormat;
|
||||
|
||||
@ -1909,12 +1935,10 @@ typedef enum VkDynamicState {
|
||||
VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000,
|
||||
VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
|
||||
VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
|
||||
VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
|
||||
VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000,
|
||||
VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000,
|
||||
VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,
|
||||
VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,
|
||||
VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002,
|
||||
VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003,
|
||||
VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004,
|
||||
VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005,
|
||||
@ -1925,6 +1949,7 @@ typedef enum VkDynamicState {
|
||||
VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010,
|
||||
VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011,
|
||||
VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012,
|
||||
VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002,
|
||||
VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013,
|
||||
VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014,
|
||||
VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015,
|
||||
@ -1946,6 +1971,8 @@ typedef enum VkDynamicState {
|
||||
VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031,
|
||||
VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032,
|
||||
VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000,
|
||||
VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = 1000259000,
|
||||
VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR,
|
||||
VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE,
|
||||
VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE,
|
||||
VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,
|
||||
@ -2094,7 +2121,8 @@ typedef enum VkAttachmentLoadOp {
|
||||
VK_ATTACHMENT_LOAD_OP_LOAD = 0,
|
||||
VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
|
||||
VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
|
||||
VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000,
|
||||
VK_ATTACHMENT_LOAD_OP_NONE_KHR = 1000400000,
|
||||
VK_ATTACHMENT_LOAD_OP_NONE_EXT = VK_ATTACHMENT_LOAD_OP_NONE_KHR,
|
||||
VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
|
||||
} VkAttachmentLoadOp;
|
||||
|
||||
@ -2130,8 +2158,9 @@ typedef enum VkIndexType {
|
||||
VK_INDEX_TYPE_UINT16 = 0,
|
||||
VK_INDEX_TYPE_UINT32 = 1,
|
||||
VK_INDEX_TYPE_NONE_KHR = 1000165000,
|
||||
VK_INDEX_TYPE_UINT8_EXT = 1000265000,
|
||||
VK_INDEX_TYPE_UINT8_KHR = 1000265000,
|
||||
VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR,
|
||||
VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8_KHR,
|
||||
VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
|
||||
} VkIndexType;
|
||||
|
||||
@ -2403,6 +2432,11 @@ typedef enum VkPipelineStageFlagBits {
|
||||
VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
|
||||
} VkPipelineStageFlagBits;
|
||||
typedef VkFlags VkPipelineStageFlags;
|
||||
|
||||
typedef enum VkMemoryMapFlagBits {
|
||||
VK_MEMORY_MAP_PLACED_BIT_EXT = 0x00000001,
|
||||
VK_MEMORY_MAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
|
||||
} VkMemoryMapFlagBits;
|
||||
typedef VkFlags VkMemoryMapFlags;
|
||||
|
||||
typedef enum VkSparseMemoryBindFlagBits {
|
||||
@ -4922,6 +4956,8 @@ typedef enum VkSubgroupFeatureFlagBits {
|
||||
VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
|
||||
VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
|
||||
VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
|
||||
VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = 0x00000200,
|
||||
VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = 0x00000400,
|
||||
VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
|
||||
} VkSubgroupFeatureFlagBits;
|
||||
typedef VkFlags VkSubgroupFeatureFlags;
|
||||
@ -7961,6 +7997,7 @@ typedef enum VkVideoCodecOperationFlagBitsKHR {
|
||||
VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 0x00020000,
|
||||
VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001,
|
||||
VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002,
|
||||
VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 0x00000004,
|
||||
VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoCodecOperationFlagBitsKHR;
|
||||
typedef VkFlags VkVideoCodecOperationFlagsKHR;
|
||||
@ -10196,6 +10233,58 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_KHR_dynamic_rendering_local_read is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_dynamic_rendering_local_read 1
|
||||
#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1
|
||||
#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME "VK_KHR_dynamic_rendering_local_read"
|
||||
typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 dynamicRenderingLocalRead;
|
||||
} VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
|
||||
|
||||
typedef struct VkRenderingAttachmentLocationInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t colorAttachmentCount;
|
||||
const uint32_t* pColorAttachmentLocations;
|
||||
} VkRenderingAttachmentLocationInfoKHR;
|
||||
|
||||
typedef struct VkRenderingInputAttachmentIndexInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t colorAttachmentCount;
|
||||
const uint32_t* pColorAttachmentInputIndices;
|
||||
const uint32_t* pDepthInputAttachmentIndex;
|
||||
const uint32_t* pStencilInputAttachmentIndex;
|
||||
} VkRenderingInputAttachmentIndexInfoKHR;
|
||||
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocationsKHR)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR* pLocationInfo);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR* pLocationInfo);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR(
|
||||
VkCommandBuffer commandBuffer,
|
||||
const VkRenderingAttachmentLocationInfoKHR* pLocationInfo);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(
|
||||
VkCommandBuffer commandBuffer,
|
||||
const VkRenderingInputAttachmentIndexInfoKHR* pLocationInfo);
|
||||
#endif
|
||||
|
||||
|
||||
// VK_KHR_shader_quad_control is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_shader_quad_control 1
|
||||
#define VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION 1
|
||||
#define VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME "VK_KHR_shader_quad_control"
|
||||
typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 shaderQuadControl;
|
||||
} VkPhysicalDeviceShaderQuadControlFeaturesKHR;
|
||||
|
||||
|
||||
|
||||
// VK_KHR_spirv_1_4 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_spirv_1_4 1
|
||||
#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1
|
||||
@ -10419,6 +10508,11 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR
|
||||
#define VK_KHR_map_memory2 1
|
||||
#define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1
|
||||
#define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2"
|
||||
|
||||
typedef enum VkMemoryUnmapFlagBitsKHR {
|
||||
VK_MEMORY_UNMAP_RESERVE_BIT_EXT = 0x00000001,
|
||||
VK_MEMORY_UNMAP_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkMemoryUnmapFlagBitsKHR;
|
||||
typedef VkFlags VkMemoryUnmapFlagsKHR;
|
||||
typedef struct VkMemoryMapInfoKHR {
|
||||
VkStructureType sType;
|
||||
@ -10512,6 +10606,10 @@ typedef enum VkVideoEncodeTuningModeKHR {
|
||||
VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4,
|
||||
VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoEncodeTuningModeKHR;
|
||||
|
||||
typedef enum VkVideoEncodeFlagBitsKHR {
|
||||
VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoEncodeFlagBitsKHR;
|
||||
typedef VkFlags VkVideoEncodeFlagsKHR;
|
||||
|
||||
typedef enum VkVideoEncodeCapabilityFlagBitsKHR {
|
||||
@ -10976,6 +11074,31 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_KHR_shader_subgroup_rotate is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_shader_subgroup_rotate 1
|
||||
#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 2
|
||||
#define VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME "VK_KHR_shader_subgroup_rotate"
|
||||
typedef struct VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 shaderSubgroupRotate;
|
||||
VkBool32 shaderSubgroupRotateClustered;
|
||||
} VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR;
|
||||
|
||||
|
||||
|
||||
// VK_KHR_shader_maximal_reconvergence is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_shader_maximal_reconvergence 1
|
||||
#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION 1
|
||||
#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME "VK_KHR_shader_maximal_reconvergence"
|
||||
typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 shaderMaximalReconvergence;
|
||||
} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
|
||||
|
||||
|
||||
|
||||
// VK_KHR_maintenance5 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_maintenance5 1
|
||||
#define VK_KHR_MAINTENANCE_5_SPEC_VERSION 1
|
||||
@ -10987,6 +11110,7 @@ typedef VkFlags64 VkPipelineCreateFlagBits2KHR;
|
||||
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL;
|
||||
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL;
|
||||
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL;
|
||||
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL;
|
||||
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL;
|
||||
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL;
|
||||
static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL;
|
||||
@ -11037,12 +11161,8 @@ static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFF
|
||||
static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000ULL;
|
||||
static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000ULL;
|
||||
static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00004000ULL;
|
||||
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
||||
static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000ULL;
|
||||
#endif
|
||||
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
||||
static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000ULL;
|
||||
#endif
|
||||
static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000ULL;
|
||||
static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000ULL;
|
||||
static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000ULL;
|
||||
@ -11232,6 +11352,51 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR
|
||||
#endif
|
||||
|
||||
|
||||
// VK_KHR_video_decode_av1 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_video_decode_av1 1
|
||||
#include "vk_video/vulkan_video_codec_av1std.h"
|
||||
#include "vk_video/vulkan_video_codec_av1std_decode.h"
|
||||
#define VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR 7U
|
||||
#define VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION 1
|
||||
#define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1"
|
||||
typedef struct VkVideoDecodeAV1ProfileInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
StdVideoAV1Profile stdProfile;
|
||||
VkBool32 filmGrainSupport;
|
||||
} VkVideoDecodeAV1ProfileInfoKHR;
|
||||
|
||||
typedef struct VkVideoDecodeAV1CapabilitiesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
StdVideoAV1Level maxLevel;
|
||||
} VkVideoDecodeAV1CapabilitiesKHR;
|
||||
|
||||
typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const StdVideoAV1SequenceHeader* pStdSequenceHeader;
|
||||
} VkVideoDecodeAV1SessionParametersCreateInfoKHR;
|
||||
|
||||
typedef struct VkVideoDecodeAV1PictureInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const StdVideoDecodeAV1PictureInfo* pStdPictureInfo;
|
||||
int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR];
|
||||
uint32_t frameHeaderOffset;
|
||||
uint32_t tileCount;
|
||||
const uint32_t* pTileOffsets;
|
||||
const uint32_t* pTileSizes;
|
||||
} VkVideoDecodeAV1PictureInfoKHR;
|
||||
|
||||
typedef struct VkVideoDecodeAV1DpbSlotInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo;
|
||||
} VkVideoDecodeAV1DpbSlotInfoKHR;
|
||||
|
||||
|
||||
|
||||
// VK_KHR_video_maintenance1 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_video_maintenance1 1
|
||||
#define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1
|
||||
@ -11284,6 +11449,88 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR {
|
||||
|
||||
|
||||
|
||||
// VK_KHR_load_store_op_none is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_load_store_op_none 1
|
||||
#define VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION 1
|
||||
#define VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_KHR_load_store_op_none"
|
||||
|
||||
|
||||
// VK_KHR_shader_float_controls2 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_shader_float_controls2 1
|
||||
#define VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION 1
|
||||
#define VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME "VK_KHR_shader_float_controls2"
|
||||
typedef struct VkPhysicalDeviceShaderFloatControls2FeaturesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 shaderFloatControls2;
|
||||
} VkPhysicalDeviceShaderFloatControls2FeaturesKHR;
|
||||
|
||||
|
||||
|
||||
// VK_KHR_index_type_uint8 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_index_type_uint8 1
|
||||
#define VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION 1
|
||||
#define VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_KHR_index_type_uint8"
|
||||
typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 indexTypeUint8;
|
||||
} VkPhysicalDeviceIndexTypeUint8FeaturesKHR;
|
||||
|
||||
|
||||
|
||||
// VK_KHR_line_rasterization is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_line_rasterization 1
|
||||
#define VK_KHR_LINE_RASTERIZATION_SPEC_VERSION 1
|
||||
#define VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME "VK_KHR_line_rasterization"
|
||||
|
||||
typedef enum VkLineRasterizationModeKHR {
|
||||
VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = 0,
|
||||
VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = 1,
|
||||
VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = 2,
|
||||
VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = 3,
|
||||
VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR,
|
||||
VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR,
|
||||
VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR,
|
||||
VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR,
|
||||
VK_LINE_RASTERIZATION_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkLineRasterizationModeKHR;
|
||||
typedef struct VkPhysicalDeviceLineRasterizationFeaturesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 rectangularLines;
|
||||
VkBool32 bresenhamLines;
|
||||
VkBool32 smoothLines;
|
||||
VkBool32 stippledRectangularLines;
|
||||
VkBool32 stippledBresenhamLines;
|
||||
VkBool32 stippledSmoothLines;
|
||||
} VkPhysicalDeviceLineRasterizationFeaturesKHR;
|
||||
|
||||
typedef struct VkPhysicalDeviceLineRasterizationPropertiesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
uint32_t lineSubPixelPrecisionBits;
|
||||
} VkPhysicalDeviceLineRasterizationPropertiesKHR;
|
||||
|
||||
typedef struct VkPipelineRasterizationLineStateCreateInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkLineRasterizationModeKHR lineRasterizationMode;
|
||||
VkBool32 stippledLineEnable;
|
||||
uint32_t lineStippleFactor;
|
||||
uint16_t lineStipplePattern;
|
||||
} VkPipelineRasterizationLineStateCreateInfoKHR;
|
||||
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleKHR)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR(
|
||||
VkCommandBuffer commandBuffer,
|
||||
uint32_t lineStippleFactor,
|
||||
uint16_t lineStipplePattern);
|
||||
#endif
|
||||
|
||||
|
||||
// VK_KHR_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_calibrated_timestamps 1
|
||||
#define VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1
|
||||
@ -11324,6 +11571,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_KHR_shader_expect_assume is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_shader_expect_assume 1
|
||||
#define VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION 1
|
||||
#define VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME "VK_KHR_shader_expect_assume"
|
||||
typedef struct VkPhysicalDeviceShaderExpectAssumeFeaturesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 shaderExpectAssume;
|
||||
} VkPhysicalDeviceShaderExpectAssumeFeaturesKHR;
|
||||
|
||||
|
||||
|
||||
// VK_KHR_maintenance6 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_maintenance6 1
|
||||
#define VK_KHR_MAINTENANCE_6_SPEC_VERSION 1
|
||||
@ -14652,39 +14911,13 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(
|
||||
#define VK_EXT_line_rasterization 1
|
||||
#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
|
||||
#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
|
||||
typedef VkLineRasterizationModeKHR VkLineRasterizationModeEXT;
|
||||
|
||||
typedef enum VkLineRasterizationModeEXT {
|
||||
VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
|
||||
VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
|
||||
VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
|
||||
VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
|
||||
VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkLineRasterizationModeEXT;
|
||||
typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 rectangularLines;
|
||||
VkBool32 bresenhamLines;
|
||||
VkBool32 smoothLines;
|
||||
VkBool32 stippledRectangularLines;
|
||||
VkBool32 stippledBresenhamLines;
|
||||
VkBool32 stippledSmoothLines;
|
||||
} VkPhysicalDeviceLineRasterizationFeaturesEXT;
|
||||
typedef VkPhysicalDeviceLineRasterizationFeaturesKHR VkPhysicalDeviceLineRasterizationFeaturesEXT;
|
||||
|
||||
typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
uint32_t lineSubPixelPrecisionBits;
|
||||
} VkPhysicalDeviceLineRasterizationPropertiesEXT;
|
||||
typedef VkPhysicalDeviceLineRasterizationPropertiesKHR VkPhysicalDeviceLineRasterizationPropertiesEXT;
|
||||
|
||||
typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkLineRasterizationModeEXT lineRasterizationMode;
|
||||
VkBool32 stippledLineEnable;
|
||||
uint32_t lineStippleFactor;
|
||||
uint16_t lineStipplePattern;
|
||||
} VkPipelineRasterizationLineStateCreateInfoEXT;
|
||||
typedef VkPipelineRasterizationLineStateCreateInfoKHR VkPipelineRasterizationLineStateCreateInfoEXT;
|
||||
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
|
||||
|
||||
@ -14740,11 +14973,7 @@ VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(
|
||||
#define VK_EXT_index_type_uint8 1
|
||||
#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
|
||||
#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
|
||||
typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 indexTypeUint8;
|
||||
} VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
|
||||
typedef VkPhysicalDeviceIndexTypeUint8FeaturesKHR VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
|
||||
|
||||
|
||||
|
||||
@ -14972,6 +15201,32 @@ VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_EXT_map_memory_placed is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_map_memory_placed 1
|
||||
#define VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION 1
|
||||
#define VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME "VK_EXT_map_memory_placed"
|
||||
typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 memoryMapPlaced;
|
||||
VkBool32 memoryMapRangePlaced;
|
||||
VkBool32 memoryUnmapReserve;
|
||||
} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT;
|
||||
|
||||
typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkDeviceSize minPlacedMemoryMapAlignment;
|
||||
} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT;
|
||||
|
||||
typedef struct VkMemoryMapPlacedInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
void* pPlacedAddress;
|
||||
} VkMemoryMapPlacedInfoEXT;
|
||||
|
||||
|
||||
|
||||
// VK_EXT_shader_atomic_float2 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_shader_atomic_float2 1
|
||||
#define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1
|
||||
@ -17769,7 +18024,6 @@ typedef struct VkColorBlendAdvancedEXT {
|
||||
VkBool32 clampResults;
|
||||
} VkColorBlendAdvancedEXT;
|
||||
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples);
|
||||
@ -17780,6 +18034,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBu
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize);
|
||||
@ -17802,10 +18057,6 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkComma
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(
|
||||
VkCommandBuffer commandBuffer,
|
||||
VkTessellationDomainOrigin domainOrigin);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(
|
||||
VkCommandBuffer commandBuffer,
|
||||
VkBool32 depthClampEnable);
|
||||
@ -17853,6 +18104,10 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(
|
||||
uint32_t attachmentCount,
|
||||
const VkColorComponentFlags* pColorWriteMasks);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(
|
||||
VkCommandBuffer commandBuffer,
|
||||
VkTessellationDomainOrigin domainOrigin);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(
|
||||
VkCommandBuffer commandBuffer,
|
||||
uint32_t rasterizationStream);
|
||||
@ -18249,7 +18504,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(
|
||||
|
||||
// VK_EXT_legacy_dithering is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_legacy_dithering 1
|
||||
#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 1
|
||||
#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 2
|
||||
#define VK_EXT_LEGACY_DITHERING_EXTENSION_NAME "VK_EXT_legacy_dithering"
|
||||
typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT {
|
||||
VkStructureType sType;
|
||||
@ -18858,6 +19113,42 @@ typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
|
||||
|
||||
|
||||
|
||||
// VK_NV_raw_access_chains is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_raw_access_chains 1
|
||||
#define VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION 1
|
||||
#define VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME "VK_NV_raw_access_chains"
|
||||
typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 shaderRawAccessChains;
|
||||
} VkPhysicalDeviceRawAccessChainsFeaturesNV;
|
||||
|
||||
|
||||
|
||||
// VK_NV_shader_atomic_float16_vector is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_shader_atomic_float16_vector 1
|
||||
#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION 1
|
||||
#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME "VK_NV_shader_atomic_float16_vector"
|
||||
typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 shaderFloat16VectorAtomics;
|
||||
} VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
|
||||
|
||||
|
||||
|
||||
// VK_NV_ray_tracing_validation is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_ray_tracing_validation 1
|
||||
#define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1
|
||||
#define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation"
|
||||
typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 rayTracingValidation;
|
||||
} VkPhysicalDeviceRayTracingValidationFeaturesNV;
|
||||
|
||||
|
||||
|
||||
// VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_acceleration_structure 1
|
||||
#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13
|
||||
|
1837
thirdparty/vulkan/include/vulkan/vulkan_enums.hpp
vendored
1837
thirdparty/vulkan/include/vulkan/vulkan_enums.hpp
vendored
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -362,7 +362,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return 8;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 8;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 8;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 2;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
|
||||
|
||||
@ -621,7 +621,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return "PVRTC1_4BPP";
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return "PVRTC2_2BPP";
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return "PVRTC2_4BPP";
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return "32-bit";
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return "32-bit";
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return "16-bit";
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return "8-bit alpha";
|
||||
|
||||
@ -2005,7 +2005,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case 3: return 4;
|
||||
default: VULKAN_HPP_ASSERT( false ); return 0;
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV:
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return 16;
|
||||
@ -2283,7 +2283,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return 2;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 2;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
|
||||
|
||||
@ -4299,7 +4299,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case 3: return "A";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV:
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
@ -6334,11 +6334,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV:
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "SINT";
|
||||
case 1: return "SINT";
|
||||
case 0: return "SFIXED5";
|
||||
case 1: return "SFIXED5";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
|
||||
@ -7657,7 +7657,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
|
||||
|
||||
|
5160
thirdparty/vulkan/include/vulkan/vulkan_funcs.hpp
vendored
5160
thirdparty/vulkan/include/vulkan/vulkan_funcs.hpp
vendored
File diff suppressed because it is too large
Load Diff
1131
thirdparty/vulkan/include/vulkan/vulkan_handles.hpp
vendored
1131
thirdparty/vulkan/include/vulkan/vulkan_handles.hpp
vendored
File diff suppressed because it is too large
Load Diff
333
thirdparty/vulkan/include/vulkan/vulkan_hash.hpp
vendored
333
thirdparty/vulkan/include/vulkan/vulkan_hash.hpp
vendored
@ -6815,6 +6815,19 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT const & memoryMapPlacedInfoEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pPlacedAddress );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
|
||||
{
|
||||
@ -8355,6 +8368,21 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const & physicalDeviceDynamicRenderingLocalReadFeaturesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeaturesKHR.dynamicRenderingLocalRead );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>
|
||||
{
|
||||
@ -9282,15 +9310,15 @@ namespace std
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const & physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR const & physicalDeviceIndexTypeUint8FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8FeaturesKHR.indexTypeUint8 );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
@ -9519,34 +9547,34 @@ namespace std
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const & physicalDeviceLineRasterizationFeaturesEXT ) const
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR const & physicalDeviceLineRasterizationFeaturesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.rectangularLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.bresenhamLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.smoothLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledRectangularLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledBresenhamLines );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeaturesKHR.stippledSmoothLines );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const & physicalDeviceLineRasterizationPropertiesEXT ) const
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR const & physicalDeviceLineRasterizationPropertiesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationPropertiesKHR.lineSubPixelPrecisionBits );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
@ -9668,6 +9696,36 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT const & physicalDeviceMapMemoryPlacedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapPlaced );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapRangePlaced );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryUnmapReserve );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT const & physicalDeviceMapMemoryPlacedPropertiesEXT ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.minPlacedMemoryMapAlignment );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT>
|
||||
{
|
||||
@ -10595,6 +10653,20 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV const & physicalDeviceRawAccessChainsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.shaderRawAccessChains );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR>
|
||||
{
|
||||
@ -10740,6 +10812,20 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const & physicalDeviceRayTracingValidationFeaturesNV ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.rayTracingValidation );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG>
|
||||
{
|
||||
@ -10934,6 +11020,20 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & physicalDeviceShaderAtomicFloat16VectorFeaturesNV )
|
||||
const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.shaderFloat16VectorAtomics );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
|
||||
{
|
||||
@ -11179,6 +11279,20 @@ namespace std
|
||||
};
|
||||
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR const & physicalDeviceShaderExpectAssumeFeaturesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeaturesKHR.shaderExpectAssume );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features>
|
||||
{
|
||||
@ -11194,6 +11308,20 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR const & physicalDeviceShaderFloatControls2FeaturesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2FeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2FeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2FeaturesKHR.shaderFloatControls2 );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
|
||||
{
|
||||
@ -11296,6 +11424,21 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & physicalDeviceShaderMaximalReconvergenceFeaturesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.shaderMaximalReconvergence );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT>
|
||||
{
|
||||
@ -11359,6 +11502,20 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR const & physicalDeviceShaderQuadControlFeaturesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.shaderQuadControl );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV>
|
||||
{
|
||||
@ -11402,6 +11559,21 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR const & physicalDeviceShaderSubgroupRotateFeaturesKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.shaderSubgroupRotate );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeaturesKHR.shaderSubgroupRotateClustered );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>
|
||||
{
|
||||
@ -12688,18 +12860,18 @@ namespace std
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const & pipelineRasterizationLineStateCreateInfoEXT ) const
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR const & pipelineRasterizationLineStateCreateInfoKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineRasterizationMode );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.stippledLineEnable );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineStippleFactor );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfoKHR.lineStipplePattern );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
@ -13914,6 +14086,20 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR const & renderingAttachmentLocationInfoKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.colorAttachmentCount );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfoKHR.pColorAttachmentLocations );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
|
||||
{
|
||||
@ -13965,6 +14151,22 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR const & renderingInputAttachmentIndexInfoKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.colorAttachmentCount );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pColorAttachmentInputIndices );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pDepthInputAttachmentIndex );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfoKHR.pStencilInputAttachmentIndex );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2>
|
||||
{
|
||||
@ -15287,6 +15489,81 @@ namespace std
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR const & videoDecodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.maxLevel );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR const & videoDecodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pStdReferenceInfo );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR const & videoDecodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pStdPictureInfo );
|
||||
for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i )
|
||||
{
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.referenceNameSlotIndices[i] );
|
||||
}
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.frameHeaderOffset );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.tileCount );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileOffsets );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileSizes );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR const & videoDecodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.stdProfile );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.filmGrainSupport );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR const & videoDecodeAV1SessionParametersCreateInfoKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR>
|
||||
{
|
||||
|
@ -88,10 +88,11 @@
|
||||
#endif
|
||||
|
||||
// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
|
||||
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
|
||||
// To enable this feature on 32-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 1
|
||||
// To disable this feature on 64-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 0
|
||||
#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
||||
# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
|
||||
# define VULKAN_HPP_TYPESAFE_CONVERSION
|
||||
# define VULKAN_HPP_TYPESAFE_CONVERSION 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
@ -131,7 +132,7 @@
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
|
||||
#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
||||
# define VULKAN_HPP_TYPESAFE_EXPLICIT
|
||||
#else
|
||||
# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
|
||||
|
12
thirdparty/vulkan/include/vulkan/vulkan_metal.h
vendored
12
thirdparty/vulkan/include/vulkan/vulkan_metal.h
vendored
@ -52,28 +52,28 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
|
||||
#define VK_EXT_metal_objects 1
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLDevice;
|
||||
typedef id<MTLDevice> MTLDevice_id;
|
||||
typedef __unsafe_unretained id<MTLDevice> MTLDevice_id;
|
||||
#else
|
||||
typedef void* MTLDevice_id;
|
||||
#endif
|
||||
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLCommandQueue;
|
||||
typedef id<MTLCommandQueue> MTLCommandQueue_id;
|
||||
typedef __unsafe_unretained id<MTLCommandQueue> MTLCommandQueue_id;
|
||||
#else
|
||||
typedef void* MTLCommandQueue_id;
|
||||
#endif
|
||||
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLBuffer;
|
||||
typedef id<MTLBuffer> MTLBuffer_id;
|
||||
typedef __unsafe_unretained id<MTLBuffer> MTLBuffer_id;
|
||||
#else
|
||||
typedef void* MTLBuffer_id;
|
||||
#endif
|
||||
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLTexture;
|
||||
typedef id<MTLTexture> MTLTexture_id;
|
||||
typedef __unsafe_unretained id<MTLTexture> MTLTexture_id;
|
||||
#else
|
||||
typedef void* MTLTexture_id;
|
||||
#endif
|
||||
@ -81,12 +81,12 @@ typedef void* MTLTexture_id;
|
||||
typedef struct __IOSurface* IOSurfaceRef;
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLSharedEvent;
|
||||
typedef id<MTLSharedEvent> MTLSharedEvent_id;
|
||||
typedef __unsafe_unretained id<MTLSharedEvent> MTLSharedEvent_id;
|
||||
#else
|
||||
typedef void* MTLSharedEvent_id;
|
||||
#endif
|
||||
|
||||
#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 1
|
||||
#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 2
|
||||
#define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects"
|
||||
|
||||
typedef enum VkExportMetalObjectTypeFlagBitsEXT {
|
||||
|
1159
thirdparty/vulkan/include/vulkan/vulkan_raii.hpp
vendored
1159
thirdparty/vulkan/include/vulkan/vulkan_raii.hpp
vendored
File diff suppressed because it is too large
Load Diff
@ -182,6 +182,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
return bool( m_handle );
|
||||
}
|
||||
|
||||
# if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST )
|
||||
operator HandleType() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_handle;
|
||||
}
|
||||
# endif
|
||||
|
||||
const HandleType * operator->() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return &m_handle;
|
||||
|
@ -4278,6 +4278,30 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>::value,
|
||||
"PhysicalDeviceCoherentMemoryFeaturesAMD is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_dynamic_rendering_local_read ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>::value,
|
||||
"PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR ) == sizeof( VkRenderingAttachmentLocationInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR>::value,
|
||||
"RenderingAttachmentLocationInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR ) == sizeof( VkRenderingInputAttachmentIndexInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR>::value,
|
||||
"RenderingInputAttachmentIndexInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_shader_image_atomic_int64 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT ) ==
|
||||
@ -4288,6 +4312,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>::value,
|
||||
"PhysicalDeviceShaderImageAtomicInt64FeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_shader_quad_control ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderQuadControlFeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR>::value,
|
||||
"PhysicalDeviceShaderQuadControlFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_memory_budget ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ),
|
||||
@ -4485,31 +4518,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Headless
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT>::value,
|
||||
"HeadlessSurfaceCreateInfoEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_line_rasterization ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>::value,
|
||||
"PhysicalDeviceLineRasterizationFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT ) ==
|
||||
sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>::value,
|
||||
"PhysicalDeviceLineRasterizationPropertiesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT ) ==
|
||||
sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>::value,
|
||||
"PipelineRasterizationLineStateCreateInfoEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_shader_atomic_float ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT ),
|
||||
@ -4519,15 +4527,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT>::value,
|
||||
"PhysicalDeviceShaderAtomicFloatFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_index_type_uint8 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>::value,
|
||||
"PhysicalDeviceIndexTypeUint8FeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_extended_dynamic_state ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT ) ==
|
||||
@ -4667,6 +4666,28 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryUn
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR>::value,
|
||||
"MemoryUnmapInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_map_memory_placed ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT ) == sizeof( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT>::value,
|
||||
"PhysicalDeviceMapMemoryPlacedFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT ) == sizeof( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT>::value,
|
||||
"PhysicalDeviceMapMemoryPlacedPropertiesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT ) == sizeof( VkMemoryMapPlacedInfoEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT>::value,
|
||||
"MemoryMapPlacedInfoEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_shader_atomic_float2 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT ) ==
|
||||
@ -6230,6 +6251,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM>::value,
|
||||
"PhysicalDeviceShaderCorePropertiesARM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_shader_subgroup_rotate ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR>::value,
|
||||
"PhysicalDeviceShaderSubgroupRotateFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_ARM_scheduling_controls ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM ) == sizeof( VkDeviceQueueShaderCoreControlCreateInfoARM ),
|
||||
@ -6468,6 +6499,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>::value,
|
||||
"PhysicalDeviceLinearColorAttachmentFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_shader_maximal_reconvergence ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>::value,
|
||||
"PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_image_compression_control_swapchain ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT ) ==
|
||||
@ -7085,6 +7126,40 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Multivie
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>::value,
|
||||
"MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_video_decode_av1 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR ) == sizeof( VkVideoDecodeAV1ProfileInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR>::value,
|
||||
"VideoDecodeAV1ProfileInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR ) == sizeof( VkVideoDecodeAV1CapabilitiesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR>::value,
|
||||
"VideoDecodeAV1CapabilitiesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR ) ==
|
||||
sizeof( VkVideoDecodeAV1SessionParametersCreateInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR>::value,
|
||||
"VideoDecodeAV1SessionParametersCreateInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR ) == sizeof( VkVideoDecodeAV1PictureInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR>::value,
|
||||
"VideoDecodeAV1PictureInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR ) == sizeof( VkVideoDecodeAV1DpbSlotInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR>::value,
|
||||
"VideoDecodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_video_maintenance1 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance1FeaturesKHR ),
|
||||
@ -7224,6 +7299,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR>::value,
|
||||
"PhysicalDeviceVertexAttributeDivisorFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_shader_float_controls2 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceShaderFloatControls2FeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR>::value,
|
||||
"PhysicalDeviceShaderFloatControls2FeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
|
||||
@ -7268,6 +7353,40 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value,
|
||||
"PhysicalDeviceLayeredDriverPropertiesMSFT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_index_type_uint8 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR>::value,
|
||||
"PhysicalDeviceIndexTypeUint8FeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>::value,
|
||||
"PhysicalDeviceLineRasterizationFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceLineRasterizationPropertiesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR>::value,
|
||||
"PhysicalDeviceLineRasterizationPropertiesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR ) ==
|
||||
sizeof( VkPipelineRasterizationLineStateCreateInfoKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR>::value,
|
||||
"PipelineRasterizationLineStateCreateInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR ) == sizeof( VkCalibratedTimestampInfoKHR ),
|
||||
@ -7276,6 +7395,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Calibrat
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>::value,
|
||||
"CalibratedTimestampInfoKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_shader_expect_assume ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR ) ==
|
||||
sizeof( VkPhysicalDeviceShaderExpectAssumeFeaturesKHR ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR>::value,
|
||||
"PhysicalDeviceShaderExpectAssumeFeaturesKHR is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_maintenance6 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance6FeaturesKHR ),
|
||||
@ -7345,4 +7474,33 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>::value,
|
||||
"PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_raw_access_chains ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV ) == sizeof( VkPhysicalDeviceRawAccessChainsFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>::value,
|
||||
"PhysicalDeviceRawAccessChainsFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_shader_atomic_float16_vector ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ) ==
|
||||
sizeof( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>::value,
|
||||
"PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_ray_tracing_validation ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV ) ==
|
||||
sizeof( VkPhysicalDeviceRayTracingValidationFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>::value,
|
||||
"PhysicalDeviceRayTracingValidationFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
#endif
|
||||
|
3739
thirdparty/vulkan/include/vulkan/vulkan_structs.hpp
vendored
3739
thirdparty/vulkan/include/vulkan/vulkan_structs.hpp
vendored
File diff suppressed because it is too large
Load Diff
@ -382,9 +382,16 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags )
|
||||
VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags value )
|
||||
{
|
||||
return "{}";
|
||||
if ( !value )
|
||||
return "{}";
|
||||
|
||||
std::string result;
|
||||
if ( value & MemoryMapFlagBits::ePlacedEXT )
|
||||
result += "PlacedEXT | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value )
|
||||
@ -1223,6 +1230,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "Quad | ";
|
||||
if ( value & SubgroupFeatureFlagBits::ePartitionedNV )
|
||||
result += "PartitionedNV | ";
|
||||
if ( value & SubgroupFeatureFlagBits::eRotateKHR )
|
||||
result += "RotateKHR | ";
|
||||
if ( value & SubgroupFeatureFlagBits::eRotateClusteredKHR )
|
||||
result += "RotateClusteredKHR | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@ -2039,6 +2050,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "DecodeH264 | ";
|
||||
if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH265 )
|
||||
result += "DecodeH265 | ";
|
||||
if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 )
|
||||
result += "DecodeAv1 | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@ -2804,9 +2817,16 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
//=== VK_KHR_map_memory2 ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagsKHR )
|
||||
VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagsKHR value )
|
||||
{
|
||||
return "{}";
|
||||
if ( !value )
|
||||
return "{}";
|
||||
|
||||
std::string result;
|
||||
if ( value & MemoryUnmapFlagBitsKHR::eReserveEXT )
|
||||
result += "ReserveEXT | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
||||
//=== VK_EXT_surface_maintenance1 ===
|
||||
@ -2895,8 +2915,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
std::string result;
|
||||
if ( value & VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes )
|
||||
result += "PrecedingExternallyEncodedBytes | ";
|
||||
if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit )
|
||||
result += "InsufficientstreamBufferRangeDetectionBit | ";
|
||||
if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection )
|
||||
result += "InsufficientBitstreamBufferRangeDetection | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@ -2907,12 +2927,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
return "{}";
|
||||
|
||||
std::string result;
|
||||
if ( value & VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit )
|
||||
result += "streamBufferOffsetBit | ";
|
||||
if ( value & VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit )
|
||||
result += "streamBytesWrittenBit | ";
|
||||
if ( value & VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit )
|
||||
result += "streamHasOverridesBit | ";
|
||||
if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset )
|
||||
result += "BitstreamBufferOffset | ";
|
||||
if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten )
|
||||
result += "BitstreamBytesWritten | ";
|
||||
if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides )
|
||||
result += "BitstreamHasOverrides | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@ -3352,6 +3372,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "AllowDerivatives | ";
|
||||
if ( value & PipelineCreateFlagBits2KHR::eDerivative )
|
||||
result += "Derivative | ";
|
||||
if ( value & PipelineCreateFlagBits2KHR::eEnableLegacyDitheringEXT )
|
||||
result += "EnableLegacyDitheringEXT | ";
|
||||
if ( value & PipelineCreateFlagBits2KHR::eViewIndexFromDeviceIndex )
|
||||
result += "ViewIndexFromDeviceIndex | ";
|
||||
if ( value & PipelineCreateFlagBits2KHR::eDispatchBase )
|
||||
@ -3452,12 +3474,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "VideoDecodeSrc | ";
|
||||
if ( value & BufferUsageFlagBits2KHR::eVideoDecodeDst )
|
||||
result += "VideoDecodeDst | ";
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
if ( value & BufferUsageFlagBits2KHR::eVideoEncodeDst )
|
||||
result += "VideoEncodeDst | ";
|
||||
if ( value & BufferUsageFlagBits2KHR::eVideoEncodeSrc )
|
||||
result += "VideoEncodeSrc | ";
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
if ( value & BufferUsageFlagBits2KHR::eShaderDeviceAddress )
|
||||
result += "ShaderDeviceAddress | ";
|
||||
if ( value & BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly )
|
||||
@ -3573,7 +3593,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case Result::eOperationNotDeferredKHR: return "OperationNotDeferredKHR";
|
||||
case Result::eErrorInvalidVideoStdParametersKHR: return "ErrorInvalidVideoStdParametersKHR";
|
||||
case Result::eErrorCompressionExhaustedEXT: return "ErrorCompressionExhaustedEXT";
|
||||
case Result::eErrorIncompatibleShaderBinaryEXT: return "ErrorIncompatibleShaderBinaryEXT";
|
||||
case Result::eIncompatibleShaderBinaryEXT: return "IncompatibleShaderBinaryEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -4127,7 +4147,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::ePhysicalDeviceFragmentShadingRateKHR: return "PhysicalDeviceFragmentShadingRateKHR";
|
||||
case StructureType::ePhysicalDeviceShaderCoreProperties2AMD: return "PhysicalDeviceShaderCoreProperties2AMD";
|
||||
case StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD: return "PhysicalDeviceCoherentMemoryFeaturesAMD";
|
||||
case StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeaturesKHR: return "PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR";
|
||||
case StructureType::eRenderingAttachmentLocationInfoKHR: return "RenderingAttachmentLocationInfoKHR";
|
||||
case StructureType::eRenderingInputAttachmentIndexInfoKHR: return "RenderingInputAttachmentIndexInfoKHR";
|
||||
case StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT: return "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR: return "PhysicalDeviceShaderQuadControlFeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT: return "PhysicalDeviceMemoryBudgetPropertiesEXT";
|
||||
case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT: return "PhysicalDeviceMemoryPriorityFeaturesEXT";
|
||||
case StructureType::eMemoryPriorityAllocateInfoEXT: return "MemoryPriorityAllocateInfoEXT";
|
||||
@ -4154,11 +4178,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT: return "SurfaceFullScreenExclusiveWin32InfoEXT";
|
||||
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
case StructureType::eHeadlessSurfaceCreateInfoEXT: return "HeadlessSurfaceCreateInfoEXT";
|
||||
case StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT: return "PhysicalDeviceLineRasterizationFeaturesEXT";
|
||||
case StructureType::ePipelineRasterizationLineStateCreateInfoEXT: return "PipelineRasterizationLineStateCreateInfoEXT";
|
||||
case StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT: return "PhysicalDeviceLineRasterizationPropertiesEXT";
|
||||
case StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT: return "PhysicalDeviceShaderAtomicFloatFeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT: return "PhysicalDeviceIndexTypeUint8FeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT: return "PhysicalDeviceExtendedDynamicStateFeaturesEXT";
|
||||
case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR: return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
|
||||
case StructureType::ePipelineInfoKHR: return "PipelineInfoKHR";
|
||||
@ -4178,6 +4198,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eHostImageCopyDevicePerformanceQueryEXT: return "HostImageCopyDevicePerformanceQueryEXT";
|
||||
case StructureType::eMemoryMapInfoKHR: return "MemoryMapInfoKHR";
|
||||
case StructureType::eMemoryUnmapInfoKHR: return "MemoryUnmapInfoKHR";
|
||||
case StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT: return "PhysicalDeviceMapMemoryPlacedFeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT: return "PhysicalDeviceMapMemoryPlacedPropertiesEXT";
|
||||
case StructureType::eMemoryMapPlacedInfoEXT: return "MemoryMapPlacedInfoEXT";
|
||||
case StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT: return "PhysicalDeviceShaderAtomicFloat2FeaturesEXT";
|
||||
case StructureType::eSurfacePresentModeEXT: return "SurfacePresentModeEXT";
|
||||
case StructureType::eSurfacePresentScalingCapabilitiesEXT: return "SurfacePresentScalingCapabilitiesEXT";
|
||||
@ -4376,6 +4399,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT: return "SamplerBorderColorComponentMappingCreateInfoEXT";
|
||||
case StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT: return "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceShaderCorePropertiesARM: return "PhysicalDeviceShaderCorePropertiesARM";
|
||||
case StructureType::ePhysicalDeviceShaderSubgroupRotateFeaturesKHR: return "PhysicalDeviceShaderSubgroupRotateFeaturesKHR";
|
||||
case StructureType::eDeviceQueueShaderCoreControlCreateInfoARM: return "DeviceQueueShaderCoreControlCreateInfoARM";
|
||||
case StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM: return "PhysicalDeviceSchedulingControlsFeaturesARM";
|
||||
case StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM: return "PhysicalDeviceSchedulingControlsPropertiesARM";
|
||||
@ -4402,6 +4426,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eComputePipelineIndirectBufferInfoNV: return "ComputePipelineIndirectBufferInfoNV";
|
||||
case StructureType::ePipelineIndirectDeviceAddressInfoNV: return "PipelineIndirectDeviceAddressInfoNV";
|
||||
case StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV: return "PhysicalDeviceLinearColorAttachmentFeaturesNV";
|
||||
case StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR: return "PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT: return "PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM: return "PhysicalDeviceImageProcessingFeaturesQCOM";
|
||||
case StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM: return "PhysicalDeviceImageProcessingPropertiesQCOM";
|
||||
@ -4478,6 +4503,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR: return "PhysicalDeviceCooperativeMatrixPropertiesKHR";
|
||||
case StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM: return "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM";
|
||||
case StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM: return "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM";
|
||||
case StructureType::eVideoDecodeAv1CapabilitiesKHR: return "VideoDecodeAv1CapabilitiesKHR";
|
||||
case StructureType::eVideoDecodeAv1PictureInfoKHR: return "VideoDecodeAv1PictureInfoKHR";
|
||||
case StructureType::eVideoDecodeAv1ProfileInfoKHR: return "VideoDecodeAv1ProfileInfoKHR";
|
||||
case StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR: return "VideoDecodeAv1SessionParametersCreateInfoKHR";
|
||||
case StructureType::eVideoDecodeAv1DpbSlotInfoKHR: return "VideoDecodeAv1DpbSlotInfoKHR";
|
||||
case StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR: return "PhysicalDeviceVideoMaintenance1FeaturesKHR";
|
||||
case StructureType::eVideoInlineQueryInfoKHR: return "VideoInlineQueryInfoKHR";
|
||||
case StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV: return "PhysicalDevicePerStageDescriptorSetFeaturesNV";
|
||||
@ -4494,6 +4524,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesKHR: return "PhysicalDeviceVertexAttributeDivisorPropertiesKHR";
|
||||
case StructureType::ePipelineVertexInputDivisorStateCreateInfoKHR: return "PipelineVertexInputDivisorStateCreateInfoKHR";
|
||||
case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesKHR: return "PhysicalDeviceVertexAttributeDivisorFeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceShaderFloatControls2FeaturesKHR: return "PhysicalDeviceShaderFloatControls2FeaturesKHR";
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
case StructureType::eScreenBufferPropertiesQNX: return "ScreenBufferPropertiesQNX";
|
||||
case StructureType::eScreenBufferFormatPropertiesQNX: return "ScreenBufferFormatPropertiesQNX";
|
||||
@ -4502,7 +4533,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT: return "PhysicalDeviceLayeredDriverPropertiesMSFT";
|
||||
case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesKHR: return "PhysicalDeviceIndexTypeUint8FeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceLineRasterizationFeaturesKHR: return "PhysicalDeviceLineRasterizationFeaturesKHR";
|
||||
case StructureType::ePipelineRasterizationLineStateCreateInfoKHR: return "PipelineRasterizationLineStateCreateInfoKHR";
|
||||
case StructureType::ePhysicalDeviceLineRasterizationPropertiesKHR: return "PhysicalDeviceLineRasterizationPropertiesKHR";
|
||||
case StructureType::eCalibratedTimestampInfoKHR: return "CalibratedTimestampInfoKHR";
|
||||
case StructureType::ePhysicalDeviceShaderExpectAssumeFeaturesKHR: return "PhysicalDeviceShaderExpectAssumeFeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceMaintenance6FeaturesKHR: return "PhysicalDeviceMaintenance6FeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceMaintenance6PropertiesKHR: return "PhysicalDeviceMaintenance6PropertiesKHR";
|
||||
case StructureType::eBindMemoryStatusKHR: return "BindMemoryStatusKHR";
|
||||
@ -4513,6 +4549,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eSetDescriptorBufferOffsetsInfoEXT: return "SetDescriptorBufferOffsetsInfoEXT";
|
||||
case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT: return "BindDescriptorBufferEmbeddedSamplersInfoEXT";
|
||||
case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
|
||||
case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV";
|
||||
case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV: return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV";
|
||||
case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV: return "PhysicalDeviceRayTracingValidationFeaturesNV";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -4855,7 +4894,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case Format::ePvrtc14BppSrgbBlockIMG: return "Pvrtc14BppSrgbBlockIMG";
|
||||
case Format::ePvrtc22BppSrgbBlockIMG: return "Pvrtc22BppSrgbBlockIMG";
|
||||
case Format::ePvrtc24BppSrgbBlockIMG: return "Pvrtc24BppSrgbBlockIMG";
|
||||
case Format::eR16G16S105NV: return "R16G16S105NV";
|
||||
case Format::eR16G16Sfixed5NV: return "R16G16Sfixed5NV";
|
||||
case Format::eA1B5G5R5UnormPack16KHR: return "A1B5G5R5UnormPack16KHR";
|
||||
case Format::eA8UnormKHR: return "A8UnormKHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
@ -5132,9 +5171,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits )
|
||||
VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits value )
|
||||
{
|
||||
return "(void)";
|
||||
switch ( value )
|
||||
{
|
||||
case MemoryMapFlagBits::ePlacedEXT: return "PlacedEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( ImageAspectFlagBits value )
|
||||
@ -5359,6 +5402,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR";
|
||||
case ImageLayout::eFragmentDensityMapOptimalEXT: return "FragmentDensityMapOptimalEXT";
|
||||
case ImageLayout::eFragmentShadingRateAttachmentOptimalKHR: return "FragmentShadingRateAttachmentOptimalKHR";
|
||||
case ImageLayout::eRenderingLocalReadKHR: return "RenderingLocalReadKHR";
|
||||
case ImageLayout::eVideoEncodeDstKHR: return "VideoEncodeDstKHR";
|
||||
case ImageLayout::eVideoEncodeSrcKHR: return "VideoEncodeSrcKHR";
|
||||
case ImageLayout::eVideoEncodeDpbKHR: return "VideoEncodeDpbKHR";
|
||||
@ -5587,12 +5631,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case DynamicState::eExclusiveScissorEnableNV: return "ExclusiveScissorEnableNV";
|
||||
case DynamicState::eExclusiveScissorNV: return "ExclusiveScissorNV";
|
||||
case DynamicState::eFragmentShadingRateKHR: return "FragmentShadingRateKHR";
|
||||
case DynamicState::eLineStippleEXT: return "LineStippleEXT";
|
||||
case DynamicState::eVertexInputEXT: return "VertexInputEXT";
|
||||
case DynamicState::ePatchControlPointsEXT: return "PatchControlPointsEXT";
|
||||
case DynamicState::eLogicOpEXT: return "LogicOpEXT";
|
||||
case DynamicState::eColorWriteEnableEXT: return "ColorWriteEnableEXT";
|
||||
case DynamicState::eTessellationDomainOriginEXT: return "TessellationDomainOriginEXT";
|
||||
case DynamicState::eDepthClampEnableEXT: return "DepthClampEnableEXT";
|
||||
case DynamicState::ePolygonModeEXT: return "PolygonModeEXT";
|
||||
case DynamicState::eRasterizationSamplesEXT: return "RasterizationSamplesEXT";
|
||||
@ -5603,6 +5645,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case DynamicState::eColorBlendEnableEXT: return "ColorBlendEnableEXT";
|
||||
case DynamicState::eColorBlendEquationEXT: return "ColorBlendEquationEXT";
|
||||
case DynamicState::eColorWriteMaskEXT: return "ColorWriteMaskEXT";
|
||||
case DynamicState::eTessellationDomainOriginEXT: return "TessellationDomainOriginEXT";
|
||||
case DynamicState::eRasterizationStreamEXT: return "RasterizationStreamEXT";
|
||||
case DynamicState::eConservativeRasterizationModeEXT: return "ConservativeRasterizationModeEXT";
|
||||
case DynamicState::eExtraPrimitiveOverestimationSizeEXT: return "ExtraPrimitiveOverestimationSizeEXT";
|
||||
@ -5624,6 +5667,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case DynamicState::eRepresentativeFragmentTestEnableNV: return "RepresentativeFragmentTestEnableNV";
|
||||
case DynamicState::eCoverageReductionModeNV: return "CoverageReductionModeNV";
|
||||
case DynamicState::eAttachmentFeedbackLoopEnableEXT: return "AttachmentFeedbackLoopEnableEXT";
|
||||
case DynamicState::eLineStippleKHR: return "LineStippleKHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -6033,7 +6077,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case AttachmentLoadOp::eLoad: return "Load";
|
||||
case AttachmentLoadOp::eClear: return "Clear";
|
||||
case AttachmentLoadOp::eDontCare: return "DontCare";
|
||||
case AttachmentLoadOp::eNoneEXT: return "NoneEXT";
|
||||
case AttachmentLoadOp::eNoneKHR: return "NoneKHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -6176,7 +6220,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case IndexType::eUint16: return "Uint16";
|
||||
case IndexType::eUint32: return "Uint32";
|
||||
case IndexType::eNoneKHR: return "NoneKHR";
|
||||
case IndexType::eUint8EXT: return "Uint8EXT";
|
||||
case IndexType::eUint8KHR: return "Uint8KHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -6218,6 +6262,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case SubgroupFeatureFlagBits::eClustered: return "Clustered";
|
||||
case SubgroupFeatureFlagBits::eQuad: return "Quad";
|
||||
case SubgroupFeatureFlagBits::ePartitionedNV: return "PartitionedNV";
|
||||
case SubgroupFeatureFlagBits::eRotateKHR: return "RotateKHR";
|
||||
case SubgroupFeatureFlagBits::eRotateClusteredKHR: return "RotateClusteredKHR";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -6992,6 +7038,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VideoCodecOperationFlagBitsKHR::eEncodeH265: return "EncodeH265";
|
||||
case VideoCodecOperationFlagBitsKHR::eDecodeH264: return "DecodeH264";
|
||||
case VideoCodecOperationFlagBitsKHR::eDecodeH265: return "DecodeH265";
|
||||
case VideoCodecOperationFlagBitsKHR::eDecodeAv1: return "DecodeAv1";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -8061,20 +8108,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
return "(void)";
|
||||
}
|
||||
|
||||
//=== VK_EXT_line_rasterization ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( LineRasterizationModeEXT value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case LineRasterizationModeEXT::eDefault: return "Default";
|
||||
case LineRasterizationModeEXT::eRectangular: return "Rectangular";
|
||||
case LineRasterizationModeEXT::eBresenham: return "Bresenham";
|
||||
case LineRasterizationModeEXT::eRectangularSmooth: return "RectangularSmooth";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_KHR_pipeline_executable_properties ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineExecutableStatisticFormatKHR value )
|
||||
@ -8102,9 +8135,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
//=== VK_KHR_map_memory2 ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagBitsKHR )
|
||||
VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagBitsKHR value )
|
||||
{
|
||||
return "(void)";
|
||||
switch ( value )
|
||||
{
|
||||
case MemoryUnmapFlagBitsKHR::eReserveEXT: return "ReserveEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_EXT_surface_maintenance1 ===
|
||||
@ -8212,7 +8249,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
switch ( value )
|
||||
{
|
||||
case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes: return "PrecedingExternallyEncodedBytes";
|
||||
case VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit: return "InsufficientstreamBufferRangeDetectionBit";
|
||||
case VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection: return "InsufficientBitstreamBufferRangeDetection";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -8221,9 +8258,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit: return "streamBufferOffsetBit";
|
||||
case VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit: return "streamBytesWrittenBit";
|
||||
case VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit: return "streamHasOverridesBit";
|
||||
case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset: return "BitstreamBufferOffset";
|
||||
case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten: return "BitstreamBytesWritten";
|
||||
case VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides: return "BitstreamHasOverrides";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
@ -8778,6 +8815,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case PipelineCreateFlagBits2KHR::eDisableOptimization: return "DisableOptimization";
|
||||
case PipelineCreateFlagBits2KHR::eAllowDerivatives: return "AllowDerivatives";
|
||||
case PipelineCreateFlagBits2KHR::eDerivative: return "Derivative";
|
||||
case PipelineCreateFlagBits2KHR::eEnableLegacyDitheringEXT: return "EnableLegacyDitheringEXT";
|
||||
case PipelineCreateFlagBits2KHR::eViewIndexFromDeviceIndex: return "ViewIndexFromDeviceIndex";
|
||||
case PipelineCreateFlagBits2KHR::eDispatchBase: return "DispatchBase";
|
||||
case PipelineCreateFlagBits2KHR::eDeferCompileNV: return "DeferCompileNV";
|
||||
@ -8832,10 +8870,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case BufferUsageFlagBits2KHR::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT";
|
||||
case BufferUsageFlagBits2KHR::eVideoDecodeSrc: return "VideoDecodeSrc";
|
||||
case BufferUsageFlagBits2KHR::eVideoDecodeDst: return "VideoDecodeDst";
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
case BufferUsageFlagBits2KHR::eVideoEncodeDst: return "VideoEncodeDst";
|
||||
case BufferUsageFlagBits2KHR::eVideoEncodeSrc: return "VideoEncodeSrc";
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
case BufferUsageFlagBits2KHR::eShaderDeviceAddress: return "ShaderDeviceAddress";
|
||||
case BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly: return "AccelerationStructureBuildInputReadOnly";
|
||||
case BufferUsageFlagBits2KHR::eAccelerationStructureStorage: return "AccelerationStructureStorage";
|
||||
@ -9008,6 +9044,20 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_KHR_line_rasterization ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( LineRasterizationModeKHR value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case LineRasterizationModeKHR::eDefault: return "Default";
|
||||
case LineRasterizationModeKHR::eRectangular: return "Rectangular";
|
||||
case LineRasterizationModeKHR::eBresenham: return "Bresenham";
|
||||
case LineRasterizationModeKHR::eRectangularSmooth: return "RectangularSmooth";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_KHR_calibrated_timestamps ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( TimeDomainKHR value )
|
||||
|
1016
thirdparty/vulkan/include/vulkan/vulkan_video.hpp
vendored
1016
thirdparty/vulkan/include/vulkan/vulkan_video.hpp
vendored
File diff suppressed because it is too large
Load Diff
4
thirdparty/vulkan/patches/VMA-use-volk.patch
vendored
4
thirdparty/vulkan/patches/VMA-use-volk.patch
vendored
@ -1,8 +1,8 @@
|
||||
diff --git a/thirdparty/vulkan/vk_mem_alloc.h b/thirdparty/vulkan/vk_mem_alloc.h
|
||||
index fa4298b23c..a29bf6dfb6 100644
|
||||
index 711f486571..e5eaa80e74 100644
|
||||
--- a/thirdparty/vulkan/vk_mem_alloc.h
|
||||
+++ b/thirdparty/vulkan/vk_mem_alloc.h
|
||||
@@ -126,7 +126,11 @@ See documentation chapter: \ref statistics.
|
||||
@@ -127,7 +127,11 @@ See documentation chapter: \ref statistics.
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
167
thirdparty/vulkan/vk_enum_string_helper.h
vendored
167
thirdparty/vulkan/vk_enum_string_helper.h
vendored
@ -112,8 +112,8 @@ static inline const char* string_VkResult(VkResult input_value) {
|
||||
return "VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR";
|
||||
case VK_ERROR_COMPRESSION_EXHAUSTED_EXT:
|
||||
return "VK_ERROR_COMPRESSION_EXHAUSTED_EXT";
|
||||
case VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT:
|
||||
return "VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT";
|
||||
case VK_INCOMPATIBLE_SHADER_BINARY_EXT:
|
||||
return "VK_INCOMPATIBLE_SHADER_BINARY_EXT";
|
||||
default:
|
||||
return "Unhandled VkResult";
|
||||
}
|
||||
@ -1138,8 +1138,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
|
||||
return "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
|
||||
return "VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
|
||||
@ -1188,16 +1196,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
|
||||
return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT";
|
||||
case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
|
||||
return "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
|
||||
@ -1236,6 +1236,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
|
||||
return "VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR:
|
||||
return "VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT";
|
||||
case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
|
||||
return "VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT";
|
||||
case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
|
||||
@ -1610,6 +1616,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
|
||||
return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
|
||||
@ -1662,6 +1670,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
|
||||
return "VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
|
||||
@ -1810,6 +1820,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM";
|
||||
case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
|
||||
return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM";
|
||||
case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR";
|
||||
case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
|
||||
return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
|
||||
return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
|
||||
return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
|
||||
return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
|
||||
@ -1842,6 +1862,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
|
||||
return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX:
|
||||
return "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX";
|
||||
case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
|
||||
@ -1854,8 +1876,18 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR";
|
||||
case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR:
|
||||
return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
|
||||
@ -1876,6 +1908,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
|
||||
return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
|
||||
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
|
||||
return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV";
|
||||
default:
|
||||
return "Unhandled VkStructureType";
|
||||
}
|
||||
@ -1938,6 +1976,8 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) {
|
||||
return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
|
||||
case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
|
||||
return "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR";
|
||||
case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR:
|
||||
return "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR";
|
||||
case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
|
||||
return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR";
|
||||
case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
|
||||
@ -2598,8 +2638,8 @@ static inline const char* string_VkFormat(VkFormat input_value) {
|
||||
return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
|
||||
case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
|
||||
return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
|
||||
case VK_FORMAT_R16G16_S10_5_NV:
|
||||
return "VK_FORMAT_R16G16_S10_5_NV";
|
||||
case VK_FORMAT_R16G16_SFIXED5_NV:
|
||||
return "VK_FORMAT_R16G16_SFIXED5_NV";
|
||||
case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
|
||||
return "VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR";
|
||||
case VK_FORMAT_A8_UNORM_KHR:
|
||||
@ -2984,8 +3024,6 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
|
||||
return "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV";
|
||||
case VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR:
|
||||
return "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR";
|
||||
case VK_DYNAMIC_STATE_LINE_STIPPLE_EXT:
|
||||
return "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT";
|
||||
case VK_DYNAMIC_STATE_VERTEX_INPUT_EXT:
|
||||
return "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT";
|
||||
case VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT:
|
||||
@ -2994,8 +3032,6 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
|
||||
return "VK_DYNAMIC_STATE_LOGIC_OP_EXT";
|
||||
case VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT:
|
||||
return "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT";
|
||||
case VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT:
|
||||
return "VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT";
|
||||
case VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT:
|
||||
return "VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT";
|
||||
case VK_DYNAMIC_STATE_POLYGON_MODE_EXT:
|
||||
@ -3016,6 +3052,8 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
|
||||
return "VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT";
|
||||
case VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT:
|
||||
return "VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT";
|
||||
case VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT:
|
||||
return "VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT";
|
||||
case VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT:
|
||||
return "VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT";
|
||||
case VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT:
|
||||
@ -3058,6 +3096,8 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
|
||||
return "VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV";
|
||||
case VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT:
|
||||
return "VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT";
|
||||
case VK_DYNAMIC_STATE_LINE_STIPPLE_KHR:
|
||||
return "VK_DYNAMIC_STATE_LINE_STIPPLE_KHR";
|
||||
default:
|
||||
return "Unhandled VkDynamicState";
|
||||
}
|
||||
@ -3292,8 +3332,8 @@ static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_val
|
||||
return "VK_ATTACHMENT_LOAD_OP_CLEAR";
|
||||
case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
|
||||
return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
|
||||
case VK_ATTACHMENT_LOAD_OP_NONE_EXT:
|
||||
return "VK_ATTACHMENT_LOAD_OP_NONE_EXT";
|
||||
case VK_ATTACHMENT_LOAD_OP_NONE_KHR:
|
||||
return "VK_ATTACHMENT_LOAD_OP_NONE_KHR";
|
||||
default:
|
||||
return "Unhandled VkAttachmentLoadOp";
|
||||
}
|
||||
@ -3346,8 +3386,8 @@ static inline const char* string_VkIndexType(VkIndexType input_value) {
|
||||
return "VK_INDEX_TYPE_UINT32";
|
||||
case VK_INDEX_TYPE_NONE_KHR:
|
||||
return "VK_INDEX_TYPE_NONE_KHR";
|
||||
case VK_INDEX_TYPE_UINT8_EXT:
|
||||
return "VK_INDEX_TYPE_UINT8_EXT";
|
||||
case VK_INDEX_TYPE_UINT8_KHR:
|
||||
return "VK_INDEX_TYPE_UINT8_KHR";
|
||||
default:
|
||||
return "Unhandled VkIndexType";
|
||||
}
|
||||
@ -3754,6 +3794,20 @@ static inline const char* string_VkScopeKHR(VkScopeKHR input_value) {
|
||||
return "Unhandled VkScopeKHR";
|
||||
}
|
||||
}
|
||||
static inline const char* string_VkLineRasterizationModeKHR(VkLineRasterizationModeKHR input_value) {
|
||||
switch (input_value) {
|
||||
case VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR:
|
||||
return "VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR";
|
||||
case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR:
|
||||
return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR";
|
||||
case VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR:
|
||||
return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR";
|
||||
case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR:
|
||||
return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR";
|
||||
default:
|
||||
return "Unhandled VkLineRasterizationModeKHR";
|
||||
}
|
||||
}
|
||||
static inline const char* string_VkTimeDomainKHR(VkTimeDomainKHR input_value) {
|
||||
switch (input_value) {
|
||||
case VK_TIME_DOMAIN_DEVICE_KHR:
|
||||
@ -4266,20 +4320,6 @@ static inline const char* string_VkFullScreenExclusiveEXT(VkFullScreenExclusiveE
|
||||
}
|
||||
}
|
||||
#endif // VK_USE_PLATFORM_WIN32_KHR
|
||||
static inline const char* string_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT input_value) {
|
||||
switch (input_value) {
|
||||
case VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT:
|
||||
return "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT";
|
||||
case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT:
|
||||
return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT";
|
||||
case VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT:
|
||||
return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT";
|
||||
case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT:
|
||||
return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT";
|
||||
default:
|
||||
return "Unhandled VkLineRasterizationModeEXT";
|
||||
}
|
||||
}
|
||||
static inline const char* string_VkIndirectCommandsTokenTypeNV(VkIndirectCommandsTokenTypeNV input_value) {
|
||||
switch (input_value) {
|
||||
case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV:
|
||||
@ -5355,6 +5395,31 @@ static inline std::string string_VkPipelineStageFlags(VkPipelineStageFlags input
|
||||
return ret;
|
||||
}
|
||||
#endif // __cplusplus
|
||||
static inline const char* string_VkMemoryMapFlagBits(VkMemoryMapFlagBits input_value) {
|
||||
switch (input_value) {
|
||||
case VK_MEMORY_MAP_PLACED_BIT_EXT:
|
||||
return "VK_MEMORY_MAP_PLACED_BIT_EXT";
|
||||
default:
|
||||
return "Unhandled VkMemoryMapFlagBits";
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
static inline std::string string_VkMemoryMapFlags(VkMemoryMapFlags input_value) {
|
||||
std::string ret;
|
||||
int index = 0;
|
||||
while(input_value) {
|
||||
if (input_value & 1) {
|
||||
if( !ret.empty()) ret.append("|");
|
||||
ret.append(string_VkMemoryMapFlagBits(static_cast<VkMemoryMapFlagBits>(1U << index)));
|
||||
}
|
||||
++index;
|
||||
input_value >>= 1;
|
||||
}
|
||||
if (ret.empty()) ret.append("VkMemoryMapFlags(0)");
|
||||
return ret;
|
||||
}
|
||||
#endif // __cplusplus
|
||||
static inline const char* string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value) {
|
||||
switch (input_value) {
|
||||
case VK_SPARSE_MEMORY_BIND_METADATA_BIT:
|
||||
@ -6449,6 +6514,10 @@ static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlag
|
||||
return "VK_SUBGROUP_FEATURE_QUAD_BIT";
|
||||
case VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV:
|
||||
return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV";
|
||||
case VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR:
|
||||
return "VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR";
|
||||
case VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR:
|
||||
return "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR";
|
||||
default:
|
||||
return "Unhandled VkSubgroupFeatureFlagBits";
|
||||
}
|
||||
@ -7360,6 +7429,8 @@ static inline const char* string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOp
|
||||
return "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR";
|
||||
case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
|
||||
return "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR";
|
||||
case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR:
|
||||
return "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR";
|
||||
default:
|
||||
return "Unhandled VkVideoCodecOperationFlagBitsKHR";
|
||||
}
|
||||
@ -7982,6 +8053,31 @@ static inline std::string string_VkPerformanceCounterDescriptionFlagsKHR(VkPerfo
|
||||
return ret;
|
||||
}
|
||||
#endif // __cplusplus
|
||||
static inline const char* string_VkMemoryUnmapFlagBitsKHR(VkMemoryUnmapFlagBitsKHR input_value) {
|
||||
switch (input_value) {
|
||||
case VK_MEMORY_UNMAP_RESERVE_BIT_EXT:
|
||||
return "VK_MEMORY_UNMAP_RESERVE_BIT_EXT";
|
||||
default:
|
||||
return "Unhandled VkMemoryUnmapFlagBitsKHR";
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
static inline std::string string_VkMemoryUnmapFlagsKHR(VkMemoryUnmapFlagsKHR input_value) {
|
||||
std::string ret;
|
||||
int index = 0;
|
||||
while(input_value) {
|
||||
if (input_value & 1) {
|
||||
if( !ret.empty()) ret.append("|");
|
||||
ret.append(string_VkMemoryUnmapFlagBitsKHR(static_cast<VkMemoryUnmapFlagBitsKHR>(1U << index)));
|
||||
}
|
||||
++index;
|
||||
input_value >>= 1;
|
||||
}
|
||||
if (ret.empty()) ret.append("VkMemoryUnmapFlagsKHR(0)");
|
||||
return ret;
|
||||
}
|
||||
#endif // __cplusplus
|
||||
static inline const char* string_VkVideoEncodeCapabilityFlagBitsKHR(VkVideoEncodeCapabilityFlagBitsKHR input_value) {
|
||||
switch (input_value) {
|
||||
case VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR:
|
||||
@ -8137,6 +8233,7 @@ static inline const char* string_VkPipelineCreateFlagBits2KHR(uint64_t input_val
|
||||
if (input_value == VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR";
|
||||
if (input_value == VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR) return "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR";
|
||||
if (input_value == VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR";
|
||||
if (input_value == VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) return "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT";
|
||||
if (input_value == VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR) return "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR";
|
||||
if (input_value == VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR";
|
||||
if (input_value == VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) return "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV";
|
||||
@ -8201,10 +8298,8 @@ static inline const char* string_VkBufferUsageFlagBits2KHR(uint64_t input_value)
|
||||
if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT";
|
||||
if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR";
|
||||
if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR";
|
||||
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
||||
if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR";
|
||||
if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR";
|
||||
#endif // VK_ENABLE_BETA_EXTENSIONS
|
||||
if (input_value == VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR";
|
||||
if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR";
|
||||
if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR";
|
||||
|
290
thirdparty/vulkan/vk_mem_alloc.h
vendored
290
thirdparty/vulkan/vk_mem_alloc.h
vendored
@ -25,7 +25,7 @@
|
||||
|
||||
/** \mainpage Vulkan Memory Allocator
|
||||
|
||||
<b>Version 3.1.0-development</b>
|
||||
<b>Version 3.1.0</b>
|
||||
|
||||
Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved. \n
|
||||
License: MIT \n
|
||||
@ -77,6 +77,7 @@ See also: [product page on GPUOpen](https://gpuopen.com/gaming-product/vulkan-me
|
||||
- [Memory initialization](@ref debugging_memory_usage_initialization)
|
||||
- [Margins](@ref debugging_memory_usage_margins)
|
||||
- [Corruption detection](@ref debugging_memory_usage_corruption_detection)
|
||||
- [Leak detection features](@ref debugging_memory_usage_leak_detection)
|
||||
- \subpage other_api_interop
|
||||
- \subpage usage_patterns
|
||||
- [GPU-only resource](@ref usage_patterns_gpu_only)
|
||||
@ -224,6 +225,15 @@ extern "C" {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Defined to 1 when VK_KHR_maintenance5 device extension is defined in Vulkan headers.
|
||||
#if !defined(VMA_KHR_MAINTENANCE5)
|
||||
#if VK_KHR_maintenance5
|
||||
#define VMA_KHR_MAINTENANCE5 1
|
||||
#else
|
||||
#define VMA_KHR_MAINTENANCE5 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
// Defined to 1 when VK_KHR_external_memory device extension is defined in Vulkan headers.
|
||||
#if !defined(VMA_EXTERNAL_MEMORY)
|
||||
@ -445,6 +455,13 @@ typedef enum VmaAllocatorCreateFlagBits
|
||||
while creating Vulkan device passed as VmaAllocatorCreateInfo::device.
|
||||
*/
|
||||
VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT = 0x00000080,
|
||||
/**
|
||||
Enables usage of VK_KHR_maintenance5 extension in the library.
|
||||
|
||||
You should set this flag if you found available and enabled this device extension,
|
||||
while creating Vulkan device passed as VmaAllocatorCreateInfo::device.
|
||||
*/
|
||||
VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT = 0x00000100,
|
||||
|
||||
VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
|
||||
} VmaAllocatorCreateFlagBits;
|
||||
@ -1011,6 +1028,7 @@ typedef struct VmaVulkanFunctions
|
||||
PFN_vkBindImageMemory2KHR VMA_NULLABLE vkBindImageMemory2KHR;
|
||||
#endif
|
||||
#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
|
||||
/// Fetch from "vkGetPhysicalDeviceMemoryProperties2" on Vulkan >= 1.1, but you can also fetch it from "vkGetPhysicalDeviceMemoryProperties2KHR" if you enabled extension VK_KHR_get_physical_device_properties2.
|
||||
PFN_vkGetPhysicalDeviceMemoryProperties2KHR VMA_NULLABLE vkGetPhysicalDeviceMemoryProperties2KHR;
|
||||
#endif
|
||||
#if VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
|
||||
@ -2152,7 +2170,7 @@ For more information, see documentation of vmaFlushAllocation().
|
||||
\param allocator
|
||||
\param allocationCount
|
||||
\param allocations
|
||||
\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
|
||||
\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all offsets are zero.
|
||||
\param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.
|
||||
|
||||
This function returns the `VkResult` from `vkFlushMappedMemoryRanges` if it is
|
||||
@ -2173,7 +2191,7 @@ For more information, see documentation of vmaInvalidateAllocation().
|
||||
\param allocator
|
||||
\param allocationCount
|
||||
\param allocations
|
||||
\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
|
||||
\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all offsets are zero.
|
||||
\param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.
|
||||
|
||||
This function returns the `VkResult` from `vkInvalidateMappedMemoryRanges` if it is
|
||||
@ -2832,7 +2850,7 @@ remove them if not needed.
|
||||
*/
|
||||
#if !defined(VMA_CONFIGURATION_USER_INCLUDES_H)
|
||||
#include <cassert> // for assert
|
||||
#include <algorithm> // for min, max
|
||||
#include <algorithm> // for min, max, swap
|
||||
#include <mutex>
|
||||
#else
|
||||
#include VMA_CONFIGURATION_USER_INCLUDES_H
|
||||
@ -2997,10 +3015,6 @@ static void vma_aligned_free(void* VMA_NULLABLE ptr)
|
||||
#define VMA_MAX(v1, v2) ((std::max)((v1), (v2)))
|
||||
#endif
|
||||
|
||||
#ifndef VMA_SWAP
|
||||
#define VMA_SWAP(v1, v2) std::swap((v1), (v2))
|
||||
#endif
|
||||
|
||||
#ifndef VMA_SORT
|
||||
#define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
|
||||
#endif
|
||||
@ -3379,7 +3393,7 @@ class VmaAllocationObjectAllocator;
|
||||
/*
|
||||
Returns number of bits set to 1 in (v).
|
||||
|
||||
On specific platforms and compilers you can use instrinsics like:
|
||||
On specific platforms and compilers you can use intrinsics like:
|
||||
|
||||
Visual Studio:
|
||||
return __popcnt(v);
|
||||
@ -3636,7 +3650,7 @@ static inline bool VmaIsBufferImageGranularityConflict(
|
||||
{
|
||||
if (suballocType1 > suballocType2)
|
||||
{
|
||||
VMA_SWAP(suballocType1, suballocType2);
|
||||
std::swap(suballocType1, suballocType2);
|
||||
}
|
||||
|
||||
switch (suballocType1)
|
||||
@ -3781,13 +3795,95 @@ static inline void VmaPnextChainPushFront(MainT* mainStruct, NewT* newStruct)
|
||||
newStruct->pNext = mainStruct->pNext;
|
||||
mainStruct->pNext = newStruct;
|
||||
}
|
||||
// Finds structure with s->sType == sType in mainStruct->pNext chain.
|
||||
// Returns pointer to it. If not found, returns null.
|
||||
template<typename FindT, typename MainT>
|
||||
static inline const FindT* VmaPnextChainFind(const MainT* mainStruct, VkStructureType sType)
|
||||
{
|
||||
for(const VkBaseInStructure* s = (const VkBaseInStructure*)mainStruct->pNext;
|
||||
s != VMA_NULL; s = s->pNext)
|
||||
{
|
||||
if(s->sType == sType)
|
||||
{
|
||||
return (const FindT*)s;
|
||||
}
|
||||
}
|
||||
return VMA_NULL;
|
||||
}
|
||||
|
||||
// An abstraction over buffer or image `usage` flags, depending on available extensions.
|
||||
struct VmaBufferImageUsage
|
||||
{
|
||||
#if VMA_KHR_MAINTENANCE5
|
||||
typedef uint64_t BaseType; // VkFlags64
|
||||
#else
|
||||
typedef uint32_t BaseType; // VkFlags32
|
||||
#endif
|
||||
|
||||
static const VmaBufferImageUsage UNKNOWN;
|
||||
|
||||
BaseType Value;
|
||||
|
||||
VmaBufferImageUsage() { *this = UNKNOWN; }
|
||||
explicit VmaBufferImageUsage(BaseType usage) : Value(usage) { }
|
||||
VmaBufferImageUsage(const VkBufferCreateInfo &createInfo, bool useKhrMaintenance5);
|
||||
explicit VmaBufferImageUsage(const VkImageCreateInfo &createInfo);
|
||||
|
||||
bool operator==(const VmaBufferImageUsage& rhs) const { return Value == rhs.Value; }
|
||||
bool operator!=(const VmaBufferImageUsage& rhs) const { return Value != rhs.Value; }
|
||||
|
||||
bool Contains(BaseType flag) const { return (Value & flag) != 0; }
|
||||
bool ContainsDeviceAccess() const
|
||||
{
|
||||
// This relies on values of VK_IMAGE_USAGE_TRANSFER* being the same as VK_BUFFER_IMAGE_TRANSFER*.
|
||||
return (Value & ~BaseType(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT)) != 0;
|
||||
}
|
||||
};
|
||||
|
||||
const VmaBufferImageUsage VmaBufferImageUsage::UNKNOWN = VmaBufferImageUsage(0);
|
||||
|
||||
static void swap(VmaBufferImageUsage& lhs, VmaBufferImageUsage& rhs) noexcept
|
||||
{
|
||||
using std::swap;
|
||||
swap(lhs.Value, rhs.Value);
|
||||
}
|
||||
|
||||
VmaBufferImageUsage::VmaBufferImageUsage(const VkBufferCreateInfo &createInfo,
|
||||
bool useKhrMaintenance5)
|
||||
{
|
||||
#if VMA_KHR_MAINTENANCE5
|
||||
if(useKhrMaintenance5)
|
||||
{
|
||||
// If VkBufferCreateInfo::pNext chain contains VkBufferUsageFlags2CreateInfoKHR,
|
||||
// take usage from it and ignore VkBufferCreateInfo::usage, per specification
|
||||
// of the VK_KHR_maintenance5 extension.
|
||||
const VkBufferUsageFlags2CreateInfoKHR* const usageFlags2 =
|
||||
VmaPnextChainFind<VkBufferUsageFlags2CreateInfoKHR>(&createInfo, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR);
|
||||
if(usageFlags2)
|
||||
{
|
||||
this->Value = usageFlags2->usage;
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
this->Value = (BaseType)createInfo.usage;
|
||||
}
|
||||
|
||||
VmaBufferImageUsage::VmaBufferImageUsage(const VkImageCreateInfo &createInfo)
|
||||
{
|
||||
// Maybe in the future there will be VK_KHR_maintenanceN extension with structure
|
||||
// VkImageUsageFlags2CreateInfoKHR, like the one for buffers...
|
||||
|
||||
this->Value = (BaseType)createInfo.usage;
|
||||
}
|
||||
|
||||
// This is the main algorithm that guides the selection of a memory type best for an allocation -
|
||||
// converts usage to required/preferred/not preferred flags.
|
||||
static bool FindMemoryPreferences(
|
||||
bool isIntegratedGPU,
|
||||
const VmaAllocationCreateInfo& allocCreateInfo,
|
||||
VkFlags bufImgUsage, // VkBufferCreateInfo::usage or VkImageCreateInfo::usage. UINT32_MAX if unknown.
|
||||
VmaBufferImageUsage bufImgUsage,
|
||||
VkMemoryPropertyFlags& outRequiredFlags,
|
||||
VkMemoryPropertyFlags& outPreferredFlags,
|
||||
VkMemoryPropertyFlags& outNotPreferredFlags)
|
||||
@ -3830,13 +3926,14 @@ static bool FindMemoryPreferences(
|
||||
case VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE:
|
||||
case VMA_MEMORY_USAGE_AUTO_PREFER_HOST:
|
||||
{
|
||||
if(bufImgUsage == UINT32_MAX)
|
||||
if(bufImgUsage == VmaBufferImageUsage::UNKNOWN)
|
||||
{
|
||||
VMA_ASSERT(0 && "VMA_MEMORY_USAGE_AUTO* values can only be used with functions like vmaCreateBuffer, vmaCreateImage so that the details of the created resource are known.");
|
||||
VMA_ASSERT(0 && "VMA_MEMORY_USAGE_AUTO* values can only be used with functions like vmaCreateBuffer, vmaCreateImage so that the details of the created resource are known."
|
||||
" Maybe you use VkBufferUsageFlags2CreateInfoKHR but forgot to use VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT?" );
|
||||
return false;
|
||||
}
|
||||
// This relies on values of VK_IMAGE_USAGE_TRANSFER* being the same VK_BUFFER_IMAGE_TRANSFER*.
|
||||
const bool deviceAccess = (bufImgUsage & ~static_cast<VkFlags>(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT)) != 0;
|
||||
|
||||
const bool deviceAccess = bufImgUsage.ContainsDeviceAccess();
|
||||
const bool hostAccessSequentialWrite = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT) != 0;
|
||||
const bool hostAccessRandom = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT) != 0;
|
||||
const bool hostAccessAllowTransferInstead = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT) != 0;
|
||||
@ -6133,9 +6230,17 @@ public:
|
||||
void DedicatedAllocUnmap(VmaAllocator hAllocator);
|
||||
|
||||
#if VMA_STATS_STRING_ENABLED
|
||||
uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
|
||||
|
||||
void InitBufferImageUsage(uint32_t bufferImageUsage);
|
||||
VmaBufferImageUsage GetBufferImageUsage() const { return m_BufferImageUsage; }
|
||||
void InitBufferUsage(const VkBufferCreateInfo &createInfo, bool useKhrMaintenance5)
|
||||
{
|
||||
VMA_ASSERT(m_BufferImageUsage == VmaBufferImageUsage::UNKNOWN);
|
||||
m_BufferImageUsage = VmaBufferImageUsage(createInfo, useKhrMaintenance5);
|
||||
}
|
||||
void InitImageUsage(const VkImageCreateInfo &createInfo)
|
||||
{
|
||||
VMA_ASSERT(m_BufferImageUsage == VmaBufferImageUsage::UNKNOWN);
|
||||
m_BufferImageUsage = VmaBufferImageUsage(createInfo);
|
||||
}
|
||||
void PrintParameters(class VmaJsonWriter& json) const;
|
||||
#endif
|
||||
|
||||
@ -6174,7 +6279,7 @@ private:
|
||||
uint8_t m_MapCount;
|
||||
uint8_t m_Flags; // enum FLAGS
|
||||
#if VMA_STATS_STRING_ENABLED
|
||||
uint32_t m_BufferImageUsage; // 0 if unknown.
|
||||
VmaBufferImageUsage m_BufferImageUsage; // 0 if unknown.
|
||||
#endif
|
||||
};
|
||||
#endif // _VMA_ALLOCATION_T
|
||||
@ -6514,10 +6619,10 @@ void VmaBlockMetadata::DebugLogAllocation(VkDeviceSize offset, VkDeviceSize size
|
||||
const char* name = allocation->GetName();
|
||||
|
||||
#if VMA_STATS_STRING_ENABLED
|
||||
VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %s; Usage: %" PRIu32,
|
||||
VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %s; Usage: %" PRIu64,
|
||||
offset, size, userData, name ? name : "vma_empty",
|
||||
VMA_SUBALLOCATION_TYPE_NAMES[allocation->GetSuballocationType()],
|
||||
allocation->GetBufferImageUsage());
|
||||
(uint64_t)allocation->GetBufferImageUsage().Value);
|
||||
#else
|
||||
VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %u",
|
||||
offset, size, userData, name ? name : "vma_empty",
|
||||
@ -7811,6 +7916,10 @@ bool VmaBlockMetadata_Linear::CreateAllocationRequest(
|
||||
VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
|
||||
VMA_ASSERT(pAllocationRequest != VMA_NULL);
|
||||
VMA_HEAVY_ASSERT(Validate());
|
||||
|
||||
if(allocSize > GetSize())
|
||||
return false;
|
||||
|
||||
pAllocationRequest->size = allocSize;
|
||||
return upperAddress ?
|
||||
CreateAllocationRequest_UpperAddress(
|
||||
@ -9960,8 +10069,8 @@ struct VmaAllocator_T
|
||||
{
|
||||
VMA_CLASS_NO_COPY_NO_MOVE(VmaAllocator_T)
|
||||
public:
|
||||
bool m_UseMutex;
|
||||
uint32_t m_VulkanApiVersion;
|
||||
const bool m_UseMutex;
|
||||
const uint32_t m_VulkanApiVersion;
|
||||
bool m_UseKhrDedicatedAllocation; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
|
||||
bool m_UseKhrBindMemory2; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
|
||||
bool m_UseExtMemoryBudget;
|
||||
@ -9969,10 +10078,11 @@ public:
|
||||
bool m_UseKhrBufferDeviceAddress;
|
||||
bool m_UseExtMemoryPriority;
|
||||
bool m_UseKhrMaintenance4;
|
||||
VkDevice m_hDevice;
|
||||
VkInstance m_hInstance;
|
||||
bool m_AllocationCallbacksSpecified;
|
||||
VkAllocationCallbacks m_AllocationCallbacks;
|
||||
bool m_UseKhrMaintenance5;
|
||||
const VkDevice m_hDevice;
|
||||
const VkInstance m_hInstance;
|
||||
const bool m_AllocationCallbacksSpecified;
|
||||
const VkAllocationCallbacks m_AllocationCallbacks;
|
||||
VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
|
||||
VmaAllocationObjectAllocator m_AllocationObjectAllocator;
|
||||
|
||||
@ -10053,7 +10163,7 @@ public:
|
||||
VkResult FindMemoryTypeIndex(
|
||||
uint32_t memoryTypeBits,
|
||||
const VmaAllocationCreateInfo* pAllocationCreateInfo,
|
||||
VkFlags bufImgUsage, // VkBufferCreateInfo::usage or VkImageCreateInfo::usage. UINT32_MAX if unknown.
|
||||
VmaBufferImageUsage bufImgUsage,
|
||||
uint32_t* pMemoryTypeIndex) const;
|
||||
|
||||
// Main allocation function.
|
||||
@ -10063,7 +10173,7 @@ public:
|
||||
bool prefersDedicatedAllocation,
|
||||
VkBuffer dedicatedBuffer,
|
||||
VkImage dedicatedImage,
|
||||
VkFlags dedicatedBufferImageUsage, // UINT32_MAX if unknown.
|
||||
VmaBufferImageUsage dedicatedBufferImageUsage,
|
||||
const VmaAllocationCreateInfo& createInfo,
|
||||
VmaSuballocationType suballocType,
|
||||
size_t allocationCount,
|
||||
@ -10208,7 +10318,7 @@ private:
|
||||
bool dedicatedPreferred,
|
||||
VkBuffer dedicatedBuffer,
|
||||
VkImage dedicatedImage,
|
||||
VkFlags dedicatedBufferImageUsage,
|
||||
VmaBufferImageUsage dedicatedBufferImageUsage,
|
||||
const VmaAllocationCreateInfo& createInfo,
|
||||
uint32_t memTypeIndex,
|
||||
VmaSuballocationType suballocType,
|
||||
@ -10245,7 +10355,7 @@ private:
|
||||
float priority,
|
||||
VkBuffer dedicatedBuffer,
|
||||
VkImage dedicatedImage,
|
||||
VkFlags dedicatedBufferImageUsage,
|
||||
VmaBufferImageUsage dedicatedBufferImageUsage,
|
||||
size_t allocationCount,
|
||||
VmaAllocation* pAllocations,
|
||||
const void* pNextChain = VMA_NULL);
|
||||
@ -10446,11 +10556,11 @@ VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void
|
||||
|
||||
VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
|
||||
const uint32_t oldTotalMapCount = m_MapCount + m_MappingHysteresis.GetExtraMapping();
|
||||
m_MappingHysteresis.PostMap();
|
||||
if (oldTotalMapCount != 0)
|
||||
{
|
||||
m_MapCount += count;
|
||||
VMA_ASSERT(m_pMappedData != VMA_NULL);
|
||||
m_MappingHysteresis.PostMap();
|
||||
m_MapCount += count;
|
||||
if (ppData != VMA_NULL)
|
||||
{
|
||||
*ppData = m_pMappedData;
|
||||
@ -10468,11 +10578,13 @@ VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void
|
||||
&m_pMappedData);
|
||||
if (result == VK_SUCCESS)
|
||||
{
|
||||
VMA_ASSERT(m_pMappedData != VMA_NULL);
|
||||
m_MappingHysteresis.PostMap();
|
||||
m_MapCount = count;
|
||||
if (ppData != VMA_NULL)
|
||||
{
|
||||
*ppData = m_pMappedData;
|
||||
}
|
||||
m_MapCount = count;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
@ -10589,10 +10701,6 @@ VmaAllocation_T::VmaAllocation_T(bool mappingAllowed)
|
||||
{
|
||||
if(mappingAllowed)
|
||||
m_Flags |= (uint8_t)FLAG_MAPPING_ALLOWED;
|
||||
|
||||
#if VMA_STATS_STRING_ENABLED
|
||||
m_BufferImageUsage = 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
VmaAllocation_T::~VmaAllocation_T()
|
||||
@ -10675,11 +10783,11 @@ uint8_t VmaAllocation_T::SwapBlockAllocation(VmaAllocator hAllocator, VmaAllocat
|
||||
m_BlockAllocation.m_Block->Unmap(hAllocator, m_MapCount);
|
||||
|
||||
m_BlockAllocation.m_Block->m_pMetadata->SetAllocationUserData(m_BlockAllocation.m_AllocHandle, allocation);
|
||||
VMA_SWAP(m_BlockAllocation, allocation->m_BlockAllocation);
|
||||
std::swap(m_BlockAllocation, allocation->m_BlockAllocation);
|
||||
m_BlockAllocation.m_Block->m_pMetadata->SetAllocationUserData(m_BlockAllocation.m_AllocHandle, this);
|
||||
|
||||
#if VMA_STATS_STRING_ENABLED
|
||||
VMA_SWAP(m_BufferImageUsage, allocation->m_BufferImageUsage);
|
||||
std::swap(m_BufferImageUsage, allocation->m_BufferImageUsage);
|
||||
#endif
|
||||
return m_MapCount;
|
||||
}
|
||||
@ -10854,12 +10962,6 @@ void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
|
||||
}
|
||||
|
||||
#if VMA_STATS_STRING_ENABLED
|
||||
void VmaAllocation_T::InitBufferImageUsage(uint32_t bufferImageUsage)
|
||||
{
|
||||
VMA_ASSERT(m_BufferImageUsage == 0);
|
||||
m_BufferImageUsage = bufferImageUsage;
|
||||
}
|
||||
|
||||
void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
|
||||
{
|
||||
json.WriteString("Type");
|
||||
@ -10868,7 +10970,7 @@ void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
|
||||
json.WriteString("Size");
|
||||
json.WriteNumber(m_Size);
|
||||
json.WriteString("Usage");
|
||||
json.WriteNumber(m_BufferImageUsage);
|
||||
json.WriteNumber(m_BufferImageUsage.Value); // It may be uint32_t or uint64_t.
|
||||
|
||||
if (m_pUserData != VMA_NULL)
|
||||
{
|
||||
@ -11354,7 +11456,7 @@ void VmaBlockVector::IncrementallySortBlocks()
|
||||
{
|
||||
if (m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
|
||||
{
|
||||
VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
|
||||
std::swap(m_Blocks[i - 1], m_Blocks[i]);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -11891,13 +11993,13 @@ VkResult VmaDefragmentationContext_T::DefragmentPassEnd(VmaDefragmentationPassMo
|
||||
{
|
||||
if (vector->GetBlock(i) == block.block)
|
||||
{
|
||||
VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[vector->GetBlockCount() - ++m_ImmovableBlockCount]);
|
||||
std::swap(vector->m_Blocks[i], vector->m_Blocks[vector->GetBlockCount() - ++m_ImmovableBlockCount]);
|
||||
if (state.firstFreeBlock != SIZE_MAX)
|
||||
{
|
||||
if (i + 1 < state.firstFreeBlock)
|
||||
{
|
||||
if (state.firstFreeBlock > 1)
|
||||
VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[--state.firstFreeBlock]);
|
||||
std::swap(vector->m_Blocks[i], vector->m_Blocks[--state.firstFreeBlock]);
|
||||
else
|
||||
--state.firstFreeBlock;
|
||||
}
|
||||
@ -11924,7 +12026,7 @@ VkResult VmaDefragmentationContext_T::DefragmentPassEnd(VmaDefragmentationPassMo
|
||||
{
|
||||
if (vector->GetBlock(i) == block.block)
|
||||
{
|
||||
VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[m_ImmovableBlockCount++]);
|
||||
std::swap(vector->m_Blocks[i], vector->m_Blocks[m_ImmovableBlockCount++]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -12612,6 +12714,7 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
|
||||
m_UseKhrBufferDeviceAddress((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT) != 0),
|
||||
m_UseExtMemoryPriority((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT) != 0),
|
||||
m_UseKhrMaintenance4((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT) != 0),
|
||||
m_UseKhrMaintenance5((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT) != 0),
|
||||
m_hDevice(pCreateInfo->device),
|
||||
m_hInstance(pCreateInfo->instance),
|
||||
m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
|
||||
@ -12697,6 +12800,12 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
|
||||
VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT is set but required extension is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
|
||||
}
|
||||
#endif
|
||||
#if !(VMA_KHR_MAINTENANCE5)
|
||||
if(m_UseKhrMaintenance5)
|
||||
{
|
||||
VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT is set but required extension is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
|
||||
}
|
||||
#endif
|
||||
|
||||
memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
|
||||
memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
|
||||
@ -12775,7 +12884,7 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
|
||||
GetMemoryTypeMinAlignment(memTypeIndex), // minAllocationAlignment
|
||||
VMA_NULL); // // pMemoryAllocateNext
|
||||
// No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
|
||||
// becase minBlockCount is 0.
|
||||
// because minBlockCount is 0.
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -12858,7 +12967,7 @@ void VmaAllocator_T::ImportVulkanFunctions_Static()
|
||||
}
|
||||
#endif
|
||||
|
||||
#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
|
||||
#if VMA_VULKAN_VERSION >= 1001000
|
||||
if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
|
||||
{
|
||||
m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2)vkGetPhysicalDeviceMemoryProperties2;
|
||||
@ -12974,11 +13083,11 @@ void VmaAllocator_T::ImportVulkanFunctions_Dynamic()
|
||||
#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
|
||||
if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
|
||||
{
|
||||
VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2");
|
||||
VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2KHR, "vkGetPhysicalDeviceMemoryProperties2");
|
||||
}
|
||||
else if(m_UseExtMemoryBudget)
|
||||
{
|
||||
VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2KHR");
|
||||
VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2KHR, "vkGetPhysicalDeviceMemoryProperties2KHR");
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -13096,7 +13205,7 @@ VkResult VmaAllocator_T::AllocateMemoryOfType(
|
||||
bool dedicatedPreferred,
|
||||
VkBuffer dedicatedBuffer,
|
||||
VkImage dedicatedImage,
|
||||
VkFlags dedicatedBufferImageUsage,
|
||||
VmaBufferImageUsage dedicatedBufferImageUsage,
|
||||
const VmaAllocationCreateInfo& createInfo,
|
||||
uint32_t memTypeIndex,
|
||||
VmaSuballocationType suballocType,
|
||||
@ -13250,7 +13359,7 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory(
|
||||
float priority,
|
||||
VkBuffer dedicatedBuffer,
|
||||
VkImage dedicatedImage,
|
||||
VkFlags dedicatedBufferImageUsage,
|
||||
VmaBufferImageUsage dedicatedBufferImageUsage,
|
||||
size_t allocationCount,
|
||||
VmaAllocation* pAllocations,
|
||||
const void* pNextChain)
|
||||
@ -13290,8 +13399,8 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory(
|
||||
bool canContainBufferWithDeviceAddress = true;
|
||||
if(dedicatedBuffer != VK_NULL_HANDLE)
|
||||
{
|
||||
canContainBufferWithDeviceAddress = dedicatedBufferImageUsage == UINT32_MAX || // Usage flags unknown
|
||||
(dedicatedBufferImageUsage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT) != 0;
|
||||
canContainBufferWithDeviceAddress = dedicatedBufferImageUsage == VmaBufferImageUsage::UNKNOWN ||
|
||||
dedicatedBufferImageUsage.Contains(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT);
|
||||
}
|
||||
else if(dedicatedImage != VK_NULL_HANDLE)
|
||||
{
|
||||
@ -13503,7 +13612,7 @@ void VmaAllocator_T::GetImageMemoryRequirements(
|
||||
VkResult VmaAllocator_T::FindMemoryTypeIndex(
|
||||
uint32_t memoryTypeBits,
|
||||
const VmaAllocationCreateInfo* pAllocationCreateInfo,
|
||||
VkFlags bufImgUsage,
|
||||
VmaBufferImageUsage bufImgUsage,
|
||||
uint32_t* pMemoryTypeIndex) const
|
||||
{
|
||||
memoryTypeBits &= GetGlobalMemoryTypeBits();
|
||||
@ -13658,7 +13767,7 @@ VkResult VmaAllocator_T::AllocateMemory(
|
||||
bool prefersDedicatedAllocation,
|
||||
VkBuffer dedicatedBuffer,
|
||||
VkImage dedicatedImage,
|
||||
VkFlags dedicatedBufferImageUsage,
|
||||
VmaBufferImageUsage dedicatedBufferImageUsage,
|
||||
const VmaAllocationCreateInfo& createInfo,
|
||||
VmaSuballocationType suballocType,
|
||||
size_t allocationCount,
|
||||
@ -15031,7 +15140,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
|
||||
VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
|
||||
VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
|
||||
|
||||
return allocator->FindMemoryTypeIndex(memoryTypeBits, pAllocationCreateInfo, UINT32_MAX, pMemoryTypeIndex);
|
||||
return allocator->FindMemoryTypeIndex(memoryTypeBits, pAllocationCreateInfo, VmaBufferImageUsage::UNKNOWN, pMemoryTypeIndex);
|
||||
}
|
||||
|
||||
VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
|
||||
@ -15053,14 +15162,15 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
|
||||
if(funcs->vkGetDeviceBufferMemoryRequirements)
|
||||
{
|
||||
// Can query straight from VkBufferCreateInfo :)
|
||||
VkDeviceBufferMemoryRequirements devBufMemReq = {VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS};
|
||||
VkDeviceBufferMemoryRequirementsKHR devBufMemReq = {VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR};
|
||||
devBufMemReq.pCreateInfo = pBufferCreateInfo;
|
||||
|
||||
VkMemoryRequirements2 memReq = {VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2};
|
||||
(*funcs->vkGetDeviceBufferMemoryRequirements)(hDev, &devBufMemReq, &memReq);
|
||||
|
||||
res = allocator->FindMemoryTypeIndex(
|
||||
memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo, pBufferCreateInfo->usage, pMemoryTypeIndex);
|
||||
memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo,
|
||||
VmaBufferImageUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5), pMemoryTypeIndex);
|
||||
}
|
||||
else
|
||||
#endif // VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
|
||||
@ -15075,7 +15185,8 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
|
||||
funcs->vkGetBufferMemoryRequirements(hDev, hBuffer, &memReq);
|
||||
|
||||
res = allocator->FindMemoryTypeIndex(
|
||||
memReq.memoryTypeBits, pAllocationCreateInfo, pBufferCreateInfo->usage, pMemoryTypeIndex);
|
||||
memReq.memoryTypeBits, pAllocationCreateInfo,
|
||||
VmaBufferImageUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5), pMemoryTypeIndex);
|
||||
|
||||
funcs->vkDestroyBuffer(
|
||||
hDev, hBuffer, allocator->GetAllocationCallbacks());
|
||||
@ -15103,7 +15214,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
|
||||
if(funcs->vkGetDeviceImageMemoryRequirements)
|
||||
{
|
||||
// Can query straight from VkImageCreateInfo :)
|
||||
VkDeviceImageMemoryRequirements devImgMemReq = {VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS};
|
||||
VkDeviceImageMemoryRequirementsKHR devImgMemReq = {VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR};
|
||||
devImgMemReq.pCreateInfo = pImageCreateInfo;
|
||||
VMA_ASSERT(pImageCreateInfo->tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT_COPY && (pImageCreateInfo->flags & VK_IMAGE_CREATE_DISJOINT_BIT_COPY) == 0 &&
|
||||
"Cannot use this VkImageCreateInfo with vmaFindMemoryTypeIndexForImageInfo as I don't know what to pass as VkDeviceImageMemoryRequirements::planeAspect.");
|
||||
@ -15112,7 +15223,8 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
|
||||
(*funcs->vkGetDeviceImageMemoryRequirements)(hDev, &devImgMemReq, &memReq);
|
||||
|
||||
res = allocator->FindMemoryTypeIndex(
|
||||
memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo, pImageCreateInfo->usage, pMemoryTypeIndex);
|
||||
memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo,
|
||||
VmaBufferImageUsage(*pImageCreateInfo), pMemoryTypeIndex);
|
||||
}
|
||||
else
|
||||
#endif // VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
|
||||
@ -15127,7 +15239,8 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
|
||||
funcs->vkGetImageMemoryRequirements(hDev, hImage, &memReq);
|
||||
|
||||
res = allocator->FindMemoryTypeIndex(
|
||||
memReq.memoryTypeBits, pAllocationCreateInfo, pImageCreateInfo->usage, pMemoryTypeIndex);
|
||||
memReq.memoryTypeBits, pAllocationCreateInfo,
|
||||
VmaBufferImageUsage(*pImageCreateInfo), pMemoryTypeIndex);
|
||||
|
||||
funcs->vkDestroyImage(
|
||||
hDev, hImage, allocator->GetAllocationCallbacks());
|
||||
@ -15250,7 +15363,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
|
||||
false, // prefersDedicatedAllocation
|
||||
VK_NULL_HANDLE, // dedicatedBuffer
|
||||
VK_NULL_HANDLE, // dedicatedImage
|
||||
UINT32_MAX, // dedicatedBufferImageUsage
|
||||
VmaBufferImageUsage::UNKNOWN, // dedicatedBufferImageUsage
|
||||
*pCreateInfo,
|
||||
VMA_SUBALLOCATION_TYPE_UNKNOWN,
|
||||
1, // allocationCount
|
||||
@ -15289,7 +15402,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
|
||||
false, // prefersDedicatedAllocation
|
||||
VK_NULL_HANDLE, // dedicatedBuffer
|
||||
VK_NULL_HANDLE, // dedicatedImage
|
||||
UINT32_MAX, // dedicatedBufferImageUsage
|
||||
VmaBufferImageUsage::UNKNOWN, // dedicatedBufferImageUsage
|
||||
*pCreateInfo,
|
||||
VMA_SUBALLOCATION_TYPE_UNKNOWN,
|
||||
allocationCount,
|
||||
@ -15332,7 +15445,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
|
||||
prefersDedicatedAllocation,
|
||||
buffer, // dedicatedBuffer
|
||||
VK_NULL_HANDLE, // dedicatedImage
|
||||
UINT32_MAX, // dedicatedBufferImageUsage
|
||||
VmaBufferImageUsage::UNKNOWN, // dedicatedBufferImageUsage
|
||||
*pCreateInfo,
|
||||
VMA_SUBALLOCATION_TYPE_BUFFER,
|
||||
1, // allocationCount
|
||||
@ -15371,7 +15484,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
|
||||
prefersDedicatedAllocation,
|
||||
VK_NULL_HANDLE, // dedicatedBuffer
|
||||
image, // dedicatedImage
|
||||
UINT32_MAX, // dedicatedBufferImageUsage
|
||||
VmaBufferImageUsage::UNKNOWN, // dedicatedBufferImageUsage
|
||||
*pCreateInfo,
|
||||
VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
|
||||
1, // allocationCount
|
||||
@ -15808,7 +15921,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
|
||||
prefersDedicatedAllocation,
|
||||
*pBuffer, // dedicatedBuffer
|
||||
VK_NULL_HANDLE, // dedicatedImage
|
||||
pBufferCreateInfo->usage, // dedicatedBufferImageUsage
|
||||
VmaBufferImageUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5), // dedicatedBufferImageUsage
|
||||
*pAllocationCreateInfo,
|
||||
VMA_SUBALLOCATION_TYPE_BUFFER,
|
||||
1, // allocationCount
|
||||
@ -15825,7 +15938,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
|
||||
{
|
||||
// All steps succeeded.
|
||||
#if VMA_STATS_STRING_ENABLED
|
||||
(*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
|
||||
(*pAllocation)->InitBufferUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5);
|
||||
#endif
|
||||
if(pAllocationInfo != VMA_NULL)
|
||||
{
|
||||
@ -15903,7 +16016,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBufferWithAlignment(
|
||||
prefersDedicatedAllocation,
|
||||
*pBuffer, // dedicatedBuffer
|
||||
VK_NULL_HANDLE, // dedicatedImage
|
||||
pBufferCreateInfo->usage, // dedicatedBufferImageUsage
|
||||
VmaBufferImageUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5), // dedicatedBufferImageUsage
|
||||
*pAllocationCreateInfo,
|
||||
VMA_SUBALLOCATION_TYPE_BUFFER,
|
||||
1, // allocationCount
|
||||
@ -15920,7 +16033,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBufferWithAlignment(
|
||||
{
|
||||
// All steps succeeded.
|
||||
#if VMA_STATS_STRING_ENABLED
|
||||
(*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
|
||||
(*pAllocation)->InitBufferUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5);
|
||||
#endif
|
||||
if(pAllocationInfo != VMA_NULL)
|
||||
{
|
||||
@ -16079,7 +16192,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
|
||||
prefersDedicatedAllocation,
|
||||
VK_NULL_HANDLE, // dedicatedBuffer
|
||||
*pImage, // dedicatedImage
|
||||
pImageCreateInfo->usage, // dedicatedBufferImageUsage
|
||||
VmaBufferImageUsage(*pImageCreateInfo), // dedicatedBufferImageUsage
|
||||
*pAllocationCreateInfo,
|
||||
suballocType,
|
||||
1, // allocationCount
|
||||
@ -16096,7 +16209,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
|
||||
{
|
||||
// All steps succeeded.
|
||||
#if VMA_STATS_STRING_ENABLED
|
||||
(*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
|
||||
(*pAllocation)->InitImageUsage(*pImageCreateInfo);
|
||||
#endif
|
||||
if(pAllocationInfo != VMA_NULL)
|
||||
{
|
||||
@ -16444,7 +16557,7 @@ You may need to configure importing Vulkan functions. There are 3 ways to do thi
|
||||
\subsection quick_start_initialization_enabling_extensions Enabling extensions
|
||||
|
||||
VMA can automatically use following Vulkan extensions.
|
||||
If you found them availeble on the selected physical device and you enabled them
|
||||
If you found them available on the selected physical device and you enabled them
|
||||
while creating `VkInstance` / `VkDevice` object, inform VMA about their availability
|
||||
by setting appropriate flags in VmaAllocatorCreateInfo::flags.
|
||||
|
||||
@ -16453,7 +16566,9 @@ Vulkan extension | VMA flag
|
||||
VK_KHR_dedicated_allocation | #VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
|
||||
VK_KHR_bind_memory2 | #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT
|
||||
VK_KHR_maintenance4 | #VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT
|
||||
VK_KHR_maintenance5 | #VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT
|
||||
VK_EXT_memory_budget | #VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT
|
||||
VK_KHR_buffer_device_address | #VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT
|
||||
VK_EXT_memory_priority | #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT
|
||||
VK_AMD_device_coherent_memory | #VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT
|
||||
|
||||
@ -17221,7 +17336,7 @@ Many of the common concerns can be addressed in a different way than using custo
|
||||
- If you want to keep your allocations of certain size (small versus large) or certain lifetime (transient versus long lived)
|
||||
separate, you likely don't need to.
|
||||
VMA uses a high quality allocation algorithm that manages memory well in various cases.
|
||||
Please mesure and check if using custom pools provides a benefit.
|
||||
Please measure and check if using custom pools provides a benefit.
|
||||
- If you want to keep your images and buffers separate, you don't need to.
|
||||
VMA respects `bufferImageGranularity` limit automatically.
|
||||
- If you want to keep your mapped and not mapped allocations separate, you don't need to.
|
||||
@ -17846,6 +17961,19 @@ Margin validation (corruption detection) works only for memory types that are
|
||||
`HOST_VISIBLE` and `HOST_COHERENT`.
|
||||
|
||||
|
||||
\section debugging_memory_usage_leak_detection Leak detection features
|
||||
|
||||
At allocation and allocator destruction time VMA checks for unfreed and unmapped blocks using
|
||||
`VMA_ASSERT_LEAK()`. This macro defaults to an assertion, triggering a typically fatal error in Debug
|
||||
builds, and doing nothing in Release builds. You can provide your own definition of `VMA_ASSERT_LEAK()`
|
||||
to change this behavior.
|
||||
|
||||
At memory block destruction time VMA lists out all unfreed allocations using the `VMA_LEAK_LOG_FORMAT()`
|
||||
macro, which defaults to `VMA_DEBUG_LOG_FORMAT`, which in turn defaults to a no-op.
|
||||
If you're having trouble with leaks - for example, the aforementioned assertion triggers, but you don't
|
||||
quite know \em why -, overriding this macro to print out the the leaking blocks, combined with assigning
|
||||
individual names to allocations using vmaSetAllocationName(), can greatly aid in fixing them.
|
||||
|
||||
\page other_api_interop Interop with other graphics APIs
|
||||
|
||||
VMA provides some features that help with interoperability with other graphics APIs, e.g. OpenGL.
|
||||
@ -18340,7 +18468,7 @@ vmaCreateImage(allocator, &imgCreateInfo, &allocCreateInfo, &img, &alloc, nullpt
|
||||
`priority` member is ignored in the following situations:
|
||||
|
||||
- Allocations created in custom pools: They inherit the priority, along with all other allocation parameters
|
||||
from the parametrs passed in #VmaPoolCreateInfo when the pool was created.
|
||||
from the parameters passed in #VmaPoolCreateInfo when the pool was created.
|
||||
- Allocations created in default pools: They inherit the priority from the parameters
|
||||
VMA used when creating default pools, which means `priority == 0.5f`.
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user