mirror of
https://github.com/godotengine/godot
synced 2024-09-04 21:48:31 +00:00
Merge pull request #87091 from DeeJayLSP/vulkan-268
vulkan: Update components to Vulkan SDK 1.3.268.0
This commit is contained in:
commit
a3976bce7f
|
@ -508,7 +508,6 @@ Comment: Vulkan Headers
|
|||
Copyright: 2014-2023, The Khronos Group Inc.
|
||||
2014-2023, Valve Corporation
|
||||
2014-2023, LunarG, Inc.
|
||||
2015-2023, Google Inc.
|
||||
License: Apache-2.0
|
||||
|
||||
Files: ./thirdparty/vulkan/vk_mem_alloc.h
|
||||
|
|
12
thirdparty/README.md
vendored
12
thirdparty/README.md
vendored
|
@ -342,7 +342,7 @@ See the patches in the `patches` directory.
|
|||
## glslang
|
||||
|
||||
- Upstream: https://github.com/KhronosGroup/glslang
|
||||
- Version: sdk-1.3.261.1 (76b52ebf77833908dc4c0dd6c70a9c357ac720bd, 2023)
|
||||
- Version: vulkan-sdk-1.3.268.0 (36d08c0d940cf307a23928299ef52c7970d8cee6, 2023)
|
||||
- License: glslang
|
||||
|
||||
Version should be kept in sync with the one of the used Vulkan SDK (see `vulkan`
|
||||
|
@ -811,7 +811,7 @@ proposed by these libraries and better integrate them with Godot.
|
|||
## spirv-reflect
|
||||
|
||||
- Upstream: https://github.com/KhronosGroup/SPIRV-Reflect
|
||||
- Version: sdk-1.3.261.1 (d7e316e7d592d16ac58f1fe39b1df7babfe65c0d, 2023)
|
||||
- Version: vulkan-sdk-1.3.268.0 (3f468129720eded0cef4077302e491036d099856, 2023)
|
||||
- License: Apache 2.0
|
||||
|
||||
Version should be kept in sync with the one of the used Vulkan SDK (see `vulkan`
|
||||
|
@ -890,7 +890,7 @@ folder.
|
|||
## volk
|
||||
|
||||
- Upstream: https://github.com/zeux/volk
|
||||
- Version: sdk-1.3.261.1 (c1fc502109e539078d53c90ee1da9f32abbb0054, 2023)
|
||||
- Version: vulkan-sdk-1.3.268.0 (cdd08788bb7062031606d3da51e268f6bd491864, 2023)
|
||||
- License: MIT
|
||||
|
||||
Unless there is a specific reason to package a more recent version, please stick
|
||||
|
@ -909,7 +909,7 @@ Files extracted from upstream source:
|
|||
## vulkan
|
||||
|
||||
- Upstream: https://github.com/KhronosGroup/Vulkan-Headers
|
||||
- Version: sdk-1.3.261.1 (85c2334e92e215cce34e8e0ed8b2dce4700f4a50, 2023)
|
||||
- Version: vulkan-sdk-1.3.268.0 (7b3466a1f47a9251ac1113efbe022ff016e2f95b, 2023)
|
||||
- License: Apache 2.0
|
||||
|
||||
The vendored version should be kept in sync with volk, see above.
|
||||
|
@ -919,8 +919,8 @@ Files extracted from upstream source:
|
|||
- `include/`
|
||||
- `LICENSE.md`
|
||||
|
||||
`vk_enum_string_helper.h` is taken from the matching `Vulkan-ValidationLayers`
|
||||
SDK release: https://github.com/KhronosGroup/Vulkan-ValidationLayers/blob/main/layers/vulkan/generated/vk_enum_string_helper.h
|
||||
`vk_enum_string_helper.h` is taken from the matching `Vulkan-Utility-Libraries`
|
||||
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 (e88fff957b94f4b541ccac67a4290f07e52aa610), as advised by upstream:
|
||||
|
|
3
thirdparty/glslang/SPIRV/GLSL.ext.NV.h
vendored
3
thirdparty/glslang/SPIRV/GLSL.ext.NV.h
vendored
|
@ -84,4 +84,7 @@ const char* const E_SPV_NV_shader_sm_builtins = "SPV_NV_shader_sm_builtins";
|
|||
//SPV_NV_shader_execution_reorder
|
||||
const char* const E_SPV_NV_shader_invocation_reorder = "SPV_NV_shader_invocation_reorder";
|
||||
|
||||
//SPV_NV_displacement_micromap
|
||||
const char* const E_SPV_NV_displacement_micromap = "SPV_NV_displacement_micromap";
|
||||
|
||||
#endif // #ifndef GLSLextNV_H
|
||||
|
|
41
thirdparty/glslang/SPIRV/GLSL.ext.QCOM.h
vendored
Normal file
41
thirdparty/glslang/SPIRV/GLSL.ext.QCOM.h
vendored
Normal file
|
@ -0,0 +1,41 @@
|
|||
/*
|
||||
** Copyright (c) 2021 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"),
|
||||
** to deal in the Materials without restriction, including without limitation
|
||||
** the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
** and/or sell copies of the Materials, and to permit persons to whom the
|
||||
** Materials are furnished to do so, subject to the following conditions:
|
||||
**
|
||||
** The above copyright notice and this permission notice shall be included in
|
||||
** all copies or substantial portions of the Materials.
|
||||
**
|
||||
** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
|
||||
** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
|
||||
** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
|
||||
**
|
||||
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
|
||||
** IN THE MATERIALS.
|
||||
*/
|
||||
|
||||
#ifndef GLSLextQCOM_H
|
||||
#define GLSLextQCOM_H
|
||||
|
||||
enum BuiltIn;
|
||||
enum Decoration;
|
||||
enum Op;
|
||||
enum Capability;
|
||||
|
||||
static const int GLSLextQCOMVersion = 100;
|
||||
static const int GLSLextQCOMRevision = 1;
|
||||
|
||||
//SPV_QCOM_image_processing
|
||||
const char* const E_SPV_QCOM_image_processing = "SPV_QCOM_image_processing";
|
||||
|
||||
#endif // #ifndef GLSLextQCOM_H
|
230
thirdparty/glslang/SPIRV/GlslangToSpv.cpp
vendored
230
thirdparty/glslang/SPIRV/GlslangToSpv.cpp
vendored
|
@ -50,6 +50,7 @@ namespace spv {
|
|||
#include "GLSL.ext.AMD.h"
|
||||
#include "GLSL.ext.NV.h"
|
||||
#include "GLSL.ext.ARM.h"
|
||||
#include "GLSL.ext.QCOM.h"
|
||||
#include "NonSemanticDebugPrintf.h"
|
||||
}
|
||||
|
||||
|
@ -132,7 +133,7 @@ public:
|
|||
bool visitLoop(glslang::TVisit, glslang::TIntermLoop*);
|
||||
bool visitBranch(glslang::TVisit visit, glslang::TIntermBranch*);
|
||||
|
||||
void finishSpv();
|
||||
void finishSpv(bool compileOnly);
|
||||
void dumpSpv(std::vector<unsigned int>& out);
|
||||
|
||||
protected:
|
||||
|
@ -166,6 +167,7 @@ protected:
|
|||
bool filterMember(const glslang::TType& member);
|
||||
spv::Id convertGlslangStructToSpvType(const glslang::TType&, const glslang::TTypeList* glslangStruct,
|
||||
glslang::TLayoutPacking, const glslang::TQualifier&);
|
||||
spv::LinkageType convertGlslangLinkageToSpv(glslang::TLinkType glslangLinkType);
|
||||
void decorateStructType(const glslang::TType&, const glslang::TTypeList* glslangStruct, glslang::TLayoutPacking,
|
||||
const glslang::TQualifier&, spv::Id, const std::vector<spv::Id>& spvMembers);
|
||||
spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim, bool allowZero = false);
|
||||
|
@ -220,6 +222,7 @@ 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);
|
||||
void addImageProcessingQCOMDecoration(spv::Id id, spv::Decoration decor);
|
||||
spv::Id createSpvConstant(const glslang::TIntermTyped&);
|
||||
spv::Id createSpvConstantFromConstUnionArray(const glslang::TType& type, const glslang::TConstUnionArray&,
|
||||
int& nextConst, bool specConstant);
|
||||
|
@ -1006,6 +1009,22 @@ spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltI
|
|||
builder.addExtension(spv::E_SPV_NV_ray_tracing_motion_blur);
|
||||
builder.addCapability(spv::CapabilityRayTracingMotionBlurNV);
|
||||
return spv::BuiltInCurrentRayTimeNV;
|
||||
case glslang::EbvMicroTrianglePositionNV:
|
||||
builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
|
||||
builder.addExtension("SPV_NV_displacement_micromap");
|
||||
return spv::BuiltInHitMicroTriangleVertexPositionsNV;
|
||||
case glslang::EbvMicroTriangleBaryNV:
|
||||
builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
|
||||
builder.addExtension("SPV_NV_displacement_micromap");
|
||||
return spv::BuiltInHitMicroTriangleVertexBarycentricsNV;
|
||||
case glslang::EbvHitKindFrontFacingMicroTriangleNV:
|
||||
builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
|
||||
builder.addExtension("SPV_NV_displacement_micromap");
|
||||
return spv::BuiltInHitKindFrontFacingMicroTriangleNV;
|
||||
case glslang::EbvHitKindBackFacingMicroTriangleNV:
|
||||
builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
|
||||
builder.addExtension("SPV_NV_displacement_micromap");
|
||||
return spv::BuiltInHitKindBackFacingMicroTriangleNV;
|
||||
|
||||
// barycentrics
|
||||
case glslang::EbvBaryCoordNV:
|
||||
|
@ -1586,8 +1605,12 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
|
|||
builder.addCapability(spv::CapabilityVariablePointers);
|
||||
}
|
||||
|
||||
shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str());
|
||||
entryPoint = builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str());
|
||||
// If not linking, there is no entry point
|
||||
if (!options.compileOnly) {
|
||||
shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str());
|
||||
entryPoint =
|
||||
builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str());
|
||||
}
|
||||
|
||||
// Add the source extensions
|
||||
const auto& sourceExtensions = glslangIntermediate->getRequestedExtensions();
|
||||
|
@ -1718,23 +1741,31 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
|
|||
}
|
||||
break;
|
||||
|
||||
case EShLangCompute:
|
||||
case EShLangCompute: {
|
||||
builder.addCapability(spv::CapabilityShader);
|
||||
if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
|
||||
std::vector<spv::Id> dimConstId;
|
||||
for (int dim = 0; dim < 3; ++dim) {
|
||||
bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet);
|
||||
dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
|
||||
if (specConst) {
|
||||
builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
|
||||
glslangIntermediate->getLocalSizeSpecId(dim));
|
||||
bool needSizeId = false;
|
||||
for (int dim = 0; dim < 3; ++dim) {
|
||||
if ((glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet)) {
|
||||
needSizeId = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
|
||||
}
|
||||
if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6 && needSizeId) {
|
||||
std::vector<spv::Id> dimConstId;
|
||||
for (int dim = 0; dim < 3; ++dim) {
|
||||
bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet);
|
||||
dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
|
||||
if (specConst) {
|
||||
builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
|
||||
glslangIntermediate->getLocalSizeSpecId(dim));
|
||||
needSizeId = true;
|
||||
}
|
||||
}
|
||||
builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
|
||||
} else {
|
||||
builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
|
||||
glslangIntermediate->getLocalSize(1),
|
||||
glslangIntermediate->getLocalSize(2));
|
||||
builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
|
||||
glslangIntermediate->getLocalSize(1),
|
||||
glslangIntermediate->getLocalSize(2));
|
||||
}
|
||||
if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupQuads) {
|
||||
builder.addCapability(spv::CapabilityComputeDerivativeGroupQuadsNV);
|
||||
|
@ -1746,6 +1777,7 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
|
|||
builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case EShLangTessEvaluation:
|
||||
case EShLangTessControl:
|
||||
builder.addCapability(spv::CapabilityTessellation);
|
||||
|
@ -1937,23 +1969,26 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
|
|||
}
|
||||
|
||||
// Finish creating SPV, after the traversal is complete.
|
||||
void TGlslangToSpvTraverser::finishSpv()
|
||||
void TGlslangToSpvTraverser::finishSpv(bool compileOnly)
|
||||
{
|
||||
// Finish the entry point function
|
||||
if (! entryPointTerminated) {
|
||||
builder.setBuildPoint(shaderEntry->getLastBlock());
|
||||
builder.leaveFunction();
|
||||
}
|
||||
// If not linking, an entry point is not expected
|
||||
if (!compileOnly) {
|
||||
// Finish the entry point function
|
||||
if (!entryPointTerminated) {
|
||||
builder.setBuildPoint(shaderEntry->getLastBlock());
|
||||
builder.leaveFunction();
|
||||
}
|
||||
|
||||
// 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);
|
||||
// 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);
|
||||
}
|
||||
|
||||
// Add capabilities, extensions, remove unneeded decorations, etc.,
|
||||
// based on the resulting SPIR-V.
|
||||
// Note: WebGPU code generation must have the opportunity to aggressively
|
||||
// prune unreachable merge blocks and continue targets.
|
||||
builder.postProcess();
|
||||
builder.postProcess(compileOnly);
|
||||
}
|
||||
|
||||
// Write the SPV into 'out'.
|
||||
|
@ -2012,7 +2047,7 @@ void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol)
|
|||
spv::StorageClass sc = builder.getStorageClass(id);
|
||||
// Before SPIR-V 1.4, we only want to include Input and Output.
|
||||
// Starting with SPIR-V 1.4, we want all globals.
|
||||
if ((glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4 && builder.isGlobalStorage(id)) ||
|
||||
if ((glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4 && builder.isGlobalVariable(id)) ||
|
||||
(sc == spv::StorageClassInput || sc == spv::StorageClassOutput)) {
|
||||
iOSet.insert(id);
|
||||
}
|
||||
|
@ -2838,9 +2873,12 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
|||
// In all cases, still let the traverser visit the children for us.
|
||||
makeFunctions(node->getAsAggregate()->getSequence());
|
||||
|
||||
// Also, we want all globals initializers to go into the beginning of the entry point, before
|
||||
// anything else gets there, so visit out of order, doing them all now.
|
||||
makeGlobalInitializers(node->getAsAggregate()->getSequence());
|
||||
// Global initializers is specific to the shader entry point, which does not exist in compile-only mode
|
||||
if (!options.compileOnly) {
|
||||
// Also, we want all globals initializers to go into the beginning of the entry point, before
|
||||
// anything else gets there, so visit out of order, doing them all now.
|
||||
makeGlobalInitializers(node->getAsAggregate()->getSequence());
|
||||
}
|
||||
|
||||
//Pre process linker objects for ray tracing stages
|
||||
if (glslangIntermediate->isRayTracingStage())
|
||||
|
@ -3276,6 +3314,26 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
|||
noReturnValue = true;
|
||||
break;
|
||||
|
||||
case glslang::EOpImageSampleWeightedQCOM:
|
||||
builder.addCapability(spv::CapabilityTextureSampleWeightedQCOM);
|
||||
builder.addExtension(spv::E_SPV_QCOM_image_processing);
|
||||
break;
|
||||
case glslang::EOpImageBoxFilterQCOM:
|
||||
builder.addCapability(spv::CapabilityTextureBoxFilterQCOM);
|
||||
builder.addExtension(spv::E_SPV_QCOM_image_processing);
|
||||
break;
|
||||
case glslang::EOpImageBlockMatchSADQCOM:
|
||||
case glslang::EOpImageBlockMatchSSDQCOM:
|
||||
builder.addCapability(spv::CapabilityTextureBlockMatchQCOM);
|
||||
builder.addExtension(spv::E_SPV_QCOM_image_processing);
|
||||
break;
|
||||
|
||||
case glslang::EOpFetchMicroTriangleVertexPositionNV:
|
||||
case glslang::EOpFetchMicroTriangleVertexBarycentricNV:
|
||||
builder.addExtension(spv::E_SPV_NV_displacement_micromap);
|
||||
builder.addCapability(spv::CapabilityDisplacementMicromapNV);
|
||||
break;
|
||||
|
||||
case glslang::EOpDebugPrintf:
|
||||
noReturnValue = true;
|
||||
break;
|
||||
|
@ -3640,7 +3698,10 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
|
|||
spv::Id typeId = builder.makeArrayType(builder.makeVectorType(builder.makeFloatType(32), 3),
|
||||
builder.makeUintConstant(3), 0);
|
||||
// do the op
|
||||
spv::Id result = builder.createOp(spv::OpRayQueryGetIntersectionTriangleVertexPositionsKHR, typeId, idImmOps);
|
||||
|
||||
spv::Op spvOp = spv::OpRayQueryGetIntersectionTriangleVertexPositionsKHR;
|
||||
|
||||
spv::Id result = builder.createOp(spvOp, typeId, idImmOps);
|
||||
// store the result to the pointer (out param 'm')
|
||||
builder.createStore(result, operands[2]);
|
||||
result = 0;
|
||||
|
@ -4313,6 +4374,16 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
|
|||
return convertGlslangToSpvType(type, getExplicitLayout(type), type.getQualifier(), false, forwardReferenceOnly);
|
||||
}
|
||||
|
||||
spv::LinkageType TGlslangToSpvTraverser::convertGlslangLinkageToSpv(glslang::TLinkType linkType)
|
||||
{
|
||||
switch (linkType) {
|
||||
case glslang::ELinkExport:
|
||||
return spv::LinkageTypeExport;
|
||||
default:
|
||||
return spv::LinkageTypeMax;
|
||||
}
|
||||
}
|
||||
|
||||
// Do full recursive conversion of an arbitrary glslang type to a SPIR-V Id.
|
||||
// explicitLayout can be kept the same throughout the hierarchical recursive walk.
|
||||
// Mutually recursive with convertGlslangStructToSpvType().
|
||||
|
@ -4476,26 +4547,27 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
|
|||
|
||||
std::vector<spv::IdImmediate> operands;
|
||||
for (const auto& typeParam : spirvType.typeParams) {
|
||||
if (typeParam.constant != nullptr) {
|
||||
if (typeParam.getAsConstant() != nullptr) {
|
||||
// Constant expression
|
||||
if (typeParam.constant->isLiteral()) {
|
||||
if (typeParam.constant->getBasicType() == glslang::EbtFloat) {
|
||||
float floatValue = static_cast<float>(typeParam.constant->getConstArray()[0].getDConst());
|
||||
auto constant = typeParam.getAsConstant();
|
||||
if (constant->isLiteral()) {
|
||||
if (constant->getBasicType() == glslang::EbtFloat) {
|
||||
float floatValue = static_cast<float>(constant->getConstArray()[0].getDConst());
|
||||
unsigned literal;
|
||||
static_assert(sizeof(literal) == sizeof(floatValue), "sizeof(unsigned) != sizeof(float)");
|
||||
memcpy(&literal, &floatValue, sizeof(literal));
|
||||
operands.push_back({false, literal});
|
||||
} else if (typeParam.constant->getBasicType() == glslang::EbtInt) {
|
||||
unsigned literal = typeParam.constant->getConstArray()[0].getIConst();
|
||||
} else if (constant->getBasicType() == glslang::EbtInt) {
|
||||
unsigned literal = constant->getConstArray()[0].getIConst();
|
||||
operands.push_back({false, literal});
|
||||
} else if (typeParam.constant->getBasicType() == glslang::EbtUint) {
|
||||
unsigned literal = typeParam.constant->getConstArray()[0].getUConst();
|
||||
} else if (constant->getBasicType() == glslang::EbtUint) {
|
||||
unsigned literal = constant->getConstArray()[0].getUConst();
|
||||
operands.push_back({false, literal});
|
||||
} else if (typeParam.constant->getBasicType() == glslang::EbtBool) {
|
||||
unsigned literal = typeParam.constant->getConstArray()[0].getBConst();
|
||||
} else if (constant->getBasicType() == glslang::EbtBool) {
|
||||
unsigned literal = constant->getConstArray()[0].getBConst();
|
||||
operands.push_back({false, literal});
|
||||
} else if (typeParam.constant->getBasicType() == glslang::EbtString) {
|
||||
auto str = typeParam.constant->getConstArray()[0].getSConst()->c_str();
|
||||
} else if (constant->getBasicType() == glslang::EbtString) {
|
||||
auto str = constant->getConstArray()[0].getSConst()->c_str();
|
||||
unsigned literal = 0;
|
||||
char* literalPtr = reinterpret_cast<char*>(&literal);
|
||||
unsigned charCount = 0;
|
||||
|
@ -4520,11 +4592,11 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
|
|||
} else
|
||||
assert(0); // Unexpected type
|
||||
} else
|
||||
operands.push_back({true, createSpvConstant(*typeParam.constant)});
|
||||
operands.push_back({true, createSpvConstant(*constant)});
|
||||
} else {
|
||||
// Type specifier
|
||||
assert(typeParam.type != nullptr);
|
||||
operands.push_back({true, convertGlslangToSpvType(*typeParam.type)});
|
||||
assert(typeParam.getAsType() != nullptr);
|
||||
operands.push_back({true, convertGlslangToSpvType(*typeParam.getAsType())});
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -5379,10 +5451,10 @@ void TGlslangToSpvTraverser::makeFunctions(const glslang::TIntermSequence& glslF
|
|||
}
|
||||
|
||||
spv::Block* functionBlock;
|
||||
spv::Function *function = builder.makeFunctionEntry(TranslatePrecisionDecoration(glslFunction->getType()),
|
||||
convertGlslangToSpvType(glslFunction->getType()),
|
||||
glslFunction->getName().c_str(), paramTypes, paramNames,
|
||||
paramDecorations, &functionBlock);
|
||||
spv::Function* function = builder.makeFunctionEntry(
|
||||
TranslatePrecisionDecoration(glslFunction->getType()), convertGlslangToSpvType(glslFunction->getType()),
|
||||
glslFunction->getName().c_str(), convertGlslangLinkageToSpv(glslFunction->getLinkType()), paramTypes,
|
||||
paramNames, paramDecorations, &functionBlock);
|
||||
if (implicitThis)
|
||||
function->setImplicitThis();
|
||||
|
||||
|
@ -7161,6 +7233,14 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDe
|
|||
unaryOp = spv::OpHitObjectGetShaderRecordBufferHandleNV;
|
||||
break;
|
||||
|
||||
case glslang::EOpFetchMicroTriangleVertexPositionNV:
|
||||
unaryOp = spv::OpFetchMicroTriangleVertexPositionNV;
|
||||
break;
|
||||
|
||||
case glslang::EOpFetchMicroTriangleVertexBarycentricNV:
|
||||
unaryOp = spv::OpFetchMicroTriangleVertexBarycentricNV;
|
||||
break;
|
||||
|
||||
case glslang::EOpCopyObject:
|
||||
unaryOp = spv::OpCopyObject;
|
||||
break;
|
||||
|
@ -9023,7 +9103,39 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
|
|||
return 0;
|
||||
|
||||
}
|
||||
|
||||
case glslang::EOpImageSampleWeightedQCOM:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
|
||||
opCode = spv::OpImageSampleWeightedQCOM;
|
||||
addImageProcessingQCOMDecoration(operands[2], spv::DecorationWeightTextureQCOM);
|
||||
break;
|
||||
case glslang::EOpImageBoxFilterQCOM:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
|
||||
opCode = spv::OpImageBoxFilterQCOM;
|
||||
break;
|
||||
case glslang::EOpImageBlockMatchSADQCOM:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
|
||||
opCode = spv::OpImageBlockMatchSADQCOM;
|
||||
addImageProcessingQCOMDecoration(operands[0], spv::DecorationBlockMatchTextureQCOM);
|
||||
addImageProcessingQCOMDecoration(operands[2], spv::DecorationBlockMatchTextureQCOM);
|
||||
break;
|
||||
case glslang::EOpImageBlockMatchSSDQCOM:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
|
||||
opCode = spv::OpImageBlockMatchSSDQCOM;
|
||||
addImageProcessingQCOMDecoration(operands[0], spv::DecorationBlockMatchTextureQCOM);
|
||||
addImageProcessingQCOMDecoration(operands[2], spv::DecorationBlockMatchTextureQCOM);
|
||||
break;
|
||||
|
||||
case glslang::EOpFetchMicroTriangleVertexBarycentricNV:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 2);
|
||||
opCode = spv::OpFetchMicroTriangleVertexBarycentricNV;
|
||||
break;
|
||||
|
||||
case glslang::EOpFetchMicroTriangleVertexPositionNV:
|
||||
typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
|
||||
opCode = spv::OpFetchMicroTriangleVertexPositionNV;
|
||||
break;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
|
@ -9568,6 +9680,20 @@ void TGlslangToSpvTraverser::addMeshNVDecoration(spv::Id id, int member, const g
|
|||
}
|
||||
}
|
||||
|
||||
void TGlslangToSpvTraverser::addImageProcessingQCOMDecoration(spv::Id id, spv::Decoration decor)
|
||||
{
|
||||
spv::Op opc = builder.getOpCode(id);
|
||||
if (opc == spv::OpSampledImage) {
|
||||
id = builder.getIdOperand(id, 0);
|
||||
opc = builder.getOpCode(id);
|
||||
}
|
||||
|
||||
if (opc == spv::OpLoad) {
|
||||
spv::Id texid = builder.getIdOperand(id, 0);
|
||||
builder.addDecoration(texid, decor);
|
||||
}
|
||||
}
|
||||
|
||||
// Make a full tree of instructions to build a SPIR-V specialization constant,
|
||||
// or regular constant if possible.
|
||||
//
|
||||
|
@ -10050,7 +10176,7 @@ void GlslangToSpv(const TIntermediate& intermediate, std::vector<unsigned int>&
|
|||
|
||||
TGlslangToSpvTraverser it(intermediate.getSpv().spv, &intermediate, logger, *options);
|
||||
root->traverse(&it);
|
||||
it.finishSpv();
|
||||
it.finishSpv(options->compileOnly);
|
||||
it.dumpSpv(spirv);
|
||||
|
||||
#if ENABLE_OPT
|
||||
|
|
66
thirdparty/glslang/SPIRV/SpvBuilder.cpp
vendored
66
thirdparty/glslang/SPIRV/SpvBuilder.cpp
vendored
|
@ -859,11 +859,19 @@ Id Builder::makeBoolDebugType(int const size)
|
|||
|
||||
Id Builder::makeIntegerDebugType(int const width, bool const hasSign)
|
||||
{
|
||||
const char* typeName = nullptr;
|
||||
switch (width) {
|
||||
case 8: typeName = hasSign ? "int8_t" : "uint8_t"; break;
|
||||
case 16: typeName = hasSign ? "int16_t" : "uint16_t"; break;
|
||||
case 64: typeName = hasSign ? "int64_t" : "uint64_t"; break;
|
||||
default: typeName = hasSign ? "int" : "uint";
|
||||
}
|
||||
auto nameId = getStringId(typeName);
|
||||
// try to find it
|
||||
Instruction* type;
|
||||
for (int t = 0; t < (int)groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].size(); ++t) {
|
||||
type = groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic][t];
|
||||
if (type->getIdOperand(0) == (hasSign ? getStringId("int") : getStringId("uint")) &&
|
||||
if (type->getIdOperand(0) == nameId &&
|
||||
type->getIdOperand(1) == static_cast<unsigned int>(width) &&
|
||||
type->getIdOperand(2) == (hasSign ? NonSemanticShaderDebugInfo100Signed : NonSemanticShaderDebugInfo100Unsigned))
|
||||
return type->getResultId();
|
||||
|
@ -873,11 +881,7 @@ Id Builder::makeIntegerDebugType(int const width, bool const hasSign)
|
|||
type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
|
||||
type->addIdOperand(nonSemanticShaderDebugInfo);
|
||||
type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeBasic);
|
||||
if(hasSign == true) {
|
||||
type->addIdOperand(getStringId("int")); // name id
|
||||
} else {
|
||||
type->addIdOperand(getStringId("uint")); // name id
|
||||
}
|
||||
type->addIdOperand(nameId); // name id
|
||||
type->addIdOperand(makeUintConstant(width)); // size id
|
||||
if(hasSign == true) {
|
||||
type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Signed)); // encoding id
|
||||
|
@ -895,11 +899,18 @@ Id Builder::makeIntegerDebugType(int const width, bool const hasSign)
|
|||
|
||||
Id Builder::makeFloatDebugType(int const width)
|
||||
{
|
||||
const char* typeName = nullptr;
|
||||
switch (width) {
|
||||
case 16: typeName = "float16_t"; break;
|
||||
case 64: typeName = "double"; break;
|
||||
default: typeName = "float"; break;
|
||||
}
|
||||
auto nameId = getStringId(typeName);
|
||||
// try to find it
|
||||
Instruction* type;
|
||||
for (int t = 0; t < (int)groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].size(); ++t) {
|
||||
type = groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic][t];
|
||||
if (type->getIdOperand(0) == getStringId("float") &&
|
||||
if (type->getIdOperand(0) == nameId &&
|
||||
type->getIdOperand(1) == static_cast<unsigned int>(width) &&
|
||||
type->getIdOperand(2) == NonSemanticShaderDebugInfo100Float)
|
||||
return type->getResultId();
|
||||
|
@ -909,7 +920,7 @@ Id Builder::makeFloatDebugType(int const width)
|
|||
type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
|
||||
type->addIdOperand(nonSemanticShaderDebugInfo);
|
||||
type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeBasic);
|
||||
type->addIdOperand(getStringId("float")); // name id
|
||||
type->addIdOperand(nameId); // name id
|
||||
type->addIdOperand(makeUintConstant(width)); // size id
|
||||
type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Float)); // encoding id
|
||||
type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100None)); // flags id
|
||||
|
@ -1018,7 +1029,10 @@ Id Builder::makeCompositeDebugType(std::vector<Id> const& memberTypes, char cons
|
|||
for(auto const memberType : memberTypes) {
|
||||
assert(debugTypeLocs.find(memberType) != debugTypeLocs.end());
|
||||
|
||||
memberDebugTypes.emplace_back(makeMemberDebugType(memberType, debugTypeLocs[memberType]));
|
||||
// There _should_ be debug types for all the member types but currently buffer references
|
||||
// do not have member debug info generated.
|
||||
if (debugId[memberType])
|
||||
memberDebugTypes.emplace_back(makeMemberDebugType(memberType, debugTypeLocs[memberType]));
|
||||
|
||||
// TODO: Need to rethink this method of passing location information.
|
||||
// debugTypeLocs.erase(memberType);
|
||||
|
@ -1824,6 +1838,10 @@ Instruction* Builder::addEntryPoint(ExecutionModel model, Function* function, co
|
|||
// Currently relying on the fact that all 'value' of interest are small non-negative values.
|
||||
void Builder::addExecutionMode(Function* entryPoint, ExecutionMode mode, int value1, int value2, int value3)
|
||||
{
|
||||
// entryPoint can be null if we are in compile-only mode
|
||||
if (!entryPoint)
|
||||
return;
|
||||
|
||||
Instruction* instr = new Instruction(OpExecutionMode);
|
||||
instr->addIdOperand(entryPoint->getId());
|
||||
instr->addImmediateOperand(mode);
|
||||
|
@ -1839,6 +1857,10 @@ void Builder::addExecutionMode(Function* entryPoint, ExecutionMode mode, int val
|
|||
|
||||
void Builder::addExecutionMode(Function* entryPoint, ExecutionMode mode, const std::vector<unsigned>& literals)
|
||||
{
|
||||
// entryPoint can be null if we are in compile-only mode
|
||||
if (!entryPoint)
|
||||
return;
|
||||
|
||||
Instruction* instr = new Instruction(OpExecutionMode);
|
||||
instr->addIdOperand(entryPoint->getId());
|
||||
instr->addImmediateOperand(mode);
|
||||
|
@ -1850,6 +1872,10 @@ void Builder::addExecutionMode(Function* entryPoint, ExecutionMode mode, const s
|
|||
|
||||
void Builder::addExecutionModeId(Function* entryPoint, ExecutionMode mode, const std::vector<Id>& operandIds)
|
||||
{
|
||||
// entryPoint can be null if we are in compile-only mode
|
||||
if (!entryPoint)
|
||||
return;
|
||||
|
||||
Instruction* instr = new Instruction(OpExecutionModeId);
|
||||
instr->addIdOperand(entryPoint->getId());
|
||||
instr->addImmediateOperand(mode);
|
||||
|
@ -1933,6 +1959,16 @@ void Builder::addDecoration(Id id, Decoration decoration, const std::vector<cons
|
|||
decorations.push_back(std::unique_ptr<Instruction>(dec));
|
||||
}
|
||||
|
||||
void Builder::addLinkageDecoration(Id id, const char* name, spv::LinkageType linkType) {
|
||||
Instruction* dec = new Instruction(OpDecorate);
|
||||
dec->addIdOperand(id);
|
||||
dec->addImmediateOperand(spv::DecorationLinkageAttributes);
|
||||
dec->addStringOperand(name);
|
||||
dec->addImmediateOperand(linkType);
|
||||
|
||||
decorations.push_back(std::unique_ptr<Instruction>(dec));
|
||||
}
|
||||
|
||||
void Builder::addDecorationId(Id id, Decoration decoration, Id idDecoration)
|
||||
{
|
||||
if (decoration == spv::DecorationMax)
|
||||
|
@ -2037,7 +2073,7 @@ Function* Builder::makeEntryPoint(const char* entryPoint)
|
|||
emitNonSemanticShaderDebugInfo = false;
|
||||
}
|
||||
|
||||
entryPointFunction = makeFunctionEntry(NoPrecision, returnType, entryPoint, paramsTypes, paramNames, decorations, &entry);
|
||||
entryPointFunction = makeFunctionEntry(NoPrecision, returnType, entryPoint, LinkageTypeMax, paramsTypes, paramNames, decorations, &entry);
|
||||
|
||||
emitNonSemanticShaderDebugInfo = restoreNonSemanticShaderDebugInfo;
|
||||
|
||||
|
@ -2045,7 +2081,7 @@ Function* Builder::makeEntryPoint(const char* entryPoint)
|
|||
}
|
||||
|
||||
// Comments in header
|
||||
Function* Builder::makeFunctionEntry(Decoration precision, Id returnType, const char* name,
|
||||
Function* Builder::makeFunctionEntry(Decoration precision, Id returnType, const char* name, LinkageType linkType,
|
||||
const std::vector<Id>& paramTypes, const std::vector<char const*>& paramNames,
|
||||
const std::vector<std::vector<Decoration>>& decorations, Block **entry)
|
||||
{
|
||||
|
@ -2053,7 +2089,7 @@ Function* Builder::makeFunctionEntry(Decoration precision, Id returnType, const
|
|||
Id typeId = makeFunctionType(returnType, paramTypes);
|
||||
Id firstParamId = paramTypes.size() == 0 ? 0 : getUniqueIds((int)paramTypes.size());
|
||||
Id funcId = getUniqueId();
|
||||
Function* function = new Function(funcId, returnType, typeId, firstParamId, module);
|
||||
Function* function = new Function(funcId, returnType, typeId, firstParamId, linkType, name, module);
|
||||
|
||||
// Set up the precisions
|
||||
setPrecision(function->getId(), precision);
|
||||
|
@ -2223,6 +2259,12 @@ void Builder::enterFunction(Function const* function)
|
|||
defInst->addIdOperand(funcId);
|
||||
buildPoint->addInstruction(std::unique_ptr<Instruction>(defInst));
|
||||
}
|
||||
|
||||
if (auto linkType = function->getLinkType(); linkType != LinkageTypeMax) {
|
||||
Id funcId = function->getFuncId();
|
||||
addCapability(CapabilityLinkage);
|
||||
addLinkageDecoration(funcId, function->getExportName(), linkType);
|
||||
}
|
||||
}
|
||||
|
||||
// Comments in header
|
||||
|
|
7
thirdparty/glslang/SPIRV/SpvBuilder.h
vendored
7
thirdparty/glslang/SPIRV/SpvBuilder.h
vendored
|
@ -261,6 +261,7 @@ public:
|
|||
ImageFormat getImageTypeFormat(Id typeId) const
|
||||
{ return (ImageFormat)module.getInstruction(typeId)->getImmediateOperand(6); }
|
||||
Id getResultingAccessChainType() const;
|
||||
Id getIdOperand(Id resultId, int idx) { return module.getInstruction(resultId)->getIdOperand(idx); }
|
||||
|
||||
bool isPointer(Id resultId) const { return isPointerType(getTypeId(resultId)); }
|
||||
bool isScalar(Id resultId) const { return isScalarType(getTypeId(resultId)); }
|
||||
|
@ -392,6 +393,7 @@ public:
|
|||
void addDecoration(Id, Decoration, const char*);
|
||||
void addDecoration(Id, Decoration, const std::vector<unsigned>& literals);
|
||||
void addDecoration(Id, Decoration, const std::vector<const char*>& strings);
|
||||
void addLinkageDecoration(Id id, const char* name, spv::LinkageType linkType);
|
||||
void addDecorationId(Id id, Decoration, Id idDecoration);
|
||||
void addDecorationId(Id id, Decoration, const std::vector<Id>& operandIds);
|
||||
void addMemberDecoration(Id, unsigned int member, Decoration, int num = -1);
|
||||
|
@ -416,7 +418,8 @@ public:
|
|||
// Return the function, pass back the entry.
|
||||
// The returned pointer is only valid for the lifetime of this builder.
|
||||
Function* makeFunctionEntry(Decoration precision, Id returnType, const char* name,
|
||||
const std::vector<Id>& paramTypes, const std::vector<char const*>& paramNames,
|
||||
LinkageType linkType, const std::vector<Id>& paramTypes,
|
||||
const std::vector<char const*>& paramNames,
|
||||
const std::vector<std::vector<Decoration>>& precisions, Block **entry = nullptr);
|
||||
|
||||
// Create a return. An 'implicit' return is one not appearing in the source
|
||||
|
@ -827,7 +830,7 @@ public:
|
|||
|
||||
// Add capabilities, extensions, remove unneeded decorations, etc.,
|
||||
// based on the resulting SPIR-V.
|
||||
void postProcess();
|
||||
void postProcess(bool compileOnly);
|
||||
|
||||
// Prune unreachable blocks in the CFG and remove unneeded decorations.
|
||||
void postProcessCFG();
|
||||
|
|
11
thirdparty/glslang/SPIRV/SpvPostProcess.cpp
vendored
11
thirdparty/glslang/SPIRV/SpvPostProcess.cpp
vendored
|
@ -53,6 +53,7 @@ namespace spv {
|
|||
#include "GLSL.ext.AMD.h"
|
||||
#include "GLSL.ext.NV.h"
|
||||
#include "GLSL.ext.ARM.h"
|
||||
#include "GLSL.ext.QCOM.h"
|
||||
}
|
||||
|
||||
namespace spv {
|
||||
|
@ -482,9 +483,13 @@ void Builder::postProcessFeatures() {
|
|||
}
|
||||
|
||||
// comment in header
|
||||
void Builder::postProcess() {
|
||||
postProcessCFG();
|
||||
postProcessFeatures();
|
||||
void Builder::postProcess(bool compileOnly)
|
||||
{
|
||||
// postProcessCFG needs an entrypoint to determine what is reachable, but if we are not creating an "executable" shader, we don't have an entrypoint
|
||||
if (!compileOnly)
|
||||
postProcessCFG();
|
||||
|
||||
postProcessFeatures();
|
||||
}
|
||||
|
||||
}; // end spv namespace
|
||||
|
|
1
thirdparty/glslang/SPIRV/SpvTools.h
vendored
1
thirdparty/glslang/SPIRV/SpvTools.h
vendored
|
@ -61,6 +61,7 @@ struct SpvOptions {
|
|||
bool validate {false};
|
||||
bool emitNonSemanticShaderDebugInfo {false};
|
||||
bool emitNonSemanticShaderDebugSource{ false };
|
||||
bool compileOnly{false};
|
||||
};
|
||||
|
||||
#if ENABLE_OPT
|
||||
|
|
1
thirdparty/glslang/SPIRV/disassemble.cpp
vendored
1
thirdparty/glslang/SPIRV/disassemble.cpp
vendored
|
@ -56,6 +56,7 @@ namespace spv {
|
|||
#include "GLSL.ext.NV.h"
|
||||
#include "GLSL.ext.ARM.h"
|
||||
#include "NonSemanticShaderDebugInfo100.h"
|
||||
#include "GLSL.ext.QCOM.h"
|
||||
}
|
||||
}
|
||||
const char* GlslStd450DebugNames[spv::GLSLstd450Count];
|
||||
|
|
68
thirdparty/glslang/SPIRV/doc.cpp
vendored
68
thirdparty/glslang/SPIRV/doc.cpp
vendored
|
@ -55,6 +55,7 @@ namespace spv {
|
|||
#include "GLSL.ext.AMD.h"
|
||||
#include "GLSL.ext.NV.h"
|
||||
#include "GLSL.ext.ARM.h"
|
||||
#include "GLSL.ext.QCOM.h"
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -311,7 +312,9 @@ const char* DecorationString(int decoration)
|
|||
case DecorationCeiling:
|
||||
default: return "Bad";
|
||||
|
||||
case DecorationExplicitInterpAMD: return "ExplicitInterpAMD";
|
||||
case DecorationWeightTextureQCOM: return "DecorationWeightTextureQCOM";
|
||||
case DecorationBlockMatchTextureQCOM: return "DecorationBlockMatchTextureQCOM";
|
||||
case DecorationExplicitInterpAMD: return "ExplicitInterpAMD";
|
||||
case DecorationOverrideCoverageNV: return "OverrideCoverageNV";
|
||||
case DecorationPassthroughNV: return "PassthroughNV";
|
||||
case DecorationViewportRelativeNV: return "ViewportRelativeNV";
|
||||
|
@ -411,6 +414,10 @@ const char* BuiltInString(int builtIn)
|
|||
case BuiltInRayTmaxKHR: return "RayTmaxKHR";
|
||||
case BuiltInCullMaskKHR: return "CullMaskKHR";
|
||||
case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
|
||||
case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV";
|
||||
case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
|
||||
case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
|
||||
case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
|
||||
case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR";
|
||||
case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR";
|
||||
case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR";
|
||||
|
@ -974,6 +981,8 @@ const char* CapabilityString(int info)
|
|||
case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR";
|
||||
case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
|
||||
case CapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR";
|
||||
case CapabilityDisplacementMicromapNV: return "DisplacementMicromapNV";
|
||||
case CapabilityRayTracingDisplacementMicromapNV: return "CapabilityRayTracingDisplacementMicromapNV";
|
||||
case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR";
|
||||
case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV";
|
||||
case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV";
|
||||
|
@ -1040,6 +1049,11 @@ const char* CapabilityString(int info)
|
|||
case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM";
|
||||
|
||||
case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
|
||||
|
||||
case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM";
|
||||
case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM";
|
||||
case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM";
|
||||
|
||||
default: return "Bad";
|
||||
}
|
||||
}
|
||||
|
@ -1534,10 +1548,18 @@ const char* OpcodeString(int op)
|
|||
case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
|
||||
case OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV";
|
||||
|
||||
case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV";
|
||||
case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV";
|
||||
|
||||
case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT";
|
||||
case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT";
|
||||
case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT";
|
||||
|
||||
case OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM";
|
||||
case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM";
|
||||
case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM";
|
||||
case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM";
|
||||
|
||||
default:
|
||||
return "Bad";
|
||||
}
|
||||
|
@ -3069,7 +3091,7 @@ void Parameterize()
|
|||
|
||||
InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'RayQuery'");
|
||||
InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'Committed'");
|
||||
InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true);
|
||||
InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
|
||||
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
|
||||
|
@ -3335,10 +3357,52 @@ void Parameterize()
|
|||
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Payload'");
|
||||
InstructionDesc[OpHitObjectTraceRayMotionNV].setResultAndType(false, false);
|
||||
|
||||
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Acceleration Structure'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Instance ID'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Geometry Index'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Primitive Index'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Barycentrics'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Acceleration Structure'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Instance ID'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Geometry Index'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Primitive Index'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Barycentrics'");
|
||||
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpColorAttachmentReadEXT].operands.push(OperandId, "'Attachment'");
|
||||
InstructionDesc[OpColorAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
|
||||
InstructionDesc[OpStencilAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
|
||||
InstructionDesc[OpDepthAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
|
||||
|
||||
InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'source texture'");
|
||||
InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'texture coordinates'");
|
||||
InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'weights texture'");
|
||||
InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandImageOperands, "", true);
|
||||
InstructionDesc[OpImageSampleWeightedQCOM].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'source texture'");
|
||||
InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'texture coordinates'");
|
||||
InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'box size'");
|
||||
InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandImageOperands, "", true);
|
||||
InstructionDesc[OpImageBoxFilterQCOM].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'target texture'");
|
||||
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'target coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'reference texture'");
|
||||
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'reference coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'block size'");
|
||||
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandImageOperands, "", true);
|
||||
InstructionDesc[OpImageBlockMatchSADQCOM].setResultAndType(true, true);
|
||||
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'target texture'");
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'target coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'reference texture'");
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'reference coordinates'");
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'block size'");
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandImageOperands, "", true);
|
||||
InstructionDesc[OpImageBlockMatchSSDQCOM].setResultAndType(true, true);
|
||||
});
|
||||
}
|
||||
|
||||
|
|
21
thirdparty/glslang/SPIRV/spirv.hpp
vendored
21
thirdparty/glslang/SPIRV/spirv.hpp
vendored
|
@ -513,6 +513,8 @@ enum Decoration {
|
|||
DecorationMaxByteOffsetId = 47,
|
||||
DecorationNoSignedWrap = 4469,
|
||||
DecorationNoUnsignedWrap = 4470,
|
||||
DecorationWeightTextureQCOM = 4487,
|
||||
DecorationBlockMatchTextureQCOM = 4488,
|
||||
DecorationExplicitInterpAMD = 4999,
|
||||
DecorationOverrideCoverageNV = 5248,
|
||||
DecorationPassthroughNV = 5250,
|
||||
|
@ -718,6 +720,10 @@ enum BuiltIn {
|
|||
BuiltInHitKindNV = 5333,
|
||||
BuiltInCurrentRayTimeNV = 5334,
|
||||
BuiltInHitTriangleVertexPositionsKHR = 5335,
|
||||
BuiltInHitMicroTriangleVertexPositionsNV = 5337,
|
||||
BuiltInHitMicroTriangleVertexBarycentricsNV = 5344,
|
||||
BuiltInHitKindFrontFacingMicroTriangleNV = 5405,
|
||||
BuiltInHitKindBackFacingMicroTriangleNV = 5406,
|
||||
BuiltInIncomingRayFlagsKHR = 5351,
|
||||
BuiltInIncomingRayFlagsNV = 5351,
|
||||
BuiltInRayGeometryIndexKHR = 5352,
|
||||
|
@ -1023,6 +1029,9 @@ enum Capability {
|
|||
CapabilityRayQueryKHR = 4472,
|
||||
CapabilityRayTraversalPrimitiveCullingKHR = 4478,
|
||||
CapabilityRayTracingKHR = 4479,
|
||||
CapabilityTextureSampleWeightedQCOM = 4484,
|
||||
CapabilityTextureBoxFilterQCOM = 4485,
|
||||
CapabilityTextureBlockMatchQCOM = 4486,
|
||||
CapabilityFloat16ImageAMD = 5008,
|
||||
CapabilityImageGatherBiasLodAMD = 5009,
|
||||
CapabilityFragmentMaskAMD = 5010,
|
||||
|
@ -1089,6 +1098,8 @@ enum Capability {
|
|||
CapabilityFragmentShaderPixelInterlockEXT = 5378,
|
||||
CapabilityDemoteToHelperInvocation = 5379,
|
||||
CapabilityDemoteToHelperInvocationEXT = 5379,
|
||||
CapabilityDisplacementMicromapNV = 5380,
|
||||
CapabilityRayTracingDisplacementMicromapNV = 5409,
|
||||
CapabilityRayTracingOpacityMicromapEXT = 5381,
|
||||
CapabilityShaderInvocationReorderNV = 5383,
|
||||
CapabilityBindlessTextureNV = 5390,
|
||||
|
@ -1678,6 +1689,10 @@ enum Op {
|
|||
OpRayQueryConfirmIntersectionKHR = 4476,
|
||||
OpRayQueryProceedKHR = 4477,
|
||||
OpRayQueryGetIntersectionTypeKHR = 4479,
|
||||
OpImageSampleWeightedQCOM = 4480,
|
||||
OpImageBoxFilterQCOM = 4481,
|
||||
OpImageBlockMatchSSDQCOM = 4482,
|
||||
OpImageBlockMatchSADQCOM = 4483,
|
||||
OpGroupIAddNonUniformAMD = 5000,
|
||||
OpGroupFAddNonUniformAMD = 5001,
|
||||
OpGroupFMinNonUniformAMD = 5002,
|
||||
|
@ -1727,6 +1742,8 @@ enum Op {
|
|||
OpSetMeshOutputsEXT = 5295,
|
||||
OpGroupNonUniformPartitionNV = 5296,
|
||||
OpWritePackedPrimitiveIndices4x8NV = 5299,
|
||||
OpFetchMicroTriangleVertexPositionNV = 5300,
|
||||
OpFetchMicroTriangleVertexBarycentricNV = 5301,
|
||||
OpReportIntersectionKHR = 5334,
|
||||
OpReportIntersectionNV = 5334,
|
||||
OpIgnoreIntersectionNV = 5335,
|
||||
|
@ -2395,6 +2412,10 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
|
|||
case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
|
||||
case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageSampleWeightedQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break;
|
||||
case OpImageBlockMatchSADQCOM: *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;
|
||||
|
|
17
thirdparty/glslang/SPIRV/spvIR.h
vendored
17
thirdparty/glslang/SPIRV/spvIR.h
vendored
|
@ -323,7 +323,7 @@ void inReadableOrder(Block* root, std::function<void(Block*, ReachReason, Block*
|
|||
|
||||
class Function {
|
||||
public:
|
||||
Function(Id id, Id resultType, Id functionType, Id firstParam, Module& parent);
|
||||
Function(Id id, Id resultType, Id functionType, Id firstParam, LinkageType linkage, const std::string& name, Module& parent);
|
||||
virtual ~Function()
|
||||
{
|
||||
for (int i = 0; i < (int)parameterInstructions.size(); ++i)
|
||||
|
@ -402,6 +402,9 @@ public:
|
|||
end.dump(out);
|
||||
}
|
||||
|
||||
LinkageType getLinkType() const { return linkType; }
|
||||
const char* getExportName() const { return exportName.c_str(); }
|
||||
|
||||
protected:
|
||||
Function(const Function&);
|
||||
Function& operator=(Function&);
|
||||
|
@ -414,6 +417,8 @@ protected:
|
|||
bool implicitThis; // true if this is a member function expecting to be passed a 'this' as the first argument
|
||||
bool reducedPrecisionReturn;
|
||||
std::set<int> reducedPrecisionParams; // list of parameter indexes that need a relaxed precision arg
|
||||
LinkageType linkType;
|
||||
std::string exportName;
|
||||
};
|
||||
|
||||
//
|
||||
|
@ -473,10 +478,11 @@ protected:
|
|||
// Add both
|
||||
// - the OpFunction instruction
|
||||
// - all the OpFunctionParameter instructions
|
||||
__inline Function::Function(Id id, Id resultType, Id functionType, Id firstParamId, Module& parent)
|
||||
__inline Function::Function(Id id, Id resultType, Id functionType, Id firstParamId, LinkageType linkage, const std::string& name, Module& parent)
|
||||
: parent(parent), lineInstruction(nullptr),
|
||||
functionInstruction(id, resultType, OpFunction), implicitThis(false),
|
||||
reducedPrecisionReturn(false)
|
||||
reducedPrecisionReturn(false),
|
||||
linkType(linkage)
|
||||
{
|
||||
// OpFunction
|
||||
functionInstruction.addImmediateOperand(FunctionControlMaskNone);
|
||||
|
@ -492,6 +498,11 @@ __inline Function::Function(Id id, Id resultType, Id functionType, Id firstParam
|
|||
parent.mapInstruction(param);
|
||||
parameterInstructions.push_back(param);
|
||||
}
|
||||
|
||||
// If importing/exporting, save the function name (without the mangled parameters) for the linkage decoration
|
||||
if (linkType != LinkageTypeMax) {
|
||||
exportName = name.substr(0, name.find_first_of('('));
|
||||
}
|
||||
}
|
||||
|
||||
__inline void Function::addLocalVariable(std::unique_ptr<Instruction> inst)
|
||||
|
|
|
@ -290,6 +290,12 @@ enum TBuiltInVariable {
|
|||
EbvLayerPerViewNV,
|
||||
EbvMeshViewCountNV,
|
||||
EbvMeshViewIndicesNV,
|
||||
|
||||
EbvMicroTrianglePositionNV,
|
||||
EbvMicroTriangleBaryNV,
|
||||
EbvHitKindFrontFacingMicroTriangleNV,
|
||||
EbvHitKindBackFacingMicroTriangleNV,
|
||||
|
||||
//GL_EXT_mesh_shader
|
||||
EbvPrimitivePointIndicesEXT,
|
||||
EbvPrimitiveLineIndicesEXT,
|
||||
|
@ -523,6 +529,9 @@ __inline const char* GetBuiltInVariableString(TBuiltInVariable v)
|
|||
case EbvShadingRateKHR: return "ShadingRateKHR";
|
||||
case EbvPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR";
|
||||
|
||||
case EbvHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
|
||||
case EbvHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
|
||||
|
||||
default: return "unknown built-in variable";
|
||||
}
|
||||
}
|
||||
|
|
13
thirdparty/glslang/glslang/Include/PoolAlloc.h
vendored
13
thirdparty/glslang/glslang/Include/PoolAlloc.h
vendored
|
@ -118,11 +118,16 @@ private:
|
|||
unsigned char* mem; // beginning of our allocation (pts to header)
|
||||
TAllocation* prevAlloc; // prior allocation in the chain
|
||||
|
||||
const static unsigned char guardBlockBeginVal;
|
||||
const static unsigned char guardBlockEndVal;
|
||||
const static unsigned char userDataFill;
|
||||
static inline constexpr unsigned char guardBlockBeginVal = 0xfb;
|
||||
static inline constexpr unsigned char guardBlockEndVal = 0xfe;
|
||||
static inline constexpr unsigned char userDataFill = 0xcd;
|
||||
|
||||
# ifdef GUARD_BLOCKS
|
||||
static inline constexpr size_t guardBlockSize = 16;
|
||||
# else
|
||||
static inline constexpr size_t guardBlockSize = 0;
|
||||
# endif
|
||||
|
||||
const static size_t guardBlockSize;
|
||||
# ifdef GUARD_BLOCKS
|
||||
inline static size_t headerSize() { return sizeof(TAllocation); }
|
||||
# else
|
||||
|
|
|
@ -39,6 +39,7 @@
|
|||
// GL_EXT_spirv_intrinsics
|
||||
//
|
||||
#include "Common.h"
|
||||
#include <variant>
|
||||
|
||||
namespace glslang {
|
||||
|
||||
|
@ -96,23 +97,27 @@ struct TSpirvInstruction {
|
|||
struct TSpirvTypeParameter {
|
||||
POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
|
||||
|
||||
TSpirvTypeParameter(const TIntermConstantUnion* arg)
|
||||
{
|
||||
constant = arg;
|
||||
type = nullptr;
|
||||
}
|
||||
TSpirvTypeParameter(const TIntermConstantUnion* arg) { value = arg; }
|
||||
TSpirvTypeParameter(const TType* arg) { value = arg; }
|
||||
|
||||
TSpirvTypeParameter(const TType *arg)
|
||||
const TIntermConstantUnion* getAsConstant() const
|
||||
{
|
||||
constant = nullptr;
|
||||
type = arg;
|
||||
if (value.index() == 0)
|
||||
return std::get<const TIntermConstantUnion*>(value);
|
||||
return nullptr;
|
||||
}
|
||||
const TType* getAsType() const
|
||||
{
|
||||
if (value.index() == 1)
|
||||
return std::get<const TType*>(value);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool operator==(const TSpirvTypeParameter& rhs) const;
|
||||
bool operator!=(const TSpirvTypeParameter& rhs) const { return !operator==(rhs); }
|
||||
|
||||
const TIntermConstantUnion* constant; // Constant expression
|
||||
const TType* type; // Type specifier
|
||||
// Parameter value: constant expression or type specifier
|
||||
std::variant<const TIntermConstantUnion*, const TType*> value;
|
||||
};
|
||||
|
||||
typedef TVector<TSpirvTypeParameter> TSpirvTypeParameters;
|
||||
|
|
|
@ -1006,6 +1006,8 @@ enum TOperator {
|
|||
EOpHitObjectGetAttributesNV,
|
||||
EOpHitObjectGetCurrentTimeNV,
|
||||
EOpReorderThreadNV,
|
||||
EOpFetchMicroTriangleVertexPositionNV,
|
||||
EOpFetchMicroTriangleVertexBarycentricNV,
|
||||
|
||||
// HLSL operations
|
||||
//
|
||||
|
@ -1100,6 +1102,17 @@ enum TOperator {
|
|||
// Shader tile image ops
|
||||
EOpStencilAttachmentReadEXT, // Fragment only
|
||||
EOpDepthAttachmentReadEXT, // Fragment only
|
||||
|
||||
// Image processing
|
||||
EOpImageSampleWeightedQCOM,
|
||||
EOpImageBoxFilterQCOM,
|
||||
EOpImageBlockMatchSADQCOM,
|
||||
EOpImageBlockMatchSSDQCOM,
|
||||
};
|
||||
|
||||
enum TLinkType {
|
||||
ELinkNone,
|
||||
ELinkExport,
|
||||
};
|
||||
|
||||
class TIntermTraverser;
|
||||
|
@ -1319,9 +1332,11 @@ public:
|
|||
virtual const TString& getMethodName() const { return method; }
|
||||
virtual TIntermTyped* getObject() const { return object; }
|
||||
virtual void traverse(TIntermTraverser*);
|
||||
void setExport() { linkType = ELinkExport; }
|
||||
protected:
|
||||
TIntermTyped* object;
|
||||
TString method;
|
||||
TLinkType linkType;
|
||||
};
|
||||
|
||||
//
|
||||
|
@ -1694,6 +1709,9 @@ public:
|
|||
const TPragmaTable& getPragmaTable() const { return *pragmaTable; }
|
||||
void setSpirvInstruction(const TSpirvInstruction& inst) { spirvInst = inst; }
|
||||
const TSpirvInstruction& getSpirvInstruction() const { return spirvInst; }
|
||||
|
||||
void setLinkType(TLinkType l) { linkType = l; }
|
||||
TLinkType getLinkType() const { return linkType; }
|
||||
protected:
|
||||
TIntermAggregate(const TIntermAggregate&); // disallow copy constructor
|
||||
TIntermAggregate& operator=(const TIntermAggregate&); // disallow assignment operator
|
||||
|
@ -1705,6 +1723,7 @@ protected:
|
|||
bool debug;
|
||||
TPragmaTable* pragmaTable;
|
||||
TSpirvInstruction spirvInst;
|
||||
TLinkType linkType = ELinkNone;
|
||||
};
|
||||
|
||||
//
|
||||
|
|
|
@ -51,7 +51,6 @@
|
|||
// including identifying what extensions are needed if a version does not allow a symbol
|
||||
//
|
||||
|
||||
#include "../Include/intermediate.h"
|
||||
#include "Initialize.h"
|
||||
|
||||
namespace glslang {
|
||||
|
@ -61,10 +60,6 @@ const bool ARBCompatibility = true;
|
|||
|
||||
const bool ForwardCompatibility = false;
|
||||
|
||||
// change this back to false if depending on textual spellings of texturing calls when consuming the AST
|
||||
// Using PureOperatorBuiltins=false is deprecated.
|
||||
bool PureOperatorBuiltins = true;
|
||||
|
||||
namespace {
|
||||
|
||||
//
|
||||
|
@ -4113,6 +4108,19 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
|||
"\n");
|
||||
}
|
||||
|
||||
// Builtins for GL_EXT_texture_shadow_lod
|
||||
if ((profile == EEsProfile && version >= 300) || ((profile != EEsProfile && version >= 130))) {
|
||||
commonBuiltins.append(
|
||||
"float texture(sampler2DArrayShadow, vec4, float);"
|
||||
"float texture(samplerCubeArrayShadow, vec4, float, float);"
|
||||
"float textureLod(sampler2DArrayShadow, vec4, float);"
|
||||
"float textureLod(samplerCubeShadow, vec4, float);"
|
||||
"float textureLod(samplerCubeArrayShadow, vec4, float, float);"
|
||||
"float textureLodOffset(sampler2DArrayShadow, vec4, float, ivec2);"
|
||||
"float textureOffset(sampler2DArrayShadow, vec4 , ivec2, float);"
|
||||
"\n");
|
||||
}
|
||||
|
||||
if (profile != EEsProfile && version >= 450) {
|
||||
stageBuiltins[EShLangFragment].append(derivativesAndControl64bits);
|
||||
stageBuiltins[EShLangFragment].append(
|
||||
|
@ -4135,6 +4143,18 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
|||
|
||||
}
|
||||
|
||||
// QCOM_image_processing
|
||||
if ((profile == EEsProfile && version >= 310) ||
|
||||
(profile != EEsProfile && version >= 140)) {
|
||||
commonBuiltins.append(
|
||||
"vec4 textureWeightedQCOM(sampler2D, vec2, sampler2DArray);"
|
||||
"vec4 textureWeightedQCOM(sampler2D, vec2, sampler1DArray);"
|
||||
"vec4 textureBoxFilterQCOM(sampler2D, vec2, vec2);"
|
||||
"vec4 textureBlockMatchSADQCOM(sampler2D, uvec2, sampler2D, uvec2, uvec2);"
|
||||
"vec4 textureBlockMatchSSDQCOM(sampler2D, uvec2, sampler2D, uvec2, uvec2);"
|
||||
"\n");
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
//
|
||||
// Prototypes for built-in functions seen by vertex shaders only.
|
||||
|
@ -4624,7 +4644,7 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
|||
"uvec4 fragmentFetchAMD(usubpassInputMS, uint);"
|
||||
|
||||
"\n");
|
||||
}
|
||||
}
|
||||
|
||||
// Builtins for GL_NV_ray_tracing/GL_NV_ray_tracing_motion_blur/GL_EXT_ray_tracing/GL_EXT_ray_query/
|
||||
// GL_NV_shader_invocation_reorder/GL_KHR_ray_tracing_position_Fetch
|
||||
|
@ -4694,6 +4714,8 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
|||
"void reorderThreadNV(uint, uint);"
|
||||
"void reorderThreadNV(hitObjectNV);"
|
||||
"void reorderThreadNV(hitObjectNV, uint, uint);"
|
||||
"vec3 fetchMicroTriangleVertexPositionNV(accelerationStructureEXT, int, int, int, ivec2);"
|
||||
"vec2 fetchMicroTriangleVertexBarycentricNV(accelerationStructureEXT, int, int, int, ivec2);"
|
||||
"\n");
|
||||
stageBuiltins[EShLangIntersect].append(
|
||||
"bool reportIntersectionNV(float, uint);"
|
||||
|
@ -4811,6 +4833,20 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
|||
"void SetMeshOutputsEXT(uint, uint);"
|
||||
"\n");
|
||||
}
|
||||
// Builtins for GL_NV_displacement_micromap
|
||||
if ((profile != EEsProfile && version >= 460) || (profile == EEsProfile && version >= 320)) {
|
||||
stageBuiltins[EShLangMesh].append(
|
||||
"vec3 fetchMicroTriangleVertexPositionNV(accelerationStructureEXT, int, int, int, ivec2);"
|
||||
"vec2 fetchMicroTriangleVertexBarycentricNV(accelerationStructureEXT, int, int, int, ivec2);"
|
||||
"\n");
|
||||
|
||||
stageBuiltins[EShLangCompute].append(
|
||||
"vec3 fetchMicroTriangleVertexPositionNV(accelerationStructureEXT, int, int, int, ivec2);"
|
||||
"vec2 fetchMicroTriangleVertexBarycentricNV(accelerationStructureEXT, int, int, int, ivec2);"
|
||||
"\n");
|
||||
|
||||
}
|
||||
|
||||
|
||||
//============================================================================
|
||||
//
|
||||
|
@ -5993,6 +6029,8 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
|||
"const uint gl_RayFlagsForceOpacityMicromap2StateEXT = 1024U;"
|
||||
"const uint gl_HitKindFrontFacingTriangleEXT = 254U;"
|
||||
"const uint gl_HitKindBackFacingTriangleEXT = 255U;"
|
||||
"in uint gl_HitKindFrontFacingMicroTriangleNV;"
|
||||
"in uint gl_HitKindBackFacingMicroTriangleNV;"
|
||||
"\n";
|
||||
|
||||
const char *constRayQueryIntersection =
|
||||
|
@ -6081,7 +6119,10 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
|
|||
"in float gl_CurrentRayTimeNV;"
|
||||
"in uint gl_CullMaskEXT;"
|
||||
"in vec3 gl_HitTriangleVertexPositionsEXT[3];"
|
||||
"in vec3 gl_HitMicroTriangleVertexPositionsNV[3];"
|
||||
"in vec2 gl_HitMicroTriangleVertexBarycentricsNV[3];"
|
||||
"\n";
|
||||
|
||||
const char *missDecls =
|
||||
"in uvec3 gl_LaunchIDNV;"
|
||||
"in uvec3 gl_LaunchIDEXT;"
|
||||
|
@ -8095,7 +8136,7 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
BuiltInVariable("gl_ViewIndex", EbvViewIndex, symbolTable);
|
||||
}
|
||||
|
||||
if (profile != EEsProfile) {
|
||||
if (profile != EEsProfile) {
|
||||
BuiltInVariable("gl_SubGroupInvocationARB", EbvSubGroupInvocation, symbolTable);
|
||||
BuiltInVariable("gl_SubGroupEqMaskARB", EbvSubGroupEqMask, symbolTable);
|
||||
BuiltInVariable("gl_SubGroupGeMaskARB", EbvSubGroupGeMask, symbolTable);
|
||||
|
@ -8725,6 +8766,14 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
symbolTable.setFunctionExtensions("stencilAttachmentReadEXT", 1, &E_GL_EXT_shader_tile_image);
|
||||
symbolTable.setFunctionExtensions("depthAttachmentReadEXT", 1, &E_GL_EXT_shader_tile_image);
|
||||
symbolTable.setFunctionExtensions("colorAttachmentReadEXT", 1, &E_GL_EXT_shader_tile_image);
|
||||
|
||||
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);
|
||||
}
|
||||
break;
|
||||
|
||||
case EShLangCompute:
|
||||
|
@ -8885,6 +8934,11 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
symbolTable.setVariableExtensions("gl_ShadingRateFlag2HorizontalPixelsEXT", 1, &E_GL_EXT_fragment_shading_rate);
|
||||
symbolTable.setVariableExtensions("gl_ShadingRateFlag4HorizontalPixelsEXT", 1, &E_GL_EXT_fragment_shading_rate);
|
||||
}
|
||||
|
||||
if ((profile != EEsProfile && version >= 460)) {
|
||||
symbolTable.setFunctionExtensions("fetchMicroTriangleVertexPositionNV", 1, &E_GL_NV_displacement_micromap);
|
||||
symbolTable.setFunctionExtensions("fetchMicroTriangleVertexBarycentricNV", 1, &E_GL_NV_displacement_micromap);
|
||||
}
|
||||
break;
|
||||
|
||||
case EShLangRayGen:
|
||||
|
@ -8931,6 +8985,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
symbolTable.setVariableExtensions("gl_IncomingRayFlagsEXT", 1, &E_GL_EXT_ray_tracing);
|
||||
symbolTable.setVariableExtensions("gl_CurrentRayTimeNV", 1, &E_GL_NV_ray_tracing_motion_blur);
|
||||
symbolTable.setVariableExtensions("gl_HitTriangleVertexPositionsEXT", 1, &E_GL_EXT_ray_tracing_position_fetch);
|
||||
symbolTable.setVariableExtensions("gl_HitMicroTriangleVertexPositionsNV", 1, &E_GL_NV_displacement_micromap);
|
||||
symbolTable.setVariableExtensions("gl_HitMicroTriangleVertexBarycentricsNV", 1, &E_GL_NV_displacement_micromap);
|
||||
|
||||
symbolTable.setVariableExtensions("gl_DeviceIndex", 1, &E_GL_EXT_device_group);
|
||||
|
||||
|
@ -8976,6 +9032,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
symbolTable.setFunctionExtensions("hitObjectGetShaderBindingTableRecordIndexNV", 1, &E_GL_NV_shader_invocation_reorder);
|
||||
symbolTable.setFunctionExtensions("hitObjectGetShaderRecordBufferHandleNV", 1, &E_GL_NV_shader_invocation_reorder);
|
||||
symbolTable.setFunctionExtensions("reorderThreadNV", 1, &E_GL_NV_shader_invocation_reorder);
|
||||
symbolTable.setFunctionExtensions("fetchMicroTriangleVertexPositionNV", 1, &E_GL_NV_displacement_micromap);
|
||||
symbolTable.setFunctionExtensions("fetchMicroTriangleVertexBarycentricNV", 1, &E_GL_NV_displacement_micromap);
|
||||
|
||||
|
||||
BuiltInVariable("gl_LaunchIDNV", EbvLaunchId, symbolTable);
|
||||
|
@ -9015,6 +9073,10 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
BuiltInVariable("gl_DeviceIndex", EbvDeviceIndex, symbolTable);
|
||||
BuiltInVariable("gl_CurrentRayTimeNV", EbvCurrentRayTimeNV, symbolTable);
|
||||
BuiltInVariable("gl_HitTriangleVertexPositionsEXT", EbvPositionFetch, symbolTable);
|
||||
BuiltInVariable("gl_HitMicroTriangleVertexPositionsNV", EbvMicroTrianglePositionNV, symbolTable);
|
||||
BuiltInVariable("gl_HitMicroTriangleVertexBarycentricsNV", EbvMicroTriangleBaryNV, symbolTable);
|
||||
BuiltInVariable("gl_HitKindFrontFacingMicroTriangleNV", EbvHitKindFrontFacingMicroTriangleNV, symbolTable);
|
||||
BuiltInVariable("gl_HitKindBackFacingMicroTriangleNV", EbvHitKindBackFacingMicroTriangleNV, symbolTable);
|
||||
|
||||
// GL_ARB_shader_ballot
|
||||
symbolTable.setVariableExtensions("gl_SubGroupSizeARB", 1, &E_GL_ARB_shader_ballot);
|
||||
|
@ -9316,6 +9378,13 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
symbolTable.setVariableExtensions("gl_ShadingRateFlag2HorizontalPixelsEXT", 1, &E_GL_EXT_fragment_shading_rate);
|
||||
symbolTable.setVariableExtensions("gl_ShadingRateFlag4HorizontalPixelsEXT", 1, &E_GL_EXT_fragment_shading_rate);
|
||||
}
|
||||
|
||||
// Builtins for GL_NV_displacment_micromap
|
||||
if ((profile != EEsProfile && version >= 460)) {
|
||||
symbolTable.setFunctionExtensions("fetchMicroTriangleVertexPositionNV", 1, &E_GL_NV_displacement_micromap);
|
||||
symbolTable.setFunctionExtensions("fetchMicroTriangleVertexBarycentricNV", 1, &E_GL_NV_displacement_micromap);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case EShLangTask:
|
||||
|
@ -9890,6 +9959,14 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
symbolTable.relateToOperator("shadow2DEXT", EOpTexture);
|
||||
symbolTable.relateToOperator("shadow2DProjEXT", EOpTextureProj);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
switch(language) {
|
||||
|
@ -9981,9 +10058,18 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
symbolTable.relateToOperator("coopMatLoad", EOpCooperativeMatrixLoad);
|
||||
symbolTable.relateToOperator("coopMatStore", EOpCooperativeMatrixStore);
|
||||
symbolTable.relateToOperator("coopMatMulAdd", EOpCooperativeMatrixMulAdd);
|
||||
|
||||
if (profile != EEsProfile && version >= 460) {
|
||||
symbolTable.relateToOperator("fetchMicroTriangleVertexPositionNV", EOpFetchMicroTriangleVertexPositionNV);
|
||||
symbolTable.relateToOperator("fetchMicroTriangleVertexBarycentricNV", EOpFetchMicroTriangleVertexBarycentricNV);
|
||||
}
|
||||
break;
|
||||
|
||||
case EShLangRayGen:
|
||||
if (profile != EEsProfile && version >= 460) {
|
||||
symbolTable.relateToOperator("fetchMicroTriangleVertexPositionNV", EOpFetchMicroTriangleVertexPositionNV);
|
||||
symbolTable.relateToOperator("fetchMicroTriangleVertexBarycentricNV", EOpFetchMicroTriangleVertexBarycentricNV);
|
||||
} // fallthrough
|
||||
case EShLangClosestHit:
|
||||
case EShLangMiss:
|
||||
if (profile != EEsProfile && version >= 460) {
|
||||
|
@ -10030,7 +10116,7 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
if (profile != EEsProfile && version >= 460) {
|
||||
symbolTable.relateToOperator("reportIntersectionNV", EOpReportIntersection);
|
||||
symbolTable.relateToOperator("reportIntersectionEXT", EOpReportIntersection);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case EShLangAnyHit:
|
||||
if (profile != EEsProfile && version >= 460) {
|
||||
|
@ -10055,6 +10141,12 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
|
|||
if (profile != EEsProfile && version >= 450) {
|
||||
symbolTable.relateToOperator("SetMeshOutputsEXT", EOpSetMeshOutputsEXT);
|
||||
}
|
||||
|
||||
if (profile != EEsProfile && version >= 460) {
|
||||
// Builtins for GL_NV_displacement_micromap.
|
||||
symbolTable.relateToOperator("fetchMicroTriangleVertexPositionNV", EOpFetchMicroTriangleVertexPositionNV);
|
||||
symbolTable.relateToOperator("fetchMicroTriangleVertexBarycentricNV", EOpFetchMicroTriangleVertexBarycentricNV);
|
||||
}
|
||||
break;
|
||||
case EShLangTask:
|
||||
if ((profile != EEsProfile && version >= 450) || (profile == EEsProfile && version >= 320)) {
|
||||
|
|
|
@ -107,6 +107,9 @@ protected:
|
|||
int dimMap[EsdNumDims];
|
||||
};
|
||||
|
||||
// change this back to false if depending on textual spellings of texturing calls when consuming the AST
|
||||
// Using PureOperatorBuiltins=false is deprecated.
|
||||
constexpr bool PureOperatorBuiltins = true;
|
||||
} // end namespace glslang
|
||||
|
||||
#endif // _INITIALIZE_INCLUDED_
|
||||
|
|
|
@ -38,6 +38,7 @@
|
|||
//
|
||||
|
||||
#include "ParseHelper.h"
|
||||
#include "Initialize.h"
|
||||
#include "Scan.h"
|
||||
|
||||
#include "../OSDependent/osinclude.h"
|
||||
|
@ -1242,6 +1243,8 @@ TIntermAggregate* TParseContext::handleFunctionDefinition(const TSourceLoc& loc,
|
|||
error(loc, "function cannot take any parameter(s)", function.getName().c_str(), "");
|
||||
if (function.getType().getBasicType() != EbtVoid)
|
||||
error(loc, "", function.getType().getBasicTypeString().c_str(), "entry point cannot return a value");
|
||||
if (function.getLinkType() != ELinkNone)
|
||||
error(loc, "main function cannot be exported", "", "");
|
||||
}
|
||||
|
||||
//
|
||||
|
@ -1278,6 +1281,7 @@ TIntermAggregate* TParseContext::handleFunctionDefinition(const TSourceLoc& loc,
|
|||
} else
|
||||
paramNodes = intermediate.growAggregate(paramNodes, intermediate.addSymbol(*param.type, loc), loc);
|
||||
}
|
||||
paramNodes->setLinkType(function.getLinkType());
|
||||
intermediate.setAggregateOperator(paramNodes, EOpParameters, TType(EbtVoid), loc);
|
||||
loopNestingLevel = 0;
|
||||
statementNestingLevel = 0;
|
||||
|
@ -2168,6 +2172,37 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
|
|||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case EOpTexture:
|
||||
case EOpTextureLod:
|
||||
{
|
||||
if ((fnCandidate.getParamCount() > 2) && ((*argp)[1]->getAsTyped()->getType().getBasicType() == EbtFloat) &&
|
||||
((*argp)[1]->getAsTyped()->getType().getVectorSize() == 4) && fnCandidate[0].type->getSampler().shadow) {
|
||||
featureString = fnCandidate.getName();
|
||||
if (callNode.getOp() == EOpTexture)
|
||||
featureString += "(..., float bias)";
|
||||
else
|
||||
featureString += "(..., float lod)";
|
||||
feature = featureString.c_str();
|
||||
|
||||
if ((fnCandidate[0].type->getSampler().dim == Esd2D && fnCandidate[0].type->getSampler().arrayed) || //2D Array Shadow
|
||||
(fnCandidate[0].type->getSampler().dim == EsdCube && fnCandidate[0].type->getSampler().arrayed && fnCandidate.getParamCount() > 3) || // Cube Array Shadow
|
||||
(fnCandidate[0].type->getSampler().dim == EsdCube && callNode.getOp() == EOpTextureLod)) { // Cube Shadow
|
||||
requireExtensions(loc, 1, &E_GL_EXT_texture_shadow_lod, feature);
|
||||
if (isEsProfile()) {
|
||||
if (version < 320 &&
|
||||
!extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array))
|
||||
error(loc, "GL_EXT_texture_shadow_lod not supported for this ES version", feature, "");
|
||||
else
|
||||
profileRequires(loc, EEsProfile, 320, nullptr, feature);
|
||||
} else { // Desktop
|
||||
profileRequires(loc, ~EEsProfile, 130, nullptr, feature);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case EOpSparseTextureGather:
|
||||
case EOpSparseTextureGatherOffset:
|
||||
case EOpSparseTextureGatherOffsets:
|
||||
|
@ -2282,12 +2317,36 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
|
|||
if (callNode.getOp() == EOpTextureOffset) {
|
||||
TSampler s = arg0->getType().getSampler();
|
||||
if (s.is2D() && s.isArrayed() && s.isShadow()) {
|
||||
if (isEsProfile())
|
||||
if (
|
||||
((*argp)[1]->getAsTyped()->getType().getBasicType() == EbtFloat) &&
|
||||
((*argp)[1]->getAsTyped()->getType().getVectorSize() == 4) &&
|
||||
(fnCandidate.getParamCount() == 4)) {
|
||||
featureString = fnCandidate.getName() + " for sampler2DArrayShadow";
|
||||
feature = featureString.c_str();
|
||||
requireExtensions(loc, 1, &E_GL_EXT_texture_shadow_lod, feature);
|
||||
profileRequires(loc, EEsProfile, 300, nullptr, feature);
|
||||
profileRequires(loc, ~EEsProfile, 130, nullptr, feature);
|
||||
}
|
||||
else if (isEsProfile())
|
||||
error(loc, "TextureOffset does not support sampler2DArrayShadow : ", "sampler", "ES Profile");
|
||||
else if (version <= 420)
|
||||
error(loc, "TextureOffset does not support sampler2DArrayShadow : ", "sampler", "version <= 420");
|
||||
}
|
||||
}
|
||||
|
||||
if (callNode.getOp() == EOpTextureLodOffset) {
|
||||
TSampler s = arg0->getType().getSampler();
|
||||
if (s.is2D() && s.isArrayed() && s.isShadow() &&
|
||||
((*argp)[1]->getAsTyped()->getType().getBasicType() == EbtFloat) &&
|
||||
((*argp)[1]->getAsTyped()->getType().getVectorSize() == 4) &&
|
||||
(fnCandidate.getParamCount() == 4)) {
|
||||
featureString = fnCandidate.getName() + " for sampler2DArrayShadow";
|
||||
feature = featureString.c_str();
|
||||
profileRequires(loc, EEsProfile, 300, nullptr, feature);
|
||||
profileRequires(loc, ~EEsProfile, 130, nullptr, feature);
|
||||
requireExtensions(loc, 1, &E_GL_EXT_texture_shadow_lod, feature);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
break;
|
||||
|
@ -2513,11 +2572,18 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
|
|||
}
|
||||
|
||||
const TIntermTyped* base = TIntermediate::findLValueBase(arg0, true , true);
|
||||
const TType* refType = (base->getType().isReference()) ? base->getType().getReferentType() : nullptr;
|
||||
const TQualifier& qualifier = (refType != nullptr) ? refType->getQualifier() : base->getType().getQualifier();
|
||||
if (qualifier.storage != EvqShared && qualifier.storage != EvqBuffer && qualifier.storage != EvqtaskPayloadSharedEXT)
|
||||
error(loc,"Atomic memory function can only be used for shader storage block member or shared variable.",
|
||||
fnCandidate.getName().c_str(), "");
|
||||
const char* errMsg = "Only l-values corresponding to shader block storage or shared variables can be used with "
|
||||
"atomic memory functions.";
|
||||
if (base) {
|
||||
const TType* refType = (base->getType().isReference()) ? base->getType().getReferentType() : nullptr;
|
||||
const TQualifier& qualifier =
|
||||
(refType != nullptr) ? refType->getQualifier() : base->getType().getQualifier();
|
||||
if (qualifier.storage != EvqShared && qualifier.storage != EvqBuffer &&
|
||||
qualifier.storage != EvqtaskPayloadSharedEXT)
|
||||
error(loc, errMsg, fnCandidate.getName().c_str(), "");
|
||||
} else {
|
||||
error(loc, errMsg, fnCandidate.getName().c_str(), "");
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
@ -2685,7 +2751,6 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
|
|||
}
|
||||
}
|
||||
|
||||
extern bool PureOperatorBuiltins;
|
||||
|
||||
// Deprecated! Use PureOperatorBuiltins == true instead, in which case this
|
||||
// functionality is handled in builtInOpCheck() instead of here.
|
||||
|
@ -6324,9 +6389,6 @@ void TParseContext::layoutMemberLocationArrayCheck(const TSourceLoc& loc, bool m
|
|||
// Do layout error checking with respect to a type.
|
||||
void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
|
||||
{
|
||||
if (extensionTurnedOn(E_GL_EXT_spirv_intrinsics))
|
||||
return; // Skip any check if GL_EXT_spirv_intrinsics is turned on
|
||||
|
||||
const TQualifier& qualifier = type.getQualifier();
|
||||
|
||||
// first, intra-layout qualifier-only error checking
|
||||
|
@ -6380,6 +6442,7 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
|
|||
case EvqCallableData:
|
||||
case EvqCallableDataIn:
|
||||
case EvqHitObjectAttrNV:
|
||||
case EvqSpirvStorageClass:
|
||||
break;
|
||||
case EvqTileImageEXT:
|
||||
break;
|
||||
|
@ -6436,7 +6499,7 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
|
|||
// an array of size N, all elements of the array from binding through binding + N - 1 must be within this
|
||||
// range."
|
||||
//
|
||||
if (! type.isOpaque() && type.getBasicType() != EbtBlock)
|
||||
if (!type.isOpaque() && type.getBasicType() != EbtBlock && type.getBasicType() != EbtSpirvType)
|
||||
error(loc, "requires block, or sampler/image, or atomic-counter type", "binding", "");
|
||||
if (type.getBasicType() == EbtSampler) {
|
||||
int lastBinding = qualifier.layoutBinding;
|
||||
|
|
|
@ -196,6 +196,7 @@ public:
|
|||
struct TPragma contextPragma;
|
||||
int beginInvocationInterlockCount;
|
||||
int endInvocationInterlockCount;
|
||||
bool compileOnly = false;
|
||||
|
||||
protected:
|
||||
TParseContextBase(TParseContextBase&);
|
||||
|
|
|
@ -131,16 +131,6 @@ TPoolAllocator::~TPoolAllocator()
|
|||
}
|
||||
}
|
||||
|
||||
const unsigned char TAllocation::guardBlockBeginVal = 0xfb;
|
||||
const unsigned char TAllocation::guardBlockEndVal = 0xfe;
|
||||
const unsigned char TAllocation::userDataFill = 0xcd;
|
||||
|
||||
# ifdef GUARD_BLOCKS
|
||||
const size_t TAllocation::guardBlockSize = 16;
|
||||
# else
|
||||
const size_t TAllocation::guardBlockSize = 0;
|
||||
# endif
|
||||
|
||||
//
|
||||
// Check a single guard block for damage
|
||||
//
|
||||
|
|
|
@ -1073,12 +1073,18 @@ int TScanContext::tokenizeIdentifier()
|
|||
parseContext.extensionTurnedOn(E_GL_NV_ray_tracing))
|
||||
return keyword;
|
||||
return identifierOrType();
|
||||
case ACCSTRUCTEXT:
|
||||
if (parseContext.symbolTable.atBuiltInLevel() ||
|
||||
parseContext.extensionTurnedOn(E_GL_EXT_ray_tracing) ||
|
||||
parseContext.extensionTurnedOn(E_GL_EXT_ray_query) ||
|
||||
parseContext.extensionTurnedOn(E_GL_NV_displacement_micromap))
|
||||
return keyword;
|
||||
return identifierOrType();
|
||||
case PAYLOADEXT:
|
||||
case PAYLOADINEXT:
|
||||
case HITATTREXT:
|
||||
case CALLDATAEXT:
|
||||
case CALLDATAINEXT:
|
||||
case ACCSTRUCTEXT:
|
||||
if (parseContext.symbolTable.atBuiltInLevel() ||
|
||||
parseContext.extensionTurnedOn(E_GL_EXT_ray_tracing) ||
|
||||
parseContext.extensionTurnedOn(E_GL_EXT_ray_query))
|
||||
|
|
|
@ -796,7 +796,8 @@ bool ProcessDeferred(
|
|||
bool requireNonempty,
|
||||
TShader::Includer& includer,
|
||||
const std::string sourceEntryPointName = "",
|
||||
const TEnvironment* environment = nullptr) // optional way of fully setting all versions, overriding the above
|
||||
const TEnvironment* environment = nullptr, // optional way of fully setting all versions, overriding the above
|
||||
bool compileOnly = false)
|
||||
{
|
||||
// This must be undone (.pop()) by the caller, after it finishes consuming the created tree.
|
||||
GetThreadPoolAllocator().push();
|
||||
|
@ -942,6 +943,7 @@ bool ProcessDeferred(
|
|||
std::unique_ptr<TParseContextBase> parseContext(CreateParseContext(*symbolTable, intermediate, version, profile, source,
|
||||
stage, compiler->infoSink,
|
||||
spvVersion, forwardCompatible, messages, false, sourceEntryPointName));
|
||||
parseContext->compileOnly = compileOnly;
|
||||
TPpContext ppContext(*parseContext, names[numPre] ? names[numPre] : "", includer);
|
||||
|
||||
// only GLSL (bison triggered, really) needs an externally set scan context
|
||||
|
@ -1066,8 +1068,8 @@ struct DoPreprocessing {
|
|||
EShOptimizationLevel, EShMessages)
|
||||
{
|
||||
// This is a list of tokens that do not require a space before or after.
|
||||
static const std::string unNeededSpaceTokens = ";()[]";
|
||||
static const std::string noSpaceBeforeTokens = ",";
|
||||
static const std::string noNeededSpaceBeforeTokens = ";)[].,";
|
||||
static const std::string noNeededSpaceAfterTokens = ".([";
|
||||
glslang::TPpToken ppToken;
|
||||
|
||||
parseContext.setScanner(&input);
|
||||
|
@ -1140,6 +1142,7 @@ struct DoPreprocessing {
|
|||
});
|
||||
|
||||
int lastToken = EndOfInput; // lastToken records the last token processed.
|
||||
std::string lastTokenName;
|
||||
do {
|
||||
int token = ppContext.tokenize(ppToken);
|
||||
if (token == EndOfInput)
|
||||
|
@ -1158,12 +1161,23 @@ struct DoPreprocessing {
|
|||
// Output a space in between tokens, but not at the start of a line,
|
||||
// and also not around special tokens. This helps with readability
|
||||
// and consistency.
|
||||
if (!isNewString && !isNewLine && lastToken != EndOfInput &&
|
||||
(unNeededSpaceTokens.find((char)token) == std::string::npos) &&
|
||||
(unNeededSpaceTokens.find((char)lastToken) == std::string::npos) &&
|
||||
(noSpaceBeforeTokens.find((char)token) == std::string::npos)) {
|
||||
outputBuffer += ' ';
|
||||
if (!isNewString && !isNewLine && lastToken != EndOfInput) {
|
||||
// left parenthesis need a leading space, except it is in a function-call-like context.
|
||||
// examples: `for (xxx)`, `a * (b + c)`, `vec(2.0)`, `foo(x, y, z)`
|
||||
if (token == '(') {
|
||||
if (lastToken != PpAtomIdentifier ||
|
||||
lastTokenName == "if" ||
|
||||
lastTokenName == "for" ||
|
||||
lastTokenName == "while" ||
|
||||
lastTokenName == "switch")
|
||||
outputBuffer += ' ';
|
||||
} else if ((noNeededSpaceBeforeTokens.find((char)token) == std::string::npos) &&
|
||||
(noNeededSpaceAfterTokens.find((char)lastToken) == std::string::npos)) {
|
||||
outputBuffer += ' ';
|
||||
}
|
||||
}
|
||||
if (token == PpAtomIdentifier)
|
||||
lastTokenName = ppToken.name;
|
||||
lastToken = token;
|
||||
if (token == PpAtomConstString)
|
||||
outputBuffer += "\"";
|
||||
|
@ -1279,14 +1293,15 @@ bool CompileDeferred(
|
|||
TIntermediate& intermediate,// returned tree, etc.
|
||||
TShader::Includer& includer,
|
||||
const std::string sourceEntryPointName = "",
|
||||
TEnvironment* environment = nullptr)
|
||||
TEnvironment* environment = nullptr,
|
||||
bool compileOnly = false)
|
||||
{
|
||||
DoFullParse parser;
|
||||
return ProcessDeferred(compiler, shaderStrings, numStrings, inputLengths, stringNames,
|
||||
preamble, optLevel, resources, defaultVersion,
|
||||
defaultProfile, forceDefaultVersionAndProfile, overrideVersion,
|
||||
forwardCompatible, messages, intermediate, parser,
|
||||
true, includer, sourceEntryPointName, environment);
|
||||
true, includer, sourceEntryPointName, environment, compileOnly);
|
||||
}
|
||||
|
||||
} // end anonymous namespace for local functions
|
||||
|
@ -1867,7 +1882,7 @@ bool TShader::parse(const TBuiltInResource* builtInResources, int defaultVersion
|
|||
preamble, EShOptNone, builtInResources, defaultVersion,
|
||||
defaultProfile, forceDefaultVersionAndProfile, overrideVersion,
|
||||
forwardCompatible, messages, *intermediate, includer, sourceEntryPointName,
|
||||
&environment);
|
||||
&environment, compileOnly);
|
||||
}
|
||||
|
||||
// Fill in a string with the result of preprocessing ShaderStrings
|
||||
|
|
|
@ -45,11 +45,11 @@ namespace glslang {
|
|||
|
||||
bool TSpirvTypeParameter::operator==(const TSpirvTypeParameter& rhs) const
|
||||
{
|
||||
if (constant != nullptr)
|
||||
return constant->getConstArray() == rhs.constant->getConstArray();
|
||||
if (getAsConstant() != nullptr)
|
||||
return getAsConstant()->getConstArray() == rhs.getAsConstant()->getConstArray();
|
||||
|
||||
assert(type != nullptr);
|
||||
return *type == *rhs.type;
|
||||
assert(getAsType() != nullptr);
|
||||
return *getAsType() == *rhs.getAsType();
|
||||
}
|
||||
|
||||
//
|
||||
|
|
|
@ -318,6 +318,16 @@ void TSymbolTableLevel::setFunctionExtensions(const char* name, int num, const c
|
|||
}
|
||||
}
|
||||
|
||||
// Make a single function require an extension(s). i.e., this will only set the extensions for the symbol that matches 'name' exactly.
|
||||
// This is different from setFunctionExtensions, which uses std::map::lower_bound to effectively set all symbols that start with 'name'.
|
||||
// Should only be used for a version/profile that actually needs the extension(s).
|
||||
void TSymbolTableLevel::setSingleFunctionExtensions(const char* name, int num, const char* const extensions[])
|
||||
{
|
||||
if (auto candidate = level.find(name); candidate != level.end()) {
|
||||
candidate->second->setExtensions(num, extensions);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Make all symbols in this table level read only.
|
||||
//
|
||||
|
|
|
@ -246,7 +246,8 @@ public:
|
|||
TSymbol(name),
|
||||
mangledName(*name + '('),
|
||||
op(tOp),
|
||||
defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), defaultParamCount(0)
|
||||
defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), defaultParamCount(0),
|
||||
linkType(ELinkNone)
|
||||
{
|
||||
returnType.shallowCopy(retType);
|
||||
declaredBuiltIn = retType.getQualifier().builtIn;
|
||||
|
@ -326,6 +327,9 @@ public:
|
|||
|
||||
virtual void dump(TInfoSink& infoSink, bool complete = false) const override;
|
||||
|
||||
void setExport() { linkType = ELinkExport; }
|
||||
TLinkType getLinkType() const { return linkType; }
|
||||
|
||||
protected:
|
||||
explicit TFunction(const TFunction&);
|
||||
TFunction& operator=(const TFunction&);
|
||||
|
@ -347,6 +351,7 @@ protected:
|
|||
int defaultParamCount;
|
||||
|
||||
TSpirvInstruction spirvInst; // SPIR-V instruction qualifiers
|
||||
TLinkType linkType;
|
||||
};
|
||||
|
||||
//
|
||||
|
@ -571,6 +576,7 @@ public:
|
|||
|
||||
void relateToOperator(const char* name, TOperator op);
|
||||
void setFunctionExtensions(const char* name, int num, const char* const extensions[]);
|
||||
void setSingleFunctionExtensions(const char* name, int num, const char* const extensions[]);
|
||||
void dump(TInfoSink& infoSink, bool complete = false) const;
|
||||
TSymbolTableLevel* clone() const;
|
||||
void readOnly();
|
||||
|
@ -872,6 +878,12 @@ public:
|
|||
table[level]->setFunctionExtensions(name, num, extensions);
|
||||
}
|
||||
|
||||
void setSingleFunctionExtensions(const char* name, int num, const char* const extensions[])
|
||||
{
|
||||
for (unsigned int level = 0; level < table.size(); ++level)
|
||||
table[level]->setSingleFunctionExtensions(name, num, extensions);
|
||||
}
|
||||
|
||||
void setVariableExtensions(const char* name, int numExts, const char* const extensions[])
|
||||
{
|
||||
TSymbol* symbol = find(TString(name));
|
||||
|
|
|
@ -297,16 +297,18 @@ void TParseVersions::initializeExtensionBehavior()
|
|||
extensionBehavior[E_GL_NV_compute_shader_derivatives] = EBhDisable;
|
||||
extensionBehavior[E_GL_NV_shader_texture_footprint] = EBhDisable;
|
||||
extensionBehavior[E_GL_NV_mesh_shader] = EBhDisable;
|
||||
|
||||
extensionBehavior[E_GL_NV_cooperative_matrix] = EBhDisable;
|
||||
extensionBehavior[E_GL_NV_shader_sm_builtins] = EBhDisable;
|
||||
extensionBehavior[E_GL_NV_integer_cooperative_matrix] = EBhDisable;
|
||||
|
||||
extensionBehavior[E_GL_NV_shader_invocation_reorder] = EBhDisable;
|
||||
extensionBehavior[E_GL_NV_displacement_micromap] = EBhDisable;
|
||||
|
||||
// ARM
|
||||
extensionBehavior[E_GL_ARM_shader_core_builtins] = EBhDisable;
|
||||
|
||||
// QCOM
|
||||
extensionBehavior[E_GL_QCOM_image_processing] = EBhDisable;
|
||||
|
||||
// AEP
|
||||
extensionBehavior[E_GL_ANDROID_extension_pack_es31a] = EBhDisable;
|
||||
extensionBehavior[E_GL_KHR_blend_equation_advanced] = EBhDisable;
|
||||
|
@ -356,6 +358,7 @@ void TParseVersions::initializeExtensionBehavior()
|
|||
extensionBehavior[E_GL_EXT_opacity_micromap] = 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;
|
||||
|
||||
// OVR extensions
|
||||
extensionBehavior[E_GL_OVR_multiview] = EBhDisable;
|
||||
|
@ -431,6 +434,8 @@ void TParseVersions::getPreamble(std::string& preamble)
|
|||
"#define GL_OES_texture_buffer 1\n"
|
||||
"#define GL_OES_texture_cube_map_array 1\n"
|
||||
"#define GL_EXT_shader_non_constant_global_initializers 1\n"
|
||||
|
||||
"#define GL_QCOM_image_processing 1\n"
|
||||
;
|
||||
|
||||
if (version >= 300) {
|
||||
|
@ -555,6 +560,8 @@ void TParseVersions::getPreamble(std::string& preamble)
|
|||
"#define GL_NV_integer_cooperative_matrix 1\n"
|
||||
"#define GL_NV_shader_invocation_reorder 1\n"
|
||||
|
||||
"#define GL_QCOM_image_processing 1\n"
|
||||
|
||||
"#define GL_EXT_shader_explicit_arithmetic_types 1\n"
|
||||
"#define GL_EXT_shader_explicit_arithmetic_types_int8 1\n"
|
||||
"#define GL_EXT_shader_explicit_arithmetic_types_int16 1\n"
|
||||
|
|
|
@ -266,7 +266,12 @@ const char* const E_GL_NV_fragment_shader_barycentric = "GL_NV_fragmen
|
|||
const char* const E_GL_NV_compute_shader_derivatives = "GL_NV_compute_shader_derivatives";
|
||||
const char* const E_GL_NV_shader_texture_footprint = "GL_NV_shader_texture_footprint";
|
||||
const char* const E_GL_NV_mesh_shader = "GL_NV_mesh_shader";
|
||||
const char* const E_GL_NV_cooperative_matrix = "GL_NV_cooperative_matrix";
|
||||
const char* const E_GL_NV_shader_sm_builtins = "GL_NV_shader_sm_builtins";
|
||||
const char* const E_GL_NV_integer_cooperative_matrix = "GL_NV_integer_cooperative_matrix";
|
||||
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";
|
||||
|
||||
// ARM
|
||||
const char* const E_GL_ARM_shader_core_builtins = "GL_ARM_shader_core_builtins";
|
||||
|
@ -276,10 +281,8 @@ const char* const E_GL_ARM_shader_core_builtins = "GL_ARM_shader
|
|||
const char* const viewportEXTs[] = { E_GL_ARB_shader_viewport_layer_array, E_GL_NV_viewport_array2 };
|
||||
const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]);
|
||||
|
||||
const char* const E_GL_NV_cooperative_matrix = "GL_NV_cooperative_matrix";
|
||||
const char* const E_GL_NV_shader_sm_builtins = "GL_NV_shader_sm_builtins";
|
||||
const char* const E_GL_NV_integer_cooperative_matrix = "GL_NV_integer_cooperative_matrix";
|
||||
const char* const E_GL_NV_shader_invocation_reorder = "GL_NV_shader_invocation_reorder";
|
||||
|
||||
const char* const E_GL_QCOM_image_processing = "GL_QCOM_image_processing";
|
||||
|
||||
// AEP
|
||||
const char* const E_GL_ANDROID_extension_pack_es31a = "GL_ANDROID_extension_pack_es31a";
|
||||
|
@ -331,6 +334,8 @@ const char* const E_GL_EXT_shader_atomic_float2 = "GL_EXT_shader_atomic_float2";
|
|||
|
||||
const char* const E_GL_EXT_shader_tile_image = "GL_EXT_shader_tile_image";
|
||||
|
||||
const char* const E_GL_EXT_texture_shadow_lod = "GL_EXT_texture_shadow_lod";
|
||||
|
||||
// Arrays of extensions for the above AEP duplications
|
||||
|
||||
const char* const AEP_geometry_shader[] = { E_GL_EXT_geometry_shader, E_GL_OES_geometry_shader };
|
||||
|
|
|
@ -123,6 +123,8 @@ TAttributeType TParseContext::attributeFromName(const TString& name) const
|
|||
return EatPartialCount;
|
||||
else if (name == "subgroup_uniform_control_flow")
|
||||
return EatSubgroupUniformControlFlow;
|
||||
else if (name == "export")
|
||||
return EatExport;
|
||||
else
|
||||
return EatNone;
|
||||
}
|
||||
|
@ -355,6 +357,7 @@ void TParseContext::handleFunctionAttributes(const TSourceLoc& loc, const TAttri
|
|||
|
||||
switch (it->name) {
|
||||
case EatSubgroupUniformControlFlow:
|
||||
requireExtensions(loc, 1, &E_GL_EXT_subgroup_uniform_control_flow, "attribute");
|
||||
intermediate.setSubgroupUniformControlFlow();
|
||||
break;
|
||||
default:
|
||||
|
|
|
@ -120,6 +120,7 @@ namespace glslang {
|
|||
EatNonWritable,
|
||||
EatNonReadable,
|
||||
EatSubgroupUniformControlFlow,
|
||||
EatExport,
|
||||
};
|
||||
|
||||
class TIntermAggregate;
|
||||
|
|
|
@ -941,24 +941,25 @@ identifier_list
|
|||
function_prototype
|
||||
: function_declarator RIGHT_PAREN {
|
||||
$$.function = $1;
|
||||
if (parseContext.compileOnly) $$.function->setExport();
|
||||
$$.loc = $2.loc;
|
||||
}
|
||||
| function_declarator RIGHT_PAREN attribute {
|
||||
$$.function = $1;
|
||||
if (parseContext.compileOnly) $$.function->setExport();
|
||||
$$.loc = $2.loc;
|
||||
parseContext.requireExtensions($2.loc, 1, &E_GL_EXT_subgroup_uniform_control_flow, "attribute");
|
||||
parseContext.handleFunctionAttributes($2.loc, *$3);
|
||||
}
|
||||
| attribute function_declarator RIGHT_PAREN {
|
||||
$$.function = $2;
|
||||
if (parseContext.compileOnly) $$.function->setExport();
|
||||
$$.loc = $3.loc;
|
||||
parseContext.requireExtensions($3.loc, 1, &E_GL_EXT_subgroup_uniform_control_flow, "attribute");
|
||||
parseContext.handleFunctionAttributes($3.loc, *$1);
|
||||
}
|
||||
| attribute function_declarator RIGHT_PAREN attribute {
|
||||
$$.function = $2;
|
||||
if (parseContext.compileOnly) $$.function->setExport();
|
||||
$$.loc = $3.loc;
|
||||
parseContext.requireExtensions($3.loc, 1, &E_GL_EXT_subgroup_uniform_control_flow, "attribute");
|
||||
parseContext.handleFunctionAttributes($3.loc, *$1);
|
||||
parseContext.handleFunctionAttributes($3.loc, *$4);
|
||||
}
|
||||
|
@ -4088,6 +4089,7 @@ function_definition
|
|||
parseContext.error($1.loc, "function does not return a value:", "", $1.function->getName().c_str());
|
||||
parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
|
||||
$$ = parseContext.intermediate.growAggregate($1.intermNode, $3);
|
||||
$$->getAsAggregate()->setLinkType($1.function->getLinkType());
|
||||
parseContext.intermediate.setAggregateOperator($$, EOpFunction, $1.function->getType(), $1.loc);
|
||||
$$->getAsAggregate()->setName($1.function->getMangledName().c_str());
|
||||
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -524,7 +524,7 @@ extern int yydebug;
|
|||
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
|
||||
union YYSTYPE
|
||||
{
|
||||
#line 97 "MachineIndependent/glslang.y"
|
||||
#line 72 "MachineIndependent/glslang.y"
|
||||
|
||||
struct {
|
||||
glslang::TSourceLoc loc;
|
||||
|
|
|
@ -1141,6 +1141,8 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
|
|||
case EOpHitObjectGetShaderBindingTableRecordIndexNV: out.debug << "HitObjectGetShaderBindingTableRecordIndexNV"; break;
|
||||
case EOpHitObjectGetShaderRecordBufferHandleNV: out.debug << "HitObjectReadShaderRecordBufferHandleNV"; break;
|
||||
case EOpReorderThreadNV: out.debug << "ReorderThreadNV"; break;
|
||||
case EOpFetchMicroTriangleVertexPositionNV: out.debug << "MicroTriangleVertexPositionNV"; break;
|
||||
case EOpFetchMicroTriangleVertexBarycentricNV: out.debug << "MicroTriangleVertexBarycentricNV"; break;
|
||||
|
||||
case EOpSpirvInst: out.debug << "spirv_instruction"; break;
|
||||
case EOpStencilAttachmentReadEXT: out.debug << "stencilAttachmentReadEXT"; break;
|
||||
|
|
|
@ -378,8 +378,6 @@ namespace {
|
|||
int op_cmpl(int a) { return ~a; }
|
||||
int op_not(int a) { return !a; }
|
||||
|
||||
};
|
||||
|
||||
struct TBinop {
|
||||
int token, precedence, (*op)(int, int);
|
||||
} binop[] = {
|
||||
|
@ -412,6 +410,8 @@ struct TUnop {
|
|||
{ '!', op_not },
|
||||
};
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
#define NUM_ELEMENTS(A) (sizeof(A) / sizeof(A[0]))
|
||||
|
||||
int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, bool& err, TPpToken* ppToken)
|
||||
|
|
|
@ -573,6 +573,9 @@ public:
|
|||
void setEnvInputVulkanRulesRelaxed() { environment.input.vulkanRulesRelaxed = true; }
|
||||
bool getEnvInputVulkanRulesRelaxed() const { return environment.input.vulkanRulesRelaxed; }
|
||||
|
||||
void setCompileOnly() { compileOnly = true; }
|
||||
bool getCompileOnly() const { return compileOnly; }
|
||||
|
||||
// Interface to #include handlers.
|
||||
//
|
||||
// To support #include, a client of Glslang does the following:
|
||||
|
@ -722,6 +725,9 @@ protected:
|
|||
|
||||
TEnvironment environment;
|
||||
|
||||
// Indicates this shader is meant to be used without linking
|
||||
bool compileOnly = false;
|
||||
|
||||
friend class TProgram;
|
||||
|
||||
private:
|
||||
|
|
4
thirdparty/glslang/glslang/build_info.h
vendored
4
thirdparty/glslang/glslang/build_info.h
vendored
|
@ -34,8 +34,8 @@
|
|||
#ifndef GLSLANG_BUILD_INFO
|
||||
#define GLSLANG_BUILD_INFO
|
||||
|
||||
#define GLSLANG_VERSION_MAJOR 12
|
||||
#define GLSLANG_VERSION_MINOR 3
|
||||
#define GLSLANG_VERSION_MAJOR 13
|
||||
#define GLSLANG_VERSION_MINOR 1
|
||||
#define GLSLANG_VERSION_PATCH 1
|
||||
#define GLSLANG_VERSION_FLAVOR ""
|
||||
|
||||
|
|
136
thirdparty/spirv-reflect/spirv_reflect.c
vendored
136
thirdparty/spirv-reflect/spirv_reflect.c
vendored
|
@ -129,6 +129,9 @@ typedef struct SpvReflectPrvDecorations {
|
|||
bool is_flat;
|
||||
bool is_non_writable;
|
||||
bool is_non_readable;
|
||||
bool is_patch;
|
||||
bool is_per_vertex;
|
||||
bool is_per_task;
|
||||
SpvReflectPrvNumberDecoration set;
|
||||
SpvReflectPrvNumberDecoration binding;
|
||||
SpvReflectPrvNumberDecoration input_attachment_index;
|
||||
|
@ -515,6 +518,15 @@ static SpvReflectDecorationFlags ApplyDecorations(const SpvReflectPrvDecorations
|
|||
if (p_decoration_fields->is_non_readable) {
|
||||
decorations |= SPV_REFLECT_DECORATION_NON_READABLE;
|
||||
}
|
||||
if (p_decoration_fields->is_patch) {
|
||||
decorations |= SPV_REFLECT_DECORATION_PATCH;
|
||||
}
|
||||
if (p_decoration_fields->is_per_vertex) {
|
||||
decorations |= SPV_REFLECT_DECORATION_PER_VERTEX;
|
||||
}
|
||||
if (p_decoration_fields->is_per_task) {
|
||||
decorations |= SPV_REFLECT_DECORATION_PER_TASK;
|
||||
}
|
||||
return decorations;
|
||||
}
|
||||
|
||||
|
@ -528,6 +540,10 @@ static void ApplyArrayTraits(const SpvReflectTypeDescription* p_type, SpvReflect
|
|||
memcpy(p_array_traits, &p_type->traits.array, sizeof(p_type->traits.array));
|
||||
}
|
||||
|
||||
static bool IsSpecConstant(const SpvReflectPrvNode* p_node) {
|
||||
return (p_node->op == SpvOpSpecConstant || p_node->op == SpvOpSpecConstantOp);
|
||||
}
|
||||
|
||||
static SpvReflectPrvNode* FindNode(
|
||||
SpvReflectPrvParser* p_parser,
|
||||
uint32_t result_id)
|
||||
|
@ -599,6 +615,9 @@ static uint32_t FindBaseId(SpvReflectPrvParser* p_parser,
|
|||
}
|
||||
base_id = base_ac->base_id;
|
||||
base_node = FindNode(p_parser, base_id);
|
||||
if (IsNull(base_node)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return base_id;
|
||||
}
|
||||
|
@ -618,12 +637,15 @@ static SpvReflectBlockVariable* GetRefBlkVar(SpvReflectPrvParser* p_parser,
|
|||
|
||||
bool IsPointerToPointer(SpvReflectPrvParser* p_parser, uint32_t type_id) {
|
||||
SpvReflectPrvNode* ptr_node = FindNode(p_parser, type_id);
|
||||
if (ptr_node->op != SpvOpTypePointer) {
|
||||
if (IsNull(ptr_node) || (ptr_node->op != SpvOpTypePointer)) {
|
||||
return false;
|
||||
}
|
||||
uint32_t pte_id = 0;
|
||||
UNCHECKED_READU32(p_parser, ptr_node->word_offset + 3, pte_id);
|
||||
SpvReflectPrvNode* pte_node = FindNode(p_parser, pte_id);
|
||||
if (IsNull(pte_node)) {
|
||||
return false;
|
||||
}
|
||||
return pte_node->op == SpvOpTypePointer;
|
||||
}
|
||||
|
||||
|
@ -1493,6 +1515,9 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser)
|
|||
case SpvDecorationFlat:
|
||||
case SpvDecorationNonWritable:
|
||||
case SpvDecorationNonReadable:
|
||||
case SpvDecorationPatch:
|
||||
case SpvDecorationPerVertexKHR:
|
||||
case SpvDecorationPerTaskNV:
|
||||
case SpvDecorationLocation:
|
||||
case SpvDecorationComponent:
|
||||
case SpvDecorationBinding:
|
||||
|
@ -1597,6 +1622,18 @@ static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser)
|
|||
}
|
||||
break;
|
||||
|
||||
case SpvDecorationPatch: {
|
||||
p_target_decorations->is_patch = true;
|
||||
} break;
|
||||
|
||||
case SpvDecorationPerVertexKHR: {
|
||||
p_target_decorations->is_per_vertex = true;
|
||||
} break;
|
||||
|
||||
case SpvDecorationPerTaskNV: {
|
||||
p_target_decorations->is_per_task = true;
|
||||
} break;
|
||||
|
||||
case SpvDecorationLocation: {
|
||||
uint32_t word_offset = p_node->word_offset + member_offset + 3;
|
||||
CHECKED_READU32(p_parser, word_offset, p_target_decorations->location.value);
|
||||
|
@ -1846,8 +1883,7 @@ static SpvReflectResult ParseType(
|
|||
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 (p_length_node->op == SpvOpSpecConstant ||
|
||||
p_length_node->op == SpvOpSpecConstantOp) {
|
||||
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;
|
||||
|
@ -3131,7 +3167,7 @@ static SpvReflectResult ParseInterfaceVariables(
|
|||
}
|
||||
|
||||
SpvReflectTypeDescription* p_type = FindType(p_module, p_node->type_id);
|
||||
if (IsNull(p_node)) {
|
||||
if (IsNull(p_node) || IsNull(p_type)) {
|
||||
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
|
||||
}
|
||||
// If the type is a pointer, resolve it
|
||||
|
@ -3533,7 +3569,8 @@ static SpvReflectResult ParseExecutionModes(
|
|||
if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && IsNotNull(p_parser->nodes)) {
|
||||
for (size_t node_idx = 0; node_idx < p_parser->node_count; ++node_idx) {
|
||||
SpvReflectPrvNode* p_node = &(p_parser->nodes[node_idx]);
|
||||
if (p_node->op != SpvOpExecutionMode) {
|
||||
if (p_node->op != SpvOpExecutionMode &&
|
||||
p_node->op != SpvOpExecutionModeId) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
@ -3560,41 +3597,55 @@ static SpvReflectResult ParseExecutionModes(
|
|||
|
||||
// Parse execution mode
|
||||
switch (execution_mode) {
|
||||
default: {
|
||||
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_EXECUTION_MODE;
|
||||
}
|
||||
break;
|
||||
|
||||
case SpvExecutionModeInvocations: {
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 3, p_entry_point->invocations);
|
||||
}
|
||||
break;
|
||||
|
||||
case SpvExecutionModeSpacingEqual:
|
||||
case SpvExecutionModeSpacingFractionalEven:
|
||||
case SpvExecutionModeSpacingFractionalOdd:
|
||||
case SpvExecutionModeVertexOrderCw:
|
||||
case SpvExecutionModeVertexOrderCcw:
|
||||
case SpvExecutionModePixelCenterInteger:
|
||||
case SpvExecutionModeOriginUpperLeft:
|
||||
case SpvExecutionModeOriginLowerLeft:
|
||||
case SpvExecutionModeEarlyFragmentTests:
|
||||
case SpvExecutionModePointMode:
|
||||
case SpvExecutionModeXfb:
|
||||
case SpvExecutionModeDepthReplacing:
|
||||
case SpvExecutionModeDepthGreater:
|
||||
case SpvExecutionModeDepthLess:
|
||||
case SpvExecutionModeDepthUnchanged:
|
||||
break;
|
||||
|
||||
case SpvExecutionModeLocalSize: {
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 3, p_entry_point->local_size.x);
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 4, p_entry_point->local_size.y);
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 5, p_entry_point->local_size.z);
|
||||
}
|
||||
break;
|
||||
case SpvExecutionModeLocalSizeId: {
|
||||
uint32_t local_size_x_id = 0;
|
||||
uint32_t local_size_y_id = 0;
|
||||
uint32_t local_size_z_id = 0;
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 3, local_size_x_id);
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 4, local_size_y_id);
|
||||
CHECKED_READU32(p_parser, p_node->word_offset + 5, local_size_z_id);
|
||||
|
||||
SpvReflectPrvNode* x_node = FindNode(p_parser, local_size_x_id);
|
||||
SpvReflectPrvNode* y_node = FindNode(p_parser, local_size_y_id);
|
||||
SpvReflectPrvNode* z_node = FindNode(p_parser, local_size_z_id);
|
||||
if (IsNotNull(x_node) && IsNotNull(y_node) && IsNotNull(z_node)) {
|
||||
if (IsSpecConstant(x_node)) {
|
||||
p_entry_point->local_size.x =
|
||||
(uint32_t)SPV_REFLECT_EXECUTION_MODE_SPEC_CONSTANT;
|
||||
} else {
|
||||
CHECKED_READU32(p_parser, x_node->word_offset + 3,
|
||||
p_entry_point->local_size.x);
|
||||
}
|
||||
|
||||
if (IsSpecConstant(y_node)) {
|
||||
p_entry_point->local_size.y =
|
||||
(uint32_t)SPV_REFLECT_EXECUTION_MODE_SPEC_CONSTANT;
|
||||
} else {
|
||||
CHECKED_READU32(p_parser, y_node->word_offset + 3,
|
||||
p_entry_point->local_size.y);
|
||||
}
|
||||
|
||||
if (IsSpecConstant(z_node)) {
|
||||
p_entry_point->local_size.z =
|
||||
(uint32_t)SPV_REFLECT_EXECUTION_MODE_SPEC_CONSTANT;
|
||||
} else {
|
||||
CHECKED_READU32(p_parser, z_node->word_offset + 3,
|
||||
p_entry_point->local_size.z);
|
||||
}
|
||||
}
|
||||
} break;
|
||||
|
||||
case SpvExecutionModeLocalSizeHint:
|
||||
case SpvExecutionModeInputPoints:
|
||||
case SpvExecutionModeInputLines:
|
||||
case SpvExecutionModeInputLinesAdjacency:
|
||||
|
@ -3607,32 +3658,7 @@ static SpvReflectResult ParseExecutionModes(
|
|||
}
|
||||
break;
|
||||
|
||||
case SpvExecutionModeOutputPoints:
|
||||
case SpvExecutionModeOutputLineStrip:
|
||||
case SpvExecutionModeOutputTriangleStrip:
|
||||
case SpvExecutionModeVecTypeHint:
|
||||
case SpvExecutionModeContractionOff:
|
||||
case SpvExecutionModeInitializer:
|
||||
case SpvExecutionModeFinalizer:
|
||||
case SpvExecutionModeSubgroupSize:
|
||||
case SpvExecutionModeSubgroupsPerWorkgroup:
|
||||
case SpvExecutionModeSubgroupsPerWorkgroupId:
|
||||
case SpvExecutionModeLocalSizeId:
|
||||
case SpvExecutionModeLocalSizeHintId:
|
||||
case SpvExecutionModePostDepthCoverage:
|
||||
case SpvExecutionModeDenormPreserve:
|
||||
case SpvExecutionModeDenormFlushToZero:
|
||||
case SpvExecutionModeSignedZeroInfNanPreserve:
|
||||
case SpvExecutionModeRoundingModeRTE:
|
||||
case SpvExecutionModeRoundingModeRTZ:
|
||||
case SpvExecutionModeStencilRefReplacingEXT:
|
||||
case SpvExecutionModeOutputLinesNV:
|
||||
case SpvExecutionModeOutputPrimitivesNV:
|
||||
case SpvExecutionModeOutputTrianglesNV:
|
||||
case SpvExecutionModePixelInterlockOrderedEXT:
|
||||
case SpvExecutionModePixelInterlockUnorderedEXT:
|
||||
case SpvExecutionModeSampleInterlockOrderedEXT:
|
||||
case SpvExecutionModeSampleInterlockUnorderedEXT:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
p_entry_point->execution_mode_count++;
|
||||
|
@ -3777,7 +3803,7 @@ static SpvReflectResult ParsePushConstantBlocks(
|
|||
}
|
||||
|
||||
SpvReflectTypeDescription* p_type = FindType(p_module, p_node->type_id);
|
||||
if (IsNull(p_node)) {
|
||||
if (IsNull(p_node) || IsNull(p_type)) {
|
||||
return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
|
||||
}
|
||||
// If the type is a pointer, resolve it
|
||||
|
|
10
thirdparty/spirv-reflect/spirv_reflect.h
vendored
10
thirdparty/spirv-reflect/spirv_reflect.h
vendored
|
@ -134,6 +134,9 @@ NOTE: HLSL row_major and column_major decorations are reversed
|
|||
SPIRV-Reflect reads the data as is and does not make any
|
||||
attempt to correct it to match what's in the source.
|
||||
|
||||
The Patch, PerVertex, and PerTask are used for Interface
|
||||
variables that can have array
|
||||
|
||||
*/
|
||||
typedef enum SpvReflectDecorationFlagBits {
|
||||
SPV_REFLECT_DECORATION_NONE = 0x00000000,
|
||||
|
@ -147,6 +150,9 @@ typedef enum SpvReflectDecorationFlagBits {
|
|||
SPV_REFLECT_DECORATION_NON_WRITABLE = 0x00000080,
|
||||
SPV_REFLECT_DECORATION_RELAXED_PRECISION = 0x00000100,
|
||||
SPV_REFLECT_DECORATION_NON_READABLE = 0x00000200,
|
||||
SPV_REFLECT_DECORATION_PATCH = 0x00000400,
|
||||
SPV_REFLECT_DECORATION_PER_VERTEX = 0x00000800,
|
||||
SPV_REFLECT_DECORATION_PER_TASK = 0x00001000,
|
||||
} SpvReflectDecorationFlagBits;
|
||||
|
||||
typedef uint32_t SpvReflectDecorationFlags;
|
||||
|
@ -478,6 +484,10 @@ typedef struct SpvReflectDescriptorSet {
|
|||
SpvReflectDescriptorBinding** bindings;
|
||||
} SpvReflectDescriptorSet;
|
||||
|
||||
typedef enum SpvReflectExecutionModeValue {
|
||||
SPV_REFLECT_EXECUTION_MODE_SPEC_CONSTANT = 0xFFFFFFFF // specialization constant
|
||||
} SpvReflectExecutionModeValue;
|
||||
|
||||
/*! @struct SpvReflectEntryPoint
|
||||
|
||||
*/
|
||||
|
|
25
thirdparty/volk/volk.c
vendored
25
thirdparty/volk/volk.c
vendored
|
@ -6,7 +6,9 @@
|
|||
typedef const char* LPCSTR;
|
||||
typedef struct HINSTANCE__* HINSTANCE;
|
||||
typedef HINSTANCE HMODULE;
|
||||
#ifdef _WIN64
|
||||
#if defined(_MINWINDEF_)
|
||||
/* minwindef.h defines FARPROC, and attempting to redefine it may conflict with -Wstrict-prototypes */
|
||||
#elif defined(_WIN64)
|
||||
typedef __int64 (__stdcall* FARPROC)(void);
|
||||
#else
|
||||
typedef int (__stdcall* FARPROC)(void);
|
||||
|
@ -1017,6 +1019,13 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c
|
|||
#if defined(VK_NV_fragment_shading_rate_enums)
|
||||
vkCmdSetFragmentShadingRateEnumNV = (PFN_vkCmdSetFragmentShadingRateEnumNV)load(context, "vkCmdSetFragmentShadingRateEnumNV");
|
||||
#endif /* defined(VK_NV_fragment_shading_rate_enums) */
|
||||
#if defined(VK_NV_low_latency2)
|
||||
vkGetLatencyTimingsNV = (PFN_vkGetLatencyTimingsNV)load(context, "vkGetLatencyTimingsNV");
|
||||
vkLatencySleepNV = (PFN_vkLatencySleepNV)load(context, "vkLatencySleepNV");
|
||||
vkQueueNotifyOutOfBandNV = (PFN_vkQueueNotifyOutOfBandNV)load(context, "vkQueueNotifyOutOfBandNV");
|
||||
vkSetLatencyMarkerNV = (PFN_vkSetLatencyMarkerNV)load(context, "vkSetLatencyMarkerNV");
|
||||
vkSetLatencySleepModeNV = (PFN_vkSetLatencySleepModeNV)load(context, "vkSetLatencySleepModeNV");
|
||||
#endif /* defined(VK_NV_low_latency2) */
|
||||
#if defined(VK_NV_memory_decompression)
|
||||
vkCmdDecompressMemoryIndirectCountNV = (PFN_vkCmdDecompressMemoryIndirectCountNV)load(context, "vkCmdDecompressMemoryIndirectCountNV");
|
||||
vkCmdDecompressMemoryNV = (PFN_vkCmdDecompressMemoryNV)load(context, "vkCmdDecompressMemoryNV");
|
||||
|
@ -1818,6 +1827,13 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context,
|
|||
#if defined(VK_NV_fragment_shading_rate_enums)
|
||||
table->vkCmdSetFragmentShadingRateEnumNV = (PFN_vkCmdSetFragmentShadingRateEnumNV)load(context, "vkCmdSetFragmentShadingRateEnumNV");
|
||||
#endif /* defined(VK_NV_fragment_shading_rate_enums) */
|
||||
#if defined(VK_NV_low_latency2)
|
||||
table->vkGetLatencyTimingsNV = (PFN_vkGetLatencyTimingsNV)load(context, "vkGetLatencyTimingsNV");
|
||||
table->vkLatencySleepNV = (PFN_vkLatencySleepNV)load(context, "vkLatencySleepNV");
|
||||
table->vkQueueNotifyOutOfBandNV = (PFN_vkQueueNotifyOutOfBandNV)load(context, "vkQueueNotifyOutOfBandNV");
|
||||
table->vkSetLatencyMarkerNV = (PFN_vkSetLatencyMarkerNV)load(context, "vkSetLatencyMarkerNV");
|
||||
table->vkSetLatencySleepModeNV = (PFN_vkSetLatencySleepModeNV)load(context, "vkSetLatencySleepModeNV");
|
||||
#endif /* defined(VK_NV_low_latency2) */
|
||||
#if defined(VK_NV_memory_decompression)
|
||||
table->vkCmdDecompressMemoryIndirectCountNV = (PFN_vkCmdDecompressMemoryIndirectCountNV)load(context, "vkCmdDecompressMemoryIndirectCountNV");
|
||||
table->vkCmdDecompressMemoryNV = (PFN_vkCmdDecompressMemoryNV)load(context, "vkCmdDecompressMemoryNV");
|
||||
|
@ -2806,6 +2822,13 @@ PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV;
|
|||
#if defined(VK_NV_fragment_shading_rate_enums)
|
||||
PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV;
|
||||
#endif /* defined(VK_NV_fragment_shading_rate_enums) */
|
||||
#if defined(VK_NV_low_latency2)
|
||||
PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV;
|
||||
PFN_vkLatencySleepNV vkLatencySleepNV;
|
||||
PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV;
|
||||
PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV;
|
||||
PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV;
|
||||
#endif /* defined(VK_NV_low_latency2) */
|
||||
#if defined(VK_NV_memory_decompression)
|
||||
PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV;
|
||||
PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV;
|
||||
|
|
16
thirdparty/volk/volk.h
vendored
16
thirdparty/volk/volk.h
vendored
|
@ -15,7 +15,7 @@
|
|||
#endif
|
||||
|
||||
/* VOLK_GENERATE_VERSION_DEFINE */
|
||||
#define VOLK_HEADER_VERSION 261
|
||||
#define VOLK_HEADER_VERSION 268
|
||||
/* VOLK_GENERATE_VERSION_DEFINE */
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
|
@ -787,6 +787,13 @@ struct VolkDeviceTable
|
|||
#if defined(VK_NV_fragment_shading_rate_enums)
|
||||
PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV;
|
||||
#endif /* defined(VK_NV_fragment_shading_rate_enums) */
|
||||
#if defined(VK_NV_low_latency2)
|
||||
PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV;
|
||||
PFN_vkLatencySleepNV vkLatencySleepNV;
|
||||
PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV;
|
||||
PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV;
|
||||
PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV;
|
||||
#endif /* defined(VK_NV_low_latency2) */
|
||||
#if defined(VK_NV_memory_decompression)
|
||||
PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV;
|
||||
PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV;
|
||||
|
@ -1767,6 +1774,13 @@ extern PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV;
|
|||
#if defined(VK_NV_fragment_shading_rate_enums)
|
||||
extern PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV;
|
||||
#endif /* defined(VK_NV_fragment_shading_rate_enums) */
|
||||
#if defined(VK_NV_low_latency2)
|
||||
extern PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV;
|
||||
extern PFN_vkLatencySleepNV vkLatencySleepNV;
|
||||
extern PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV;
|
||||
extern PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV;
|
||||
extern PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV;
|
||||
#endif /* defined(VK_NV_low_latency2) */
|
||||
#if defined(VK_NV_memory_decompression)
|
||||
extern PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV;
|
||||
extern PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV;
|
||||
|
|
|
@ -29,6 +29,7 @@ extern "C" {
|
|||
#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64
|
||||
#define STD_VIDEO_H264_MAX_NUM_LIST_REF 32
|
||||
#define STD_VIDEO_H264_MAX_CHROMA_PLANES 2
|
||||
#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFF
|
||||
|
||||
typedef enum StdVideoH264ChromaFormatIdc {
|
||||
STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0,
|
||||
|
|
|
@ -23,9 +23,9 @@ extern "C" {
|
|||
#define vulkan_video_codec_h264std_encode 1
|
||||
#include "vulkan_video_codec_h264std.h"
|
||||
// Vulkan 0.9 provisional Vulkan video H.264 encode std specification version number
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_10 VK_MAKE_VIDEO_STD_VERSION(0, 9, 10)
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_11 VK_MAKE_VIDEO_STD_VERSION(0, 9, 11)
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_10
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_11
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode"
|
||||
typedef struct StdVideoEncodeH264WeightTableFlags {
|
||||
uint32_t luma_weight_l0_flag;
|
||||
|
@ -81,7 +81,7 @@ typedef struct StdVideoEncodeH264RefListModEntry {
|
|||
} StdVideoEncodeH264RefListModEntry;
|
||||
|
||||
typedef struct StdVideoEncodeH264RefPicMarkingEntry {
|
||||
StdVideoH264MemMgmtControlOp operation;
|
||||
StdVideoH264MemMgmtControlOp memory_management_control_operation;
|
||||
uint16_t difference_of_pic_nums_minus1;
|
||||
uint16_t long_term_pic_num;
|
||||
uint16_t long_term_frame_idx;
|
||||
|
@ -132,7 +132,8 @@ typedef struct StdVideoEncodeH264SliceHeader {
|
|||
StdVideoH264SliceType slice_type;
|
||||
int8_t slice_alpha_c0_offset_div2;
|
||||
int8_t slice_beta_offset_div2;
|
||||
uint16_t reserved1;
|
||||
int8_t slice_qp_delta;
|
||||
uint8_t reserved1;
|
||||
StdVideoH264CabacInitIdc cabac_init_idc;
|
||||
StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc;
|
||||
const StdVideoEncodeH264WeightTable* pWeightTable;
|
||||
|
|
|
@ -44,6 +44,7 @@ extern "C" {
|
|||
#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32
|
||||
#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16
|
||||
#define STD_VIDEO_H265_MAX_DELTA_POC 48
|
||||
#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFF
|
||||
|
||||
typedef enum StdVideoH265ChromaFormatIdc {
|
||||
STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0,
|
||||
|
|
|
@ -23,9 +23,9 @@ extern "C" {
|
|||
#define vulkan_video_codec_h265std_encode 1
|
||||
#include "vulkan_video_codec_h265std.h"
|
||||
// Vulkan 0.9 provisional Vulkan video H.265 encode std specification version number
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_11 VK_MAKE_VIDEO_STD_VERSION(0, 9, 11)
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_12 VK_MAKE_VIDEO_STD_VERSION(0, 9, 12)
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_11
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_12
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode"
|
||||
typedef struct StdVideoEncodeH265WeightTableFlags {
|
||||
uint16_t luma_weight_l0_flag;
|
||||
|
@ -77,7 +77,8 @@ typedef struct StdVideoEncodeH265SliceSegmentHeader {
|
|||
int8_t slice_act_y_qp_offset;
|
||||
int8_t slice_act_cb_qp_offset;
|
||||
int8_t slice_act_cr_qp_offset;
|
||||
uint8_t reserved1[3];
|
||||
int8_t slice_qp_delta;
|
||||
uint16_t reserved1;
|
||||
const StdVideoEncodeH265WeightTable* pWeightTable;
|
||||
} StdVideoEncodeH265SliceSegmentHeader;
|
||||
|
||||
|
@ -110,7 +111,7 @@ typedef struct StdVideoEncodeH265PictureInfoFlags {
|
|||
uint32_t reserved : 23;
|
||||
} StdVideoEncodeH265PictureInfoFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH265SliceSegmentLongTermRefPics {
|
||||
typedef struct StdVideoEncodeH265LongTermRefPics {
|
||||
uint8_t num_long_term_sps;
|
||||
uint8_t num_long_term_pics;
|
||||
uint8_t lt_idx_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS];
|
||||
|
@ -118,21 +119,21 @@ typedef struct StdVideoEncodeH265SliceSegmentLongTermRefPics {
|
|||
uint16_t used_by_curr_pic_lt_flag;
|
||||
uint8_t delta_poc_msb_present_flag[STD_VIDEO_H265_MAX_DELTA_POC];
|
||||
uint8_t delta_poc_msb_cycle_lt[STD_VIDEO_H265_MAX_DELTA_POC];
|
||||
} StdVideoEncodeH265SliceSegmentLongTermRefPics;
|
||||
} StdVideoEncodeH265LongTermRefPics;
|
||||
|
||||
typedef struct StdVideoEncodeH265PictureInfo {
|
||||
StdVideoEncodeH265PictureInfoFlags flags;
|
||||
StdVideoH265PictureType pic_type;
|
||||
uint8_t sps_video_parameter_set_id;
|
||||
uint8_t pps_seq_parameter_set_id;
|
||||
uint8_t pps_pic_parameter_set_id;
|
||||
uint8_t short_term_ref_pic_set_idx;
|
||||
int32_t PicOrderCntVal;
|
||||
uint8_t TemporalId;
|
||||
uint8_t reserved1[7];
|
||||
const StdVideoEncodeH265ReferenceListsInfo* pRefLists;
|
||||
const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet;
|
||||
const StdVideoEncodeH265SliceSegmentLongTermRefPics* pLongTermRefPics;
|
||||
StdVideoEncodeH265PictureInfoFlags flags;
|
||||
StdVideoH265PictureType pic_type;
|
||||
uint8_t sps_video_parameter_set_id;
|
||||
uint8_t pps_seq_parameter_set_id;
|
||||
uint8_t pps_pic_parameter_set_id;
|
||||
uint8_t short_term_ref_pic_set_idx;
|
||||
int32_t PicOrderCntVal;
|
||||
uint8_t TemporalId;
|
||||
uint8_t reserved1[7];
|
||||
const StdVideoEncodeH265ReferenceListsInfo* pRefLists;
|
||||
const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet;
|
||||
const StdVideoEncodeH265LongTermRefPics* pLongTermRefPics;
|
||||
} StdVideoEncodeH265PictureInfo;
|
||||
|
||||
typedef struct StdVideoEncodeH265ReferenceInfoFlags {
|
||||
|
|
240
thirdparty/vulkan/include/vulkan/vulkan.cppm
vendored
240
thirdparty/vulkan/include/vulkan/vulkan.cppm
vendored
|
@ -5,6 +5,9 @@
|
|||
|
||||
// This header is generated from the Khronos Vulkan XML API Registry.
|
||||
|
||||
// Note: This module is still in an experimental state.
|
||||
// Any feedback is welcome on https://github.com/KhronosGroup/Vulkan-Hpp/issues.
|
||||
|
||||
module;
|
||||
|
||||
#include <vulkan/vulkan.hpp>
|
||||
|
@ -12,10 +15,9 @@ module;
|
|||
#include <vulkan/vulkan_format_traits.hpp>
|
||||
#include <vulkan/vulkan_hash.hpp>
|
||||
#include <vulkan/vulkan_raii.hpp>
|
||||
#include <vulkan/vulkan_shared.hpp>
|
||||
|
||||
export module vulkan;
|
||||
|
||||
VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
|
||||
export module vulkan_hpp;
|
||||
|
||||
export namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
|
@ -25,6 +27,7 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::ArrayWrapper1D;
|
||||
using VULKAN_HPP_NAMESPACE::ArrayWrapper2D;
|
||||
using VULKAN_HPP_NAMESPACE::DispatchLoaderBase;
|
||||
using VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic;
|
||||
using VULKAN_HPP_NAMESPACE::Flags;
|
||||
using VULKAN_HPP_NAMESPACE::FlagTraits;
|
||||
|
||||
|
@ -44,14 +47,19 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::Optional;
|
||||
using VULKAN_HPP_NAMESPACE::StridedArrayProxy;
|
||||
using VULKAN_HPP_NAMESPACE::StructureChain;
|
||||
using VULKAN_HPP_NAMESPACE::UniqueHandle;
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||
using VULKAN_HPP_NAMESPACE::ObjectDestroy;
|
||||
using VULKAN_HPP_NAMESPACE::ObjectDestroyShared;
|
||||
using VULKAN_HPP_NAMESPACE::ObjectFree;
|
||||
using VULKAN_HPP_NAMESPACE::ObjectFreeShared;
|
||||
using VULKAN_HPP_NAMESPACE::ObjectRelease;
|
||||
using VULKAN_HPP_NAMESPACE::ObjectReleaseShared;
|
||||
using VULKAN_HPP_NAMESPACE::PoolFree;
|
||||
using VULKAN_HPP_NAMESPACE::PoolFreeShared;
|
||||
using VULKAN_HPP_NAMESPACE::SharedHandle;
|
||||
using VULKAN_HPP_NAMESPACE::UniqueHandle;
|
||||
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
||||
|
||||
//==================
|
||||
|
@ -110,6 +118,8 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::DescriptorType;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::DynamicState;
|
||||
using VULKAN_HPP_NAMESPACE::EventCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::EventCreateFlags;
|
||||
|
@ -148,13 +158,21 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::ObjectType;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceType;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineBindPoint;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlagBits;
|
||||
|
@ -222,8 +240,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType;
|
||||
using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateTypeKHR;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBitsKHR;
|
||||
using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags;
|
||||
|
@ -669,10 +685,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagBitsEXT;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT;
|
||||
|
||||
//=== VK_EXT_pipeline_creation_cache_control ===
|
||||
using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags;
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_KHR_video_encode_queue ===
|
||||
using VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagBitsKHR;
|
||||
|
@ -705,8 +717,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_EXT_graphics_pipeline_library ===
|
||||
using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagBitsEXT;
|
||||
using VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryFlagsEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags;
|
||||
|
||||
//=== VK_NV_fragment_shading_rate_enums ===
|
||||
using VULKAN_HPP_NAMESPACE::FragmentShadingRateNV;
|
||||
|
@ -748,6 +758,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA;
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
//=== VK_EXT_frame_boundary ===
|
||||
using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagBitsEXT;
|
||||
using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_screen_surface ===
|
||||
using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagBitsQNX;
|
||||
|
@ -782,12 +796,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG;
|
||||
using VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG;
|
||||
|
||||
//=== VK_EXT_rasterization_order_attachment_access ===
|
||||
using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlagBits;
|
||||
using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags;
|
||||
|
||||
//=== VK_NV_optical_flow ===
|
||||
using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagBitsNV;
|
||||
using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagsNV;
|
||||
|
@ -814,12 +822,25 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_NV_ray_tracing_invocation_reorder ===
|
||||
using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeNV;
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
using VULKAN_HPP_NAMESPACE::LatencyMarkerNV;
|
||||
using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV;
|
||||
|
||||
//=== VK_KHR_cooperative_matrix ===
|
||||
using VULKAN_HPP_NAMESPACE::ComponentTypeKHR;
|
||||
using VULKAN_HPP_NAMESPACE::ComponentTypeNV;
|
||||
using VULKAN_HPP_NAMESPACE::ScopeKHR;
|
||||
using VULKAN_HPP_NAMESPACE::ScopeNV;
|
||||
|
||||
//=== VK_QCOM_image_processing2 ===
|
||||
using VULKAN_HPP_NAMESPACE::BlockMatchWindowCompareModeQCOM;
|
||||
|
||||
//=== VK_QCOM_filter_cubic_weights ===
|
||||
using VULKAN_HPP_NAMESPACE::CubicFilterWeightsQCOM;
|
||||
|
||||
//=== VK_MSFT_layered_driver ===
|
||||
using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT;
|
||||
|
||||
//=========================
|
||||
//=== Index Type Traits ===
|
||||
//=========================
|
||||
|
@ -925,40 +946,40 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::MaxDriverNameSize;
|
||||
|
||||
//=== VK_KHR_device_group_creation ===
|
||||
using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSizeKhr;
|
||||
using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSizeKHR;
|
||||
|
||||
//=== VK_KHR_external_memory_capabilities ===
|
||||
using VULKAN_HPP_NAMESPACE::LuidSizeKhr;
|
||||
using VULKAN_HPP_NAMESPACE::LuidSizeKHR;
|
||||
|
||||
//=== VK_KHR_external_memory ===
|
||||
using VULKAN_HPP_NAMESPACE::QueueFamilyExternalKhr;
|
||||
using VULKAN_HPP_NAMESPACE::QueueFamilyExternalKHR;
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_AMDX_shader_enqueue ===
|
||||
using VULKAN_HPP_NAMESPACE::ShaderIndexUnusedAmdx;
|
||||
using VULKAN_HPP_NAMESPACE::ShaderIndexUnusedAMDX;
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_KHR_ray_tracing_pipeline ===
|
||||
using VULKAN_HPP_NAMESPACE::ShaderUnusedKhr;
|
||||
using VULKAN_HPP_NAMESPACE::ShaderUnusedKHR;
|
||||
|
||||
//=== VK_NV_ray_tracing ===
|
||||
using VULKAN_HPP_NAMESPACE::ShaderUnusedNv;
|
||||
using VULKAN_HPP_NAMESPACE::ShaderUnusedNV;
|
||||
|
||||
//=== VK_KHR_global_priority ===
|
||||
using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeKhr;
|
||||
using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeKHR;
|
||||
|
||||
//=== VK_KHR_driver_properties ===
|
||||
using VULKAN_HPP_NAMESPACE::MaxDriverInfoSizeKhr;
|
||||
using VULKAN_HPP_NAMESPACE::MaxDriverNameSizeKhr;
|
||||
using VULKAN_HPP_NAMESPACE::MaxDriverInfoSizeKHR;
|
||||
using VULKAN_HPP_NAMESPACE::MaxDriverNameSizeKHR;
|
||||
|
||||
//=== VK_EXT_global_priority_query ===
|
||||
using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeExt;
|
||||
using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeEXT;
|
||||
|
||||
//=== VK_EXT_image_sliced_view_of_3d ===
|
||||
using VULKAN_HPP_NAMESPACE::Remaining3DSlicesExt;
|
||||
using VULKAN_HPP_NAMESPACE::Remaining3DSlicesEXT;
|
||||
|
||||
//=== VK_EXT_shader_module_identifier ===
|
||||
using VULKAN_HPP_NAMESPACE::MaxShaderModuleIdentifierSizeExt;
|
||||
using VULKAN_HPP_NAMESPACE::MaxShaderModuleIdentifierSizeEXT;
|
||||
|
||||
//========================
|
||||
//=== CONSTEXPR VALUEs ===
|
||||
|
@ -2416,6 +2437,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT;
|
||||
|
||||
//=== VK_EXT_frame_boundary ===
|
||||
using VULKAN_HPP_NAMESPACE::FrameBoundaryEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT;
|
||||
|
||||
//=== VK_EXT_multisampled_render_to_single_sampled ===
|
||||
using VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
|
||||
|
@ -2540,6 +2565,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM;
|
||||
|
||||
//=== VK_EXT_nested_command_buffer ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT;
|
||||
|
||||
//=== VK_EXT_external_memory_acquire_unmodified ===
|
||||
using VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT;
|
||||
|
||||
|
@ -2586,6 +2615,13 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_EXT_pipeline_protected_access ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
//=== VK_ANDROID_external_format_resolve ===
|
||||
using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID;
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|
||||
//=== VK_KHR_maintenance5 ===
|
||||
using VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR;
|
||||
using VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR;
|
||||
|
@ -2621,6 +2657,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
|
||||
|
||||
//=== VK_NV_extended_sparse_address_space ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
|
||||
|
||||
//=== VK_EXT_mutable_descriptor_type ===
|
||||
using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT;
|
||||
using VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE;
|
||||
|
@ -2639,6 +2679,17 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_EXT_dynamic_rendering_unused_attachments ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
using VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::LatencySleepInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV;
|
||||
using VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV;
|
||||
using VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV;
|
||||
using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV;
|
||||
using VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV;
|
||||
|
||||
//=== VK_KHR_cooperative_matrix ===
|
||||
using VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR;
|
||||
|
@ -2648,6 +2699,23 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
|
||||
|
||||
//=== VK_QCOM_image_processing2 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM;
|
||||
|
||||
//=== VK_QCOM_filter_cubic_weights ===
|
||||
using VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM;
|
||||
|
||||
//=== VK_QCOM_ycbcr_degamma ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM;
|
||||
using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
|
||||
|
||||
//=== VK_QCOM_filter_cubic_clamp ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM;
|
||||
|
||||
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
|
||||
|
||||
|
@ -2660,6 +2728,12 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX;
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_MSFT_layered_driver ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT;
|
||||
|
||||
//=== VK_NV_descriptor_pool_overallocation ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
|
||||
|
||||
//===============
|
||||
//=== HANDLEs ===
|
||||
//===============
|
||||
|
@ -2845,6 +2919,104 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::UniqueShaderEXT;
|
||||
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
||||
|
||||
//======================
|
||||
//=== SHARED HANDLEs ===
|
||||
//======================
|
||||
|
||||
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||
|
||||
//=== VK_VERSION_1_0 ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedBuffer;
|
||||
using VULKAN_HPP_NAMESPACE::SharedBufferView;
|
||||
using VULKAN_HPP_NAMESPACE::SharedCommandBuffer;
|
||||
using VULKAN_HPP_NAMESPACE::SharedCommandPool;
|
||||
using VULKAN_HPP_NAMESPACE::SharedDescriptorPool;
|
||||
using VULKAN_HPP_NAMESPACE::SharedDescriptorSet;
|
||||
using VULKAN_HPP_NAMESPACE::SharedDescriptorSetLayout;
|
||||
using VULKAN_HPP_NAMESPACE::SharedDevice;
|
||||
using VULKAN_HPP_NAMESPACE::SharedDeviceMemory;
|
||||
using VULKAN_HPP_NAMESPACE::SharedEvent;
|
||||
using VULKAN_HPP_NAMESPACE::SharedFence;
|
||||
using VULKAN_HPP_NAMESPACE::SharedFramebuffer;
|
||||
using VULKAN_HPP_NAMESPACE::SharedImage;
|
||||
using VULKAN_HPP_NAMESPACE::SharedImageView;
|
||||
using VULKAN_HPP_NAMESPACE::SharedInstance;
|
||||
using VULKAN_HPP_NAMESPACE::SharedPhysicalDevice;
|
||||
using VULKAN_HPP_NAMESPACE::SharedPipeline;
|
||||
using VULKAN_HPP_NAMESPACE::SharedPipelineCache;
|
||||
using VULKAN_HPP_NAMESPACE::SharedPipelineLayout;
|
||||
using VULKAN_HPP_NAMESPACE::SharedQueryPool;
|
||||
using VULKAN_HPP_NAMESPACE::SharedQueue;
|
||||
using VULKAN_HPP_NAMESPACE::SharedRenderPass;
|
||||
using VULKAN_HPP_NAMESPACE::SharedSampler;
|
||||
using VULKAN_HPP_NAMESPACE::SharedSemaphore;
|
||||
using VULKAN_HPP_NAMESPACE::SharedShaderModule;
|
||||
|
||||
//=== VK_VERSION_1_1 ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedDescriptorUpdateTemplate;
|
||||
using VULKAN_HPP_NAMESPACE::SharedSamplerYcbcrConversion;
|
||||
|
||||
//=== VK_VERSION_1_3 ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedPrivateDataSlot;
|
||||
|
||||
//=== VK_KHR_surface ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedSurfaceKHR;
|
||||
|
||||
//=== VK_KHR_swapchain ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedSwapchainKHR;
|
||||
|
||||
//=== VK_KHR_display ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedDisplayKHR;
|
||||
using VULKAN_HPP_NAMESPACE::SharedDisplayModeKHR;
|
||||
|
||||
//=== VK_EXT_debug_report ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedDebugReportCallbackEXT;
|
||||
|
||||
//=== VK_KHR_video_queue ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedVideoSessionKHR;
|
||||
using VULKAN_HPP_NAMESPACE::SharedVideoSessionParametersKHR;
|
||||
|
||||
//=== VK_NVX_binary_import ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedCuFunctionNVX;
|
||||
using VULKAN_HPP_NAMESPACE::SharedCuModuleNVX;
|
||||
|
||||
//=== VK_EXT_debug_utils ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedDebugUtilsMessengerEXT;
|
||||
|
||||
//=== VK_KHR_acceleration_structure ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureKHR;
|
||||
|
||||
//=== VK_EXT_validation_cache ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedValidationCacheEXT;
|
||||
|
||||
//=== VK_NV_ray_tracing ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureNV;
|
||||
|
||||
//=== VK_INTEL_performance_query ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedPerformanceConfigurationINTEL;
|
||||
|
||||
//=== VK_KHR_deferred_host_operations ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedDeferredOperationKHR;
|
||||
|
||||
//=== VK_NV_device_generated_commands ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutNV;
|
||||
|
||||
# if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||
//=== VK_FUCHSIA_buffer_collection ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedBufferCollectionFUCHSIA;
|
||||
# endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
//=== VK_EXT_opacity_micromap ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedMicromapEXT;
|
||||
|
||||
//=== VK_NV_optical_flow ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV;
|
||||
|
||||
//=== VK_EXT_shader_object ===
|
||||
using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
|
||||
using VULKAN_HPP_NAMESPACE::SharedShaderEXT;
|
||||
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
||||
|
||||
//===========================
|
||||
//=== COMMAND Definitions ===
|
||||
//===========================
|
||||
|
@ -2865,8 +3037,6 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::DynamicLoader;
|
||||
#endif /*VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL*/
|
||||
|
||||
using VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic;
|
||||
|
||||
//=====================
|
||||
//=== Format Traits ===
|
||||
//=====================
|
||||
|
@ -2906,6 +3076,7 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_NAMESPACE::isObsoletedExtension;
|
||||
using VULKAN_HPP_NAMESPACE::isPromotedExtension;
|
||||
|
||||
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) && !defined( VULKAN_HPP_NO_EXCEPTIONS )
|
||||
namespace VULKAN_HPP_RAII_NAMESPACE
|
||||
{
|
||||
//======================
|
||||
|
@ -3004,10 +3175,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_NV_device_generated_commands ===
|
||||
using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||
# if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||
//=== VK_FUCHSIA_buffer_collection ===
|
||||
using VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA;
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
# endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
//=== VK_EXT_opacity_micromap ===
|
||||
using VULKAN_HPP_RAII_NAMESPACE::MicromapEXT;
|
||||
|
@ -3020,4 +3191,5 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||
using VULKAN_HPP_RAII_NAMESPACE::ShaderEXTs;
|
||||
|
||||
} // namespace VULKAN_HPP_RAII_NAMESPACE
|
||||
#endif
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
|
917
thirdparty/vulkan/include/vulkan/vulkan.hpp
vendored
917
thirdparty/vulkan/include/vulkan/vulkan.hpp
vendored
File diff suppressed because it is too large
Load diff
|
@ -120,6 +120,32 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
|
|||
struct AHardwareBuffer** pBuffer);
|
||||
#endif
|
||||
|
||||
|
||||
// VK_ANDROID_external_format_resolve is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_ANDROID_external_format_resolve 1
|
||||
#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION 1
|
||||
#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME "VK_ANDROID_external_format_resolve"
|
||||
typedef struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 externalFormatResolve;
|
||||
} VkPhysicalDeviceExternalFormatResolveFeaturesANDROID;
|
||||
|
||||
typedef struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 nullColorAttachmentWithExternalFormatResolve;
|
||||
VkChromaLocation externalFormatResolveChromaOffsetX;
|
||||
VkChromaLocation externalFormatResolveChromaOffsetY;
|
||||
} VkPhysicalDeviceExternalFormatResolvePropertiesANDROID;
|
||||
|
||||
typedef struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkFormat colorAttachmentFormat;
|
||||
} VkAndroidHardwareBufferFormatResolvePropertiesANDROID;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
11
thirdparty/vulkan/include/vulkan/vulkan_beta.h
vendored
11
thirdparty/vulkan/include/vulkan/vulkan_beta.h
vendored
|
@ -53,7 +53,7 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
|
|||
|
||||
// VK_KHR_video_encode_queue is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_video_encode_queue 1
|
||||
#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 9
|
||||
#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 10
|
||||
#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
|
||||
|
||||
typedef enum VkVideoEncodeTuningModeKHR {
|
||||
|
@ -68,6 +68,7 @@ typedef VkFlags VkVideoEncodeFlagsKHR;
|
|||
|
||||
typedef enum VkVideoEncodeCapabilityFlagBitsKHR {
|
||||
VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001,
|
||||
VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR = 0x00000002,
|
||||
VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoEncodeCapabilityFlagBitsKHR;
|
||||
typedef VkFlags VkVideoEncodeCapabilityFlagsKHR;
|
||||
|
@ -227,7 +228,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
|
|||
#define VK_EXT_video_encode_h264 1
|
||||
#include "vk_video/vulkan_video_codec_h264std.h"
|
||||
#include "vk_video/vulkan_video_codec_h264std_encode.h"
|
||||
#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 11
|
||||
#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 12
|
||||
#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
|
||||
|
||||
typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
|
||||
|
@ -263,6 +264,8 @@ typedef enum VkVideoEncodeH264StdFlagBitsEXT {
|
|||
VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00008000,
|
||||
VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00010000,
|
||||
VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00020000,
|
||||
VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT = 0x00080000,
|
||||
VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT = 0x00100000,
|
||||
VK_VIDEO_ENCODE_H264_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkVideoEncodeH264StdFlagBitsEXT;
|
||||
typedef VkFlags VkVideoEncodeH264StdFlagsEXT;
|
||||
|
@ -424,7 +427,7 @@ typedef struct VkVideoEncodeH264GopRemainingFrameInfoEXT {
|
|||
#define VK_EXT_video_encode_h265 1
|
||||
#include "vk_video/vulkan_video_codec_h265std.h"
|
||||
#include "vk_video/vulkan_video_codec_h265std_encode.h"
|
||||
#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 11
|
||||
#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 12
|
||||
#define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265"
|
||||
|
||||
typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT {
|
||||
|
@ -462,6 +465,8 @@ typedef enum VkVideoEncodeH265StdFlagBitsEXT {
|
|||
VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT = 0x00010000,
|
||||
VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT = 0x00020000,
|
||||
VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT = 0x00040000,
|
||||
VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT = 0x00080000,
|
||||
VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT = 0x00100000,
|
||||
VK_VIDEO_ENCODE_H265_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkVideoEncodeH265StdFlagBitsEXT;
|
||||
typedef VkFlags VkVideoEncodeH265StdFlagsEXT;
|
||||
|
|
369
thirdparty/vulkan/include/vulkan/vulkan_core.h
vendored
369
thirdparty/vulkan/include/vulkan/vulkan_core.h
vendored
|
@ -27,7 +27,7 @@ extern "C" {
|
|||
|
||||
|
||||
#ifndef VK_USE_64_BIT_PTR_DEFINES
|
||||
#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
|
||||
#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) || (defined(__riscv) && __riscv_xlen == 64)
|
||||
#define VK_USE_64_BIT_PTR_DEFINES 1
|
||||
#else
|
||||
#define VK_USE_64_BIT_PTR_DEFINES 0
|
||||
|
@ -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 261
|
||||
#define VK_HEADER_VERSION 268
|
||||
|
||||
// Complete version of this file
|
||||
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
|
||||
|
@ -992,6 +992,8 @@ typedef enum VkStructureType {
|
|||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001,
|
||||
VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT = 1000375000,
|
||||
VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT = 1000375001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000,
|
||||
VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001,
|
||||
VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002,
|
||||
|
@ -1055,6 +1057,8 @@ typedef enum VkStructureType {
|
|||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001,
|
||||
VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT = 1000451000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT = 1000451001,
|
||||
VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001,
|
||||
|
@ -1078,6 +1082,9 @@ typedef enum VkStructureType {
|
|||
VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID = 1000468000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468001,
|
||||
VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = 1000470000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = 1000470001,
|
||||
VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR = 1000470003,
|
||||
|
@ -1097,23 +1104,45 @@ typedef enum VkStructureType {
|
|||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV = 1000492000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000,
|
||||
VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000,
|
||||
VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV = 1000505000,
|
||||
VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV = 1000505001,
|
||||
VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV = 1000505002,
|
||||
VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV = 1000505003,
|
||||
VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV = 1000505004,
|
||||
VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV = 1000505005,
|
||||
VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV = 1000505006,
|
||||
VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV = 1000505007,
|
||||
VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV = 1000505008,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000,
|
||||
VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001,
|
||||
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_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001,
|
||||
VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002,
|
||||
VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM = 1000519000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM = 1000519001,
|
||||
VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM = 1000519002,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM = 1000520000,
|
||||
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000,
|
||||
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000,
|
||||
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_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
|
||||
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,
|
||||
|
@ -2163,6 +2192,7 @@ typedef enum VkIndexType {
|
|||
typedef enum VkSubpassContents {
|
||||
VK_SUBPASS_CONTENTS_INLINE = 0,
|
||||
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
|
||||
VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = 1000451000,
|
||||
VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
|
||||
} VkSubpassContents;
|
||||
|
||||
|
@ -2714,6 +2744,8 @@ typedef enum VkDescriptorPoolCreateFlagBits {
|
|||
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
|
||||
VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002,
|
||||
VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0x00000004,
|
||||
VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV = 0x00000008,
|
||||
VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV = 0x00000010,
|
||||
VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
|
||||
VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT,
|
||||
VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
|
||||
|
@ -5784,6 +5816,7 @@ typedef enum VkDriverId {
|
|||
VK_DRIVER_ID_MESA_DOZEN = 23,
|
||||
VK_DRIVER_ID_MESA_NVK = 24,
|
||||
VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25,
|
||||
VK_DRIVER_ID_MESA_AGXV = 26,
|
||||
VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
|
||||
VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
|
||||
VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
|
||||
|
@ -5813,6 +5846,7 @@ typedef enum VkSamplerReductionMode {
|
|||
VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0,
|
||||
VK_SAMPLER_REDUCTION_MODE_MIN = 1,
|
||||
VK_SAMPLER_REDUCTION_MODE_MAX = 2,
|
||||
VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM = 1000521000,
|
||||
VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
|
||||
VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN,
|
||||
VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX,
|
||||
|
@ -5833,6 +5867,7 @@ typedef enum VkResolveModeFlagBits {
|
|||
VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002,
|
||||
VK_RESOLVE_MODE_MIN_BIT = 0x00000004,
|
||||
VK_RESOLVE_MODE_MAX_BIT = 0x00000008,
|
||||
VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID = 0x00000010,
|
||||
VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE,
|
||||
VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
|
||||
VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT,
|
||||
|
@ -6711,6 +6746,7 @@ typedef enum VkRenderingFlagBits {
|
|||
VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001,
|
||||
VK_RENDERING_SUSPENDING_BIT = 0x00000002,
|
||||
VK_RENDERING_RESUMING_BIT = 0x00000004,
|
||||
VK_RENDERING_CONTENTS_INLINE_BIT_EXT = 0x00000010,
|
||||
VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008,
|
||||
VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT,
|
||||
VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT,
|
||||
|
@ -7992,6 +8028,7 @@ typedef enum VkQueryResultStatusKHR {
|
|||
VK_QUERY_RESULT_STATUS_ERROR_KHR = -1,
|
||||
VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0,
|
||||
VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1,
|
||||
VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR = -1000299000,
|
||||
VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkQueryResultStatusKHR;
|
||||
|
||||
|
@ -15816,6 +15853,38 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT(
|
|||
#endif
|
||||
|
||||
|
||||
// VK_EXT_frame_boundary is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_frame_boundary 1
|
||||
#define VK_EXT_FRAME_BOUNDARY_SPEC_VERSION 1
|
||||
#define VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME "VK_EXT_frame_boundary"
|
||||
|
||||
typedef enum VkFrameBoundaryFlagBitsEXT {
|
||||
VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT = 0x00000001,
|
||||
VK_FRAME_BOUNDARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkFrameBoundaryFlagBitsEXT;
|
||||
typedef VkFlags VkFrameBoundaryFlagsEXT;
|
||||
typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 frameBoundary;
|
||||
} VkPhysicalDeviceFrameBoundaryFeaturesEXT;
|
||||
|
||||
typedef struct VkFrameBoundaryEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkFrameBoundaryFlagsEXT flags;
|
||||
uint64_t frameID;
|
||||
uint32_t imageCount;
|
||||
const VkImage* pImages;
|
||||
uint32_t bufferCount;
|
||||
const VkBuffer* pBuffers;
|
||||
uint64_t tagName;
|
||||
size_t tagSize;
|
||||
const void* pTag;
|
||||
} VkFrameBoundaryEXT;
|
||||
|
||||
|
||||
|
||||
// VK_EXT_multisampled_render_to_single_sampled is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_multisampled_render_to_single_sampled 1
|
||||
#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION 1
|
||||
|
@ -16728,6 +16797,26 @@ typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM {
|
|||
|
||||
|
||||
|
||||
// VK_EXT_nested_command_buffer is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_nested_command_buffer 1
|
||||
#define VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION 1
|
||||
#define VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME "VK_EXT_nested_command_buffer"
|
||||
typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 nestedCommandBuffer;
|
||||
VkBool32 nestedCommandBufferRendering;
|
||||
VkBool32 nestedCommandBufferSimultaneousUse;
|
||||
} VkPhysicalDeviceNestedCommandBufferFeaturesEXT;
|
||||
|
||||
typedef struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
uint32_t maxCommandBufferNestingLevel;
|
||||
} VkPhysicalDeviceNestedCommandBufferPropertiesEXT;
|
||||
|
||||
|
||||
|
||||
// VK_EXT_external_memory_acquire_unmodified is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_external_memory_acquire_unmodified 1
|
||||
#define VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION 1
|
||||
|
@ -17482,6 +17571,26 @@ typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
|
|||
|
||||
|
||||
|
||||
// VK_NV_extended_sparse_address_space is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_extended_sparse_address_space 1
|
||||
#define VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION 1
|
||||
#define VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME "VK_NV_extended_sparse_address_space"
|
||||
typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 extendedSparseAddressSpace;
|
||||
} VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
|
||||
|
||||
typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkDeviceSize extendedSparseAddressSpaceSize;
|
||||
VkImageUsageFlags extendedSparseImageUsageFlags;
|
||||
VkBufferUsageFlags extendedSparseBufferUsageFlags;
|
||||
} VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
|
||||
|
||||
|
||||
|
||||
// VK_EXT_mutable_descriptor_type is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_mutable_descriptor_type 1
|
||||
#define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1
|
||||
|
@ -17532,6 +17641,138 @@ typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
|
|||
|
||||
|
||||
|
||||
// VK_NV_low_latency2 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_low_latency2 1
|
||||
#define VK_NV_LOW_LATENCY_2_SPEC_VERSION 1
|
||||
#define VK_NV_LOW_LATENCY_2_EXTENSION_NAME "VK_NV_low_latency2"
|
||||
|
||||
typedef enum VkLatencyMarkerNV {
|
||||
VK_LATENCY_MARKER_SIMULATION_START_NV = 0,
|
||||
VK_LATENCY_MARKER_SIMULATION_END_NV = 1,
|
||||
VK_LATENCY_MARKER_RENDERSUBMIT_START_NV = 2,
|
||||
VK_LATENCY_MARKER_RENDERSUBMIT_END_NV = 3,
|
||||
VK_LATENCY_MARKER_PRESENT_START_NV = 4,
|
||||
VK_LATENCY_MARKER_PRESENT_END_NV = 5,
|
||||
VK_LATENCY_MARKER_INPUT_SAMPLE_NV = 6,
|
||||
VK_LATENCY_MARKER_TRIGGER_FLASH_NV = 7,
|
||||
VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV = 8,
|
||||
VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV = 9,
|
||||
VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV = 10,
|
||||
VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV = 11,
|
||||
VK_LATENCY_MARKER_MAX_ENUM_NV = 0x7FFFFFFF
|
||||
} VkLatencyMarkerNV;
|
||||
|
||||
typedef enum VkOutOfBandQueueTypeNV {
|
||||
VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV = 0,
|
||||
VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV = 1,
|
||||
VK_OUT_OF_BAND_QUEUE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
|
||||
} VkOutOfBandQueueTypeNV;
|
||||
typedef struct VkLatencySleepModeInfoNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkBool32 lowLatencyMode;
|
||||
VkBool32 lowLatencyBoost;
|
||||
uint32_t minimumIntervalUs;
|
||||
} VkLatencySleepModeInfoNV;
|
||||
|
||||
typedef struct VkLatencySleepInfoNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkSemaphore signalSemaphore;
|
||||
uint64_t value;
|
||||
} VkLatencySleepInfoNV;
|
||||
|
||||
typedef struct VkSetLatencyMarkerInfoNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint64_t presentID;
|
||||
VkLatencyMarkerNV marker;
|
||||
} VkSetLatencyMarkerInfoNV;
|
||||
|
||||
typedef struct VkLatencyTimingsFrameReportNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint64_t presentID;
|
||||
uint64_t inputSampleTimeUs;
|
||||
uint64_t simStartTimeUs;
|
||||
uint64_t simEndTimeUs;
|
||||
uint64_t renderSubmitStartTimeUs;
|
||||
uint64_t renderSubmitEndTimeUs;
|
||||
uint64_t presentStartTimeUs;
|
||||
uint64_t presentEndTimeUs;
|
||||
uint64_t driverStartTimeUs;
|
||||
uint64_t driverEndTimeUs;
|
||||
uint64_t osRenderQueueStartTimeUs;
|
||||
uint64_t osRenderQueueEndTimeUs;
|
||||
uint64_t gpuRenderStartTimeUs;
|
||||
uint64_t gpuRenderEndTimeUs;
|
||||
} VkLatencyTimingsFrameReportNV;
|
||||
|
||||
typedef struct VkGetLatencyMarkerInfoNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkLatencyTimingsFrameReportNV* pTimings;
|
||||
} VkGetLatencyMarkerInfoNV;
|
||||
|
||||
typedef struct VkLatencySubmissionPresentIdNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint64_t presentID;
|
||||
} VkLatencySubmissionPresentIdNV;
|
||||
|
||||
typedef struct VkSwapchainLatencyCreateInfoNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkBool32 latencyModeEnable;
|
||||
} VkSwapchainLatencyCreateInfoNV;
|
||||
|
||||
typedef struct VkOutOfBandQueueTypeInfoNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkOutOfBandQueueTypeNV queueType;
|
||||
} VkOutOfBandQueueTypeInfoNV;
|
||||
|
||||
typedef struct VkLatencySurfaceCapabilitiesNV {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t presentModeCount;
|
||||
VkPresentModeKHR* pPresentModes;
|
||||
} VkLatencySurfaceCapabilitiesNV;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkSetLatencySleepModeNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkLatencySleepNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo);
|
||||
typedef void (VKAPI_PTR *PFN_vkSetLatencyMarkerNV)(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo);
|
||||
typedef void (VKAPI_PTR *PFN_vkGetLatencyTimingsNV)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pTimingCount, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo);
|
||||
typedef void (VKAPI_PTR *PFN_vkQueueNotifyOutOfBandNV)(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkSetLatencySleepModeNV(
|
||||
VkDevice device,
|
||||
VkSwapchainKHR swapchain,
|
||||
const VkLatencySleepModeInfoNV* pSleepModeInfo);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkLatencySleepNV(
|
||||
VkDevice device,
|
||||
VkSwapchainKHR swapchain,
|
||||
const VkLatencySleepInfoNV* pSleepInfo);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerNV(
|
||||
VkDevice device,
|
||||
VkSwapchainKHR swapchain,
|
||||
const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsNV(
|
||||
VkDevice device,
|
||||
VkSwapchainKHR swapchain,
|
||||
uint32_t* pTimingCount,
|
||||
VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandNV(
|
||||
VkQueue queue,
|
||||
const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo);
|
||||
#endif
|
||||
|
||||
|
||||
// VK_QCOM_multiview_per_view_render_areas is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_QCOM_multiview_per_view_render_areas 1
|
||||
#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1
|
||||
|
@ -17551,6 +17792,100 @@ typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
|
|||
|
||||
|
||||
|
||||
// VK_QCOM_image_processing2 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_QCOM_image_processing2 1
|
||||
#define VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION 1
|
||||
#define VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME "VK_QCOM_image_processing2"
|
||||
|
||||
typedef enum VkBlockMatchWindowCompareModeQCOM {
|
||||
VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM = 0,
|
||||
VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM = 1,
|
||||
VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_ENUM_QCOM = 0x7FFFFFFF
|
||||
} VkBlockMatchWindowCompareModeQCOM;
|
||||
typedef struct VkPhysicalDeviceImageProcessing2FeaturesQCOM {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 textureBlockMatch2;
|
||||
} VkPhysicalDeviceImageProcessing2FeaturesQCOM;
|
||||
|
||||
typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkExtent2D maxBlockMatchWindow;
|
||||
} VkPhysicalDeviceImageProcessing2PropertiesQCOM;
|
||||
|
||||
typedef struct VkSamplerBlockMatchWindowCreateInfoQCOM {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkExtent2D windowExtent;
|
||||
VkBlockMatchWindowCompareModeQCOM windowCompareMode;
|
||||
} VkSamplerBlockMatchWindowCreateInfoQCOM;
|
||||
|
||||
|
||||
|
||||
// VK_QCOM_filter_cubic_weights is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_QCOM_filter_cubic_weights 1
|
||||
#define VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION 1
|
||||
#define VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME "VK_QCOM_filter_cubic_weights"
|
||||
|
||||
typedef enum VkCubicFilterWeightsQCOM {
|
||||
VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM = 0,
|
||||
VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM = 1,
|
||||
VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM = 2,
|
||||
VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM = 3,
|
||||
VK_CUBIC_FILTER_WEIGHTS_MAX_ENUM_QCOM = 0x7FFFFFFF
|
||||
} VkCubicFilterWeightsQCOM;
|
||||
typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 selectableCubicWeights;
|
||||
} VkPhysicalDeviceCubicWeightsFeaturesQCOM;
|
||||
|
||||
typedef struct VkSamplerCubicWeightsCreateInfoQCOM {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkCubicFilterWeightsQCOM cubicWeights;
|
||||
} VkSamplerCubicWeightsCreateInfoQCOM;
|
||||
|
||||
typedef struct VkBlitImageCubicWeightsInfoQCOM {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkCubicFilterWeightsQCOM cubicWeights;
|
||||
} VkBlitImageCubicWeightsInfoQCOM;
|
||||
|
||||
|
||||
|
||||
// VK_QCOM_ycbcr_degamma is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_QCOM_ycbcr_degamma 1
|
||||
#define VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION 1
|
||||
#define VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME "VK_QCOM_ycbcr_degamma"
|
||||
typedef struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 ycbcrDegamma;
|
||||
} VkPhysicalDeviceYcbcrDegammaFeaturesQCOM;
|
||||
|
||||
typedef struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 enableYDegamma;
|
||||
VkBool32 enableCbCrDegamma;
|
||||
} VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
|
||||
|
||||
|
||||
|
||||
// VK_QCOM_filter_cubic_clamp is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_QCOM_filter_cubic_clamp 1
|
||||
#define VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION 1
|
||||
#define VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME "VK_QCOM_filter_cubic_clamp"
|
||||
typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 cubicRangeClamp;
|
||||
} VkPhysicalDeviceCubicClampFeaturesQCOM;
|
||||
|
||||
|
||||
|
||||
// VK_EXT_attachment_feedback_loop_dynamic_state is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_attachment_feedback_loop_dynamic_state 1
|
||||
#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION 1
|
||||
|
@ -17570,6 +17905,36 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetAttachmentFeedbackLoopEnableEXT(
|
|||
#endif
|
||||
|
||||
|
||||
// VK_MSFT_layered_driver is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_MSFT_layered_driver 1
|
||||
#define VK_MSFT_LAYERED_DRIVER_SPEC_VERSION 1
|
||||
#define VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME "VK_MSFT_layered_driver"
|
||||
|
||||
typedef enum VkLayeredDriverUnderlyingApiMSFT {
|
||||
VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT = 0,
|
||||
VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT = 1,
|
||||
VK_LAYERED_DRIVER_UNDERLYING_API_MAX_ENUM_MSFT = 0x7FFFFFFF
|
||||
} VkLayeredDriverUnderlyingApiMSFT;
|
||||
typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkLayeredDriverUnderlyingApiMSFT underlyingAPI;
|
||||
} VkPhysicalDeviceLayeredDriverPropertiesMSFT;
|
||||
|
||||
|
||||
|
||||
// VK_NV_descriptor_pool_overallocation is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_descriptor_pool_overallocation 1
|
||||
#define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION 1
|
||||
#define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME "VK_NV_descriptor_pool_overallocation"
|
||||
typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 descriptorPoolOverallocation;
|
||||
} VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
|
||||
|
||||
|
||||
|
||||
// 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
|
||||
|
|
656
thirdparty/vulkan/include/vulkan/vulkan_enums.hpp
vendored
656
thirdparty/vulkan/include/vulkan/vulkan_enums.hpp
vendored
|
@ -10,6 +10,212 @@
|
|||
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
template <typename FlagBitsType>
|
||||
struct FlagTraits
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
|
||||
};
|
||||
|
||||
template <typename BitType>
|
||||
class Flags
|
||||
{
|
||||
public:
|
||||
using MaskType = typename std::underlying_type<BitType>::type;
|
||||
|
||||
// constructors
|
||||
VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
|
||||
|
||||
VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
|
||||
|
||||
// relational operators
|
||||
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
|
||||
auto operator<=>( Flags<BitType> const & ) const = default;
|
||||
#else
|
||||
VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_mask < rhs.m_mask;
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_mask <= rhs.m_mask;
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_mask > rhs.m_mask;
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_mask >= rhs.m_mask;
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_mask == rhs.m_mask;
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_mask != rhs.m_mask;
|
||||
}
|
||||
#endif
|
||||
|
||||
// logical operator
|
||||
VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return !m_mask;
|
||||
}
|
||||
|
||||
// bitwise operators
|
||||
VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return Flags<BitType>( m_mask & rhs.m_mask );
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return Flags<BitType>( m_mask | rhs.m_mask );
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return Flags<BitType>( m_mask ^ rhs.m_mask );
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
|
||||
}
|
||||
|
||||
// assignment operators
|
||||
VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
|
||||
|
||||
VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
m_mask |= rhs.m_mask;
|
||||
return *this;
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
m_mask &= rhs.m_mask;
|
||||
return *this;
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
m_mask ^= rhs.m_mask;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// cast operators
|
||||
explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return !!m_mask;
|
||||
}
|
||||
|
||||
explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_mask;
|
||||
}
|
||||
|
||||
#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
|
||||
public:
|
||||
#else
|
||||
private:
|
||||
#endif
|
||||
MaskType m_mask;
|
||||
};
|
||||
|
||||
#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
|
||||
// relational operators only needed for pre C++20
|
||||
template <typename BitType>
|
||||
VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return flags.operator>( bit );
|
||||
}
|
||||
|
||||
template <typename BitType>
|
||||
VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return flags.operator>=( bit );
|
||||
}
|
||||
|
||||
template <typename BitType>
|
||||
VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return flags.operator<( bit );
|
||||
}
|
||||
|
||||
template <typename BitType>
|
||||
VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return flags.operator<=( bit );
|
||||
}
|
||||
|
||||
template <typename BitType>
|
||||
VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return flags.operator==( bit );
|
||||
}
|
||||
|
||||
template <typename BitType>
|
||||
VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return flags.operator!=( bit );
|
||||
}
|
||||
#endif
|
||||
|
||||
// bitwise operators
|
||||
template <typename BitType>
|
||||
VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return flags.operator&( bit );
|
||||
}
|
||||
|
||||
template <typename BitType>
|
||||
VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return flags.operator|( bit );
|
||||
}
|
||||
|
||||
template <typename BitType>
|
||||
VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return flags.operator^( bit );
|
||||
}
|
||||
|
||||
// bitwise operators on BitType
|
||||
template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return Flags<BitType>( lhs ) & rhs;
|
||||
}
|
||||
|
||||
template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return Flags<BitType>( lhs ) | rhs;
|
||||
}
|
||||
|
||||
template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return Flags<BitType>( lhs ) ^ rhs;
|
||||
}
|
||||
|
||||
template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ~( Flags<BitType>( bit ) );
|
||||
}
|
||||
|
||||
template <typename EnumType, EnumType value>
|
||||
struct CppType
|
||||
{
|
||||
|
@ -1007,6 +1213,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
ePipelinePropertiesIdentifierEXT = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT,
|
||||
ePhysicalDevicePipelinePropertiesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT,
|
||||
ePipelineInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT,
|
||||
ePhysicalDeviceFrameBoundaryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT,
|
||||
eFrameBoundaryEXT = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT,
|
||||
ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT,
|
||||
eSubpassResolvePerformanceQueryEXT = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT,
|
||||
eMultisampledRenderToSingleSampledInfoEXT = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT,
|
||||
|
@ -1074,6 +1282,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
ePhysicalDeviceImageProcessingFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM,
|
||||
ePhysicalDeviceImageProcessingPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM,
|
||||
eImageViewSampleWeightCreateInfoQCOM = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM,
|
||||
ePhysicalDeviceNestedCommandBufferFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT,
|
||||
ePhysicalDeviceNestedCommandBufferPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT,
|
||||
eExternalMemoryAcquireUnmodifiedEXT = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT,
|
||||
ePhysicalDeviceExtendedDynamicState3FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
|
||||
ePhysicalDeviceExtendedDynamicState3PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT,
|
||||
|
@ -1097,6 +1307,11 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
eOpticalFlowSessionCreatePrivateDataInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV,
|
||||
ePhysicalDeviceLegacyDitheringFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT,
|
||||
ePhysicalDevicePipelineProtectedAccessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT,
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
ePhysicalDeviceExternalFormatResolveFeaturesANDROID = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID,
|
||||
ePhysicalDeviceExternalFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID,
|
||||
eAndroidHardwareBufferFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID,
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
ePhysicalDeviceMaintenance5FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR,
|
||||
ePhysicalDeviceMaintenance5PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR,
|
||||
eRenderingAreaInfoKHR = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR,
|
||||
|
@ -1117,25 +1332,47 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM,
|
||||
ePhysicalDeviceRayTracingInvocationReorderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV,
|
||||
ePhysicalDeviceRayTracingInvocationReorderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV,
|
||||
ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV,
|
||||
ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV,
|
||||
ePhysicalDeviceMutableDescriptorTypeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT,
|
||||
eMutableDescriptorTypeCreateInfoEXT = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT,
|
||||
ePhysicalDeviceShaderCoreBuiltinsFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM,
|
||||
ePhysicalDeviceShaderCoreBuiltinsPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM,
|
||||
ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT,
|
||||
ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT,
|
||||
eLatencySleepModeInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV,
|
||||
eLatencySleepInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV,
|
||||
eSetLatencyMarkerInfoNV = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV,
|
||||
eGetLatencyMarkerInfoNV = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV,
|
||||
eLatencyTimingsFrameReportNV = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV,
|
||||
eLatencySubmissionPresentIdNV = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV,
|
||||
eOutOfBandQueueTypeInfoNV = VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV,
|
||||
eSwapchainLatencyCreateInfoNV = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV,
|
||||
eLatencySurfaceCapabilitiesNV = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV,
|
||||
ePhysicalDeviceCooperativeMatrixFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR,
|
||||
eCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
|
||||
ePhysicalDeviceCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
|
||||
ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM,
|
||||
eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM,
|
||||
ePhysicalDeviceImageProcessing2FeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM,
|
||||
ePhysicalDeviceImageProcessing2PropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM,
|
||||
eSamplerBlockMatchWindowCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM,
|
||||
eSamplerCubicWeightsCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM,
|
||||
ePhysicalDeviceCubicWeightsFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM,
|
||||
eBlitImageCubicWeightsInfoQCOM = VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM,
|
||||
ePhysicalDeviceYcbcrDegammaFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM,
|
||||
eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM,
|
||||
ePhysicalDeviceCubicClampFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM,
|
||||
ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT,
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
eScreenBufferPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX,
|
||||
eScreenBufferFormatPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX,
|
||||
eImportScreenBufferInfoQNX = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX,
|
||||
eExternalFormatQNX = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX,
|
||||
ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX
|
||||
ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
ePhysicalDeviceLayeredDriverPropertiesMSFT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT,
|
||||
ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV
|
||||
};
|
||||
|
||||
enum class PipelineCacheHeaderVersion
|
||||
|
@ -1843,6 +2080,20 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceCreateFlags allFlags = {};
|
||||
};
|
||||
|
||||
enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags
|
||||
{
|
||||
eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
|
||||
};
|
||||
|
||||
using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<DeviceQueueCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = DeviceQueueCreateFlagBits::eProtected;
|
||||
};
|
||||
|
||||
enum class PipelineStageFlagBits : VkPipelineStageFlags
|
||||
{
|
||||
eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
||||
|
@ -2306,6 +2557,21 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderModuleCreateFlags allFlags = {};
|
||||
};
|
||||
|
||||
enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags
|
||||
{
|
||||
eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
|
||||
eExternallySynchronizedEXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT
|
||||
};
|
||||
|
||||
using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<PipelineCacheCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = PipelineCacheCreateFlagBits::eExternallySynchronized;
|
||||
};
|
||||
|
||||
enum class BlendFactor
|
||||
{
|
||||
eZero = VK_BLEND_FACTOR_ZERO,
|
||||
|
@ -2720,6 +2986,41 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
|
||||
};
|
||||
|
||||
enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags
|
||||
{
|
||||
eRasterizationOrderAttachmentAccessARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM,
|
||||
eRasterizationOrderAttachmentAccessEXT = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT
|
||||
};
|
||||
|
||||
using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<PipelineColorBlendStateCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineColorBlendStateCreateFlags allFlags =
|
||||
PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT;
|
||||
};
|
||||
|
||||
enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags
|
||||
{
|
||||
eRasterizationOrderAttachmentDepthAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM,
|
||||
eRasterizationOrderAttachmentStencilAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM,
|
||||
eRasterizationOrderAttachmentDepthAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT,
|
||||
eRasterizationOrderAttachmentStencilAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT
|
||||
};
|
||||
|
||||
using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<PipelineDepthStencilStateCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDepthStencilStateCreateFlags allFlags =
|
||||
PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT |
|
||||
PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT;
|
||||
};
|
||||
|
||||
enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags
|
||||
{
|
||||
};
|
||||
|
@ -2746,6 +3047,20 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineInputAssemblyStateCreateFlags allFlags = {};
|
||||
};
|
||||
|
||||
enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags
|
||||
{
|
||||
eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT
|
||||
};
|
||||
|
||||
using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<PipelineLayoutCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT;
|
||||
};
|
||||
|
||||
enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags
|
||||
{
|
||||
};
|
||||
|
@ -2869,11 +3184,13 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
|
||||
enum class DescriptorPoolCreateFlagBits : VkDescriptorPoolCreateFlags
|
||||
{
|
||||
eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
|
||||
eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
|
||||
eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT,
|
||||
eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE,
|
||||
eHostOnlyEXT = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT
|
||||
eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
|
||||
eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
|
||||
eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT,
|
||||
eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE,
|
||||
eHostOnlyEXT = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT,
|
||||
eAllowOverallocationSetsNV = VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV,
|
||||
eAllowOverallocationPoolsNV = VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV
|
||||
};
|
||||
|
||||
using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits>;
|
||||
|
@ -2883,7 +3200,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolCreateFlags allFlags =
|
||||
DescriptorPoolCreateFlagBits::eFreeDescriptorSet | DescriptorPoolCreateFlagBits::eUpdateAfterBind | DescriptorPoolCreateFlagBits::eHostOnlyEXT;
|
||||
DescriptorPoolCreateFlagBits::eFreeDescriptorSet | DescriptorPoolCreateFlagBits::eUpdateAfterBind | DescriptorPoolCreateFlagBits::eHostOnlyEXT |
|
||||
DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV | DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV;
|
||||
};
|
||||
|
||||
enum class DescriptorSetLayoutCreateFlagBits : VkDescriptorSetLayoutCreateFlags
|
||||
|
@ -3232,8 +3550,9 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
|
||||
enum class SubpassContents
|
||||
{
|
||||
eInline = VK_SUBPASS_CONTENTS_INLINE,
|
||||
eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
|
||||
eInline = VK_SUBPASS_CONTENTS_INLINE,
|
||||
eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
|
||||
eInlineAndSecondaryCommandBuffersEXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT
|
||||
};
|
||||
|
||||
//=== VK_VERSION_1_1 ===
|
||||
|
@ -3330,20 +3649,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
};
|
||||
using TessellationDomainOriginKHR = TessellationDomainOrigin;
|
||||
|
||||
enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags
|
||||
{
|
||||
eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
|
||||
};
|
||||
|
||||
using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<DeviceQueueCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = DeviceQueueCreateFlagBits::eProtected;
|
||||
};
|
||||
|
||||
enum class SamplerYcbcrModelConversion
|
||||
{
|
||||
eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
|
||||
|
@ -3605,7 +3910,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
eMesaVenus = VK_DRIVER_ID_MESA_VENUS,
|
||||
eMesaDozen = VK_DRIVER_ID_MESA_DOZEN,
|
||||
eMesaNvk = VK_DRIVER_ID_MESA_NVK,
|
||||
eImaginationOpenSourceMESA = VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA
|
||||
eImaginationOpenSourceMESA = VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA,
|
||||
eMesaAgxv = VK_DRIVER_ID_MESA_AGXV
|
||||
};
|
||||
using DriverIdKHR = DriverId;
|
||||
|
||||
|
@ -3644,7 +3950,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
eSampleZero = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
|
||||
eAverage = VK_RESOLVE_MODE_AVERAGE_BIT,
|
||||
eMin = VK_RESOLVE_MODE_MIN_BIT,
|
||||
eMax = VK_RESOLVE_MODE_MAX_BIT
|
||||
eMax = VK_RESOLVE_MODE_MAX_BIT,
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
eExternalFormatDownsampleANDROID = VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
};
|
||||
using ResolveModeFlagBitsKHR = ResolveModeFlagBits;
|
||||
|
||||
|
@ -3655,15 +3964,20 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
struct FlagTraits<ResolveModeFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags =
|
||||
ResolveModeFlagBits::eNone | ResolveModeFlagBits::eSampleZero | ResolveModeFlagBits::eAverage | ResolveModeFlagBits::eMin | ResolveModeFlagBits::eMax;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags = ResolveModeFlagBits::eNone | ResolveModeFlagBits::eSampleZero |
|
||||
ResolveModeFlagBits::eAverage | ResolveModeFlagBits::eMin | ResolveModeFlagBits::eMax
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
| ResolveModeFlagBits::eExternalFormatDownsampleANDROID
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
;
|
||||
};
|
||||
|
||||
enum class SamplerReductionMode
|
||||
{
|
||||
eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
|
||||
eMin = VK_SAMPLER_REDUCTION_MODE_MIN,
|
||||
eMax = VK_SAMPLER_REDUCTION_MODE_MAX
|
||||
eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
|
||||
eMin = VK_SAMPLER_REDUCTION_MODE_MIN,
|
||||
eMax = VK_SAMPLER_REDUCTION_MODE_MAX,
|
||||
eWeightedAverageRangeclampQCOM = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM
|
||||
};
|
||||
using SamplerReductionModeEXT = SamplerReductionMode;
|
||||
|
||||
|
@ -3933,6 +4247,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
eContentsSecondaryCommandBuffers = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT,
|
||||
eSuspending = VK_RENDERING_SUSPENDING_BIT,
|
||||
eResuming = VK_RENDERING_RESUMING_BIT,
|
||||
eContentsInlineEXT = VK_RENDERING_CONTENTS_INLINE_BIT_EXT,
|
||||
eEnableLegacyDitheringEXT = VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT
|
||||
};
|
||||
using RenderingFlagBitsKHR = RenderingFlagBits;
|
||||
|
@ -3945,7 +4260,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingFlags allFlags = RenderingFlagBits::eContentsSecondaryCommandBuffers | RenderingFlagBits::eSuspending |
|
||||
RenderingFlagBits::eResuming | RenderingFlagBits::eEnableLegacyDitheringEXT;
|
||||
RenderingFlagBits::eResuming | RenderingFlagBits::eContentsInlineEXT |
|
||||
RenderingFlagBits::eEnableLegacyDitheringEXT;
|
||||
};
|
||||
|
||||
enum class FormatFeatureFlagBits2 : VkFormatFeatureFlags2
|
||||
|
@ -4487,7 +4803,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{
|
||||
eError = VK_QUERY_RESULT_STATUS_ERROR_KHR,
|
||||
eNotReady = VK_QUERY_RESULT_STATUS_NOT_READY_KHR,
|
||||
eComplete = VK_QUERY_RESULT_STATUS_COMPLETE_KHR
|
||||
eComplete = VK_QUERY_RESULT_STATUS_COMPLETE_KHR,
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
eInsufficientBitstreamBufferRange = VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
};
|
||||
|
||||
enum class VideoSessionParametersCreateFlagBitsKHR : VkVideoSessionParametersCreateFlagsKHR
|
||||
|
@ -4642,7 +4961,9 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
eConstrainedIntraPredFlagSet = VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT,
|
||||
eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT,
|
||||
eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT,
|
||||
eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT
|
||||
eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT,
|
||||
eSliceQpDelta = VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT,
|
||||
eDifferentSliceQpDelta = VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT
|
||||
};
|
||||
|
||||
using VideoEncodeH264StdFlagsEXT = Flags<VideoEncodeH264StdFlagBitsEXT>;
|
||||
|
@ -4660,7 +4981,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
VideoEncodeH264StdFlagBitsEXT::eDirectSpatialMvPredFlagUnset | VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagUnset |
|
||||
VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagSet | VideoEncodeH264StdFlagBitsEXT::eDirect8X8InferenceFlagUnset |
|
||||
VideoEncodeH264StdFlagBitsEXT::eConstrainedIntraPredFlagSet | VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterDisabled |
|
||||
VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled | VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial;
|
||||
VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled | VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial |
|
||||
VideoEncodeH264StdFlagBitsEXT::eSliceQpDelta | VideoEncodeH264StdFlagBitsEXT::eDifferentSliceQpDelta;
|
||||
};
|
||||
|
||||
enum class VideoEncodeH264RateControlFlagBitsEXT : VkVideoEncodeH264RateControlFlagsEXT
|
||||
|
@ -4736,7 +5058,9 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
eEntropyCodingSyncEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT,
|
||||
eDeblockingFilterOverrideEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT,
|
||||
eDependentSliceSegmentsEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT,
|
||||
eDependentSliceSegmentFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT
|
||||
eDependentSliceSegmentFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT,
|
||||
eSliceQpDelta = VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT,
|
||||
eDifferentSliceQpDelta = VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT
|
||||
};
|
||||
|
||||
using VideoEncodeH265StdFlagsEXT = Flags<VideoEncodeH265StdFlagBitsEXT>;
|
||||
|
@ -4755,7 +5079,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
VideoEncodeH265StdFlagBitsEXT::ePpsSliceChromaQpOffsetsPresentFlagSet | VideoEncodeH265StdFlagBitsEXT::eTransquantBypassEnabledFlagSet |
|
||||
VideoEncodeH265StdFlagBitsEXT::eConstrainedIntraPredFlagSet | VideoEncodeH265StdFlagBitsEXT::eEntropyCodingSyncEnabledFlagSet |
|
||||
VideoEncodeH265StdFlagBitsEXT::eDeblockingFilterOverrideEnabledFlagSet | VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentsEnabledFlagSet |
|
||||
VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet;
|
||||
VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet | VideoEncodeH265StdFlagBitsEXT::eSliceQpDelta |
|
||||
VideoEncodeH265StdFlagBitsEXT::eDifferentSliceQpDelta;
|
||||
};
|
||||
|
||||
enum class VideoEncodeH265CtbSizeFlagBitsEXT : VkVideoEncodeH265CtbSizeFlagsEXT
|
||||
|
@ -5896,29 +6221,13 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceMemoryReportFlagsEXT allFlags = {};
|
||||
};
|
||||
|
||||
//=== VK_EXT_pipeline_creation_cache_control ===
|
||||
|
||||
enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags
|
||||
{
|
||||
eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
|
||||
eExternallySynchronizedEXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT
|
||||
};
|
||||
|
||||
using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<PipelineCacheCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = PipelineCacheCreateFlagBits::eExternallySynchronized;
|
||||
};
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_KHR_video_encode_queue ===
|
||||
|
||||
enum class VideoEncodeCapabilityFlagBitsKHR : VkVideoEncodeCapabilityFlagsKHR
|
||||
{
|
||||
ePrecedingExternallyEncodedBytes = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR
|
||||
ePrecedingExternallyEncodedBytes = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR,
|
||||
eInsufficientstreamBufferRangeDetectionBit = VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR
|
||||
};
|
||||
|
||||
using VideoEncodeCapabilityFlagsKHR = Flags<VideoEncodeCapabilityFlagBitsKHR>;
|
||||
|
@ -5927,7 +6236,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
struct FlagTraits<VideoEncodeCapabilityFlagBitsKHR>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeCapabilityFlagsKHR allFlags = VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeCapabilityFlagsKHR allFlags =
|
||||
VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes | VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit;
|
||||
};
|
||||
|
||||
enum class VideoEncodeFeedbackFlagBitsKHR : VkVideoEncodeFeedbackFlagsKHR
|
||||
|
@ -6109,20 +6419,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader | GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface;
|
||||
};
|
||||
|
||||
enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags
|
||||
{
|
||||
eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT
|
||||
};
|
||||
|
||||
using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<PipelineLayoutCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT;
|
||||
};
|
||||
|
||||
//=== VK_NV_fragment_shading_rate_enums ===
|
||||
|
||||
enum class FragmentShadingRateNV
|
||||
|
@ -6345,6 +6641,22 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
};
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
//=== VK_EXT_frame_boundary ===
|
||||
|
||||
enum class FrameBoundaryFlagBitsEXT : VkFrameBoundaryFlagsEXT
|
||||
{
|
||||
eFrameEnd = VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT
|
||||
};
|
||||
|
||||
using FrameBoundaryFlagsEXT = Flags<FrameBoundaryFlagBitsEXT>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<FrameBoundaryFlagBitsEXT>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR FrameBoundaryFlagsEXT allFlags = FrameBoundaryFlagBitsEXT::eFrameEnd;
|
||||
};
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_screen_surface ===
|
||||
|
||||
|
@ -6498,43 +6810,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
static VULKAN_HPP_CONST_OR_CONSTEXPR DirectDriverLoadingFlagsLUNARG allFlags = {};
|
||||
};
|
||||
|
||||
//=== VK_EXT_rasterization_order_attachment_access ===
|
||||
|
||||
enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags
|
||||
{
|
||||
eRasterizationOrderAttachmentAccessARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM,
|
||||
eRasterizationOrderAttachmentAccessEXT = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT
|
||||
};
|
||||
|
||||
using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<PipelineColorBlendStateCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineColorBlendStateCreateFlags allFlags =
|
||||
PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT;
|
||||
};
|
||||
|
||||
enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags
|
||||
{
|
||||
eRasterizationOrderAttachmentDepthAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM,
|
||||
eRasterizationOrderAttachmentStencilAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM,
|
||||
eRasterizationOrderAttachmentDepthAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT,
|
||||
eRasterizationOrderAttachmentStencilAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT
|
||||
};
|
||||
|
||||
using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits>;
|
||||
|
||||
template <>
|
||||
struct FlagTraits<PipelineDepthStencilStateCreateFlagBits>
|
||||
{
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDepthStencilStateCreateFlags allFlags =
|
||||
PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT |
|
||||
PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT;
|
||||
};
|
||||
|
||||
//=== VK_NV_optical_flow ===
|
||||
|
||||
enum class OpticalFlowUsageFlagBitsNV : VkOpticalFlowUsageFlagsNV
|
||||
|
@ -6793,6 +7068,30 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
eReorder = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV
|
||||
};
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
|
||||
enum class LatencyMarkerNV
|
||||
{
|
||||
eSimulationStart = VK_LATENCY_MARKER_SIMULATION_START_NV,
|
||||
eSimulationEnd = VK_LATENCY_MARKER_SIMULATION_END_NV,
|
||||
eRendersubmitStart = VK_LATENCY_MARKER_RENDERSUBMIT_START_NV,
|
||||
eRendersubmitEnd = VK_LATENCY_MARKER_RENDERSUBMIT_END_NV,
|
||||
ePresentStart = VK_LATENCY_MARKER_PRESENT_START_NV,
|
||||
ePresentEnd = VK_LATENCY_MARKER_PRESENT_END_NV,
|
||||
eInputSample = VK_LATENCY_MARKER_INPUT_SAMPLE_NV,
|
||||
eTriggerFlash = VK_LATENCY_MARKER_TRIGGER_FLASH_NV,
|
||||
eOutOfBandRendersubmitStart = VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV,
|
||||
eOutOfBandRendersubmitEnd = VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV,
|
||||
eOutOfBandPresentStart = VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV,
|
||||
eOutOfBandPresentEnd = VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV
|
||||
};
|
||||
|
||||
enum class OutOfBandQueueTypeNV
|
||||
{
|
||||
eRender = VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV,
|
||||
ePresent = VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV
|
||||
};
|
||||
|
||||
//=== VK_KHR_cooperative_matrix ===
|
||||
|
||||
enum class ScopeKHR
|
||||
|
@ -6820,6 +7119,32 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
};
|
||||
using ComponentTypeNV = ComponentTypeKHR;
|
||||
|
||||
//=== VK_QCOM_image_processing2 ===
|
||||
|
||||
enum class BlockMatchWindowCompareModeQCOM
|
||||
{
|
||||
eMin = VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM,
|
||||
eMax = VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM
|
||||
};
|
||||
|
||||
//=== VK_QCOM_filter_cubic_weights ===
|
||||
|
||||
enum class CubicFilterWeightsQCOM
|
||||
{
|
||||
eCatmullRom = VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM,
|
||||
eZeroTangentCardinal = VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM,
|
||||
eBSpline = VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM,
|
||||
eMitchellNetravali = VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM
|
||||
};
|
||||
|
||||
//=== VK_MSFT_layered_driver ===
|
||||
|
||||
enum class LayeredDriverUnderlyingApiMSFT
|
||||
{
|
||||
eNone = VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT,
|
||||
eD3D12 = VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT
|
||||
};
|
||||
|
||||
//=========================
|
||||
//=== Index Type Traits ===
|
||||
//=========================
|
||||
|
@ -6865,5 +7190,124 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
using Type = uint8_t;
|
||||
};
|
||||
|
||||
//===========================================================
|
||||
//=== Mapping from ObjectType to DebugReportObjectTypeEXT ===
|
||||
//===========================================================
|
||||
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType( VULKAN_HPP_NAMESPACE::ObjectType objectType )
|
||||
{
|
||||
switch ( objectType )
|
||||
{
|
||||
//=== VK_VERSION_1_0 ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eInstance: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDevice: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eQueue: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eFence: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eEvent: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eBuffer: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eBufferView: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eImage: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eImageView: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::ePipeline: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eSampler: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
|
||||
|
||||
//=== VK_VERSION_1_1 ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
|
||||
|
||||
//=== VK_VERSION_1_3 ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
|
||||
//=== VK_KHR_surface ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
|
||||
|
||||
//=== VK_KHR_swapchain ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
|
||||
|
||||
//=== VK_KHR_display ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
|
||||
|
||||
//=== VK_EXT_debug_report ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
|
||||
|
||||
//=== VK_KHR_video_queue ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
|
||||
//=== VK_NVX_binary_import ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
|
||||
|
||||
//=== VK_EXT_debug_utils ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
|
||||
//=== VK_KHR_acceleration_structure ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
|
||||
|
||||
//=== VK_EXT_validation_cache ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
|
||||
|
||||
//=== VK_NV_ray_tracing ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
|
||||
|
||||
//=== VK_INTEL_performance_query ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
|
||||
//=== VK_KHR_deferred_host_operations ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
|
||||
//=== VK_NV_device_generated_commands ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||
//=== VK_FUCHSIA_buffer_collection ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
//=== VK_EXT_opacity_micromap ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
|
||||
//=== VK_NV_optical_flow ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV:
|
||||
return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
|
||||
//=== VK_EXT_shader_object ===
|
||||
case VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
|
||||
default: VULKAN_HPP_ASSERT( false && "unknown ObjectType" ); return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
#endif
|
||||
|
|
|
@ -343,6 +343,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_HUAWEI_invocation_mask",
|
||||
"VK_NV_external_memory_rdma",
|
||||
"VK_EXT_pipeline_properties",
|
||||
"VK_EXT_frame_boundary",
|
||||
"VK_EXT_multisampled_render_to_single_sampled",
|
||||
"VK_EXT_extended_dynamic_state2",
|
||||
"VK_EXT_color_write_enable",
|
||||
|
@ -374,6 +375,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_NV_linear_color_attachment",
|
||||
"VK_EXT_image_compression_control_swapchain",
|
||||
"VK_QCOM_image_processing",
|
||||
"VK_EXT_nested_command_buffer",
|
||||
"VK_EXT_external_memory_acquire_unmodified",
|
||||
"VK_EXT_extended_dynamic_state3",
|
||||
"VK_EXT_subpass_merge_feedback",
|
||||
|
@ -381,7 +383,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_EXT_rasterization_order_attachment_access",
|
||||
"VK_NV_optical_flow",
|
||||
"VK_EXT_legacy_dithering",
|
||||
"VK_EXT_pipeline_protected_access",
|
||||
"VK_EXT_pipeline_protected_access",
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
"VK_ANDROID_external_format_resolve",
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
"VK_KHR_maintenance5",
|
||||
"VK_KHR_ray_tracing_position_fetch",
|
||||
"VK_EXT_shader_object",
|
||||
|
@ -389,17 +394,24 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
"VK_SEC_amigo_profiling",
|
||||
"VK_QCOM_multiview_per_view_viewports",
|
||||
"VK_NV_ray_tracing_invocation_reorder",
|
||||
"VK_NV_extended_sparse_address_space",
|
||||
"VK_EXT_mutable_descriptor_type",
|
||||
"VK_ARM_shader_core_builtins",
|
||||
"VK_EXT_pipeline_library_group_handles",
|
||||
"VK_EXT_dynamic_rendering_unused_attachments",
|
||||
"VK_NV_low_latency2",
|
||||
"VK_KHR_cooperative_matrix",
|
||||
"VK_QCOM_multiview_per_view_render_areas",
|
||||
"VK_QCOM_image_processing2",
|
||||
"VK_QCOM_filter_cubic_weights",
|
||||
"VK_QCOM_ycbcr_degamma",
|
||||
"VK_QCOM_filter_cubic_clamp",
|
||||
"VK_EXT_attachment_feedback_loop_dynamic_state",
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
"VK_QNX_external_memory_screen_buffer"
|
||||
"VK_QNX_external_memory_screen_buffer",
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
};
|
||||
"VK_MSFT_layered_driver",
|
||||
"VK_NV_descriptor_pool_overallocation" };
|
||||
return deviceExtensions;
|
||||
}
|
||||
|
||||
|
@ -773,6 +785,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_GOOGLE_surfaceless_query", { { "VK_VERSION_1_0", { { "VK_KHR_surface", } } } } },
|
||||
{ "VK_EXT_image_compression_control_swapchain", { { "VK_VERSION_1_0", { { "VK_EXT_image_compression_control", } } } } },
|
||||
{ "VK_QCOM_image_processing", { { "VK_VERSION_1_0", { { "VK_KHR_format_feature_flags2", } } } } },
|
||||
{ "VK_EXT_nested_command_buffer", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
|
||||
{ "VK_EXT_external_memory_acquire_unmodified", { { "VK_VERSION_1_0", { { "VK_KHR_external_memory", } } } } },
|
||||
{ "VK_EXT_extended_dynamic_state3", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
|
||||
{ "VK_EXT_subpass_merge_feedback", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
|
||||
|
@ -780,7 +793,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_rasterization_order_attachment_access", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
|
||||
{ "VK_NV_optical_flow", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", "VK_KHR_format_feature_flags2", "VK_KHR_synchronization2", } } } } },
|
||||
{ "VK_EXT_legacy_dithering", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
|
||||
{ "VK_EXT_pipeline_protected_access", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
|
||||
{ "VK_EXT_pipeline_protected_access", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
{ "VK_ANDROID_external_format_resolve", { { "VK_VERSION_1_0", { { "VK_ANDROID_external_memory_android_hardware_buffer", } } } } },
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
{ "VK_KHR_maintenance5", { { "VK_VERSION_1_1", { { "VK_KHR_dynamic_rendering", } } } } },
|
||||
{ "VK_KHR_ray_tracing_position_fetch", { { "VK_VERSION_1_0", { { "VK_KHR_acceleration_structure", } } } } },
|
||||
{ "VK_EXT_shader_object", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", "VK_KHR_dynamic_rendering", } } }, { "VK_VERSION_1_1", { { "VK_KHR_dynamic_rendering", } } }, { "VK_VERSION_1_3", { { } } } } },
|
||||
|
@ -793,11 +809,15 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{ "VK_EXT_pipeline_library_group_handles", { { "VK_VERSION_1_0", { { "VK_KHR_ray_tracing_pipeline", "VK_KHR_pipeline_library", } } } } },
|
||||
{ "VK_EXT_dynamic_rendering_unused_attachments", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", "VK_KHR_dynamic_rendering", } } }, { "VK_VERSION_1_1", { { "VK_KHR_dynamic_rendering", } } }, { "VK_VERSION_1_3", { { } } } } },
|
||||
{ "VK_KHR_cooperative_matrix", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
|
||||
{ "VK_QCOM_image_processing2", { { "VK_VERSION_1_0", { { "VK_QCOM_image_processing", } } } } },
|
||||
{ "VK_QCOM_filter_cubic_weights", { { "VK_VERSION_1_0", { { "VK_EXT_filter_cubic", } } } } },
|
||||
{ "VK_QCOM_filter_cubic_clamp", { { "VK_VERSION_1_0", { { "VK_EXT_filter_cubic", "VK_EXT_sampler_filter_minmax", } } }, { "VK_VERSION_1_2", { { "VK_EXT_filter_cubic", } } } } },
|
||||
{ "VK_EXT_attachment_feedback_loop_dynamic_state", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", "VK_EXT_attachment_feedback_loop_layout", } } } } },
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
{ "VK_QNX_external_memory_screen_buffer", { { "VK_VERSION_1_0", { { "VK_KHR_sampler_ycbcr_conversion", "VK_KHR_external_memory", "VK_KHR_dedicated_allocation", } } }, { "VK_VERSION_1_1", { { "VK_EXT_queue_family_foreign", } } } } }
|
||||
{ "VK_QNX_external_memory_screen_buffer", { { "VK_VERSION_1_0", { { "VK_KHR_sampler_ycbcr_conversion", "VK_KHR_external_memory", "VK_KHR_dedicated_allocation", } } }, { "VK_VERSION_1_1", { { "VK_EXT_queue_family_foreign", } } } } },
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
};
|
||||
{ "VK_MSFT_layered_driver", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } } } },
|
||||
{ "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { { } } } } } };
|
||||
auto depIt = dependencies.find( extension );
|
||||
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
|
||||
}
|
||||
|
@ -1486,11 +1506,12 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
( extension == "VK_FUCHSIA_buffer_collection" )
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|| ( extension == "VK_HUAWEI_subpass_shading" ) || ( extension == "VK_HUAWEI_invocation_mask" ) || ( extension == "VK_NV_external_memory_rdma" ) ||
|
||||
( extension == "VK_EXT_pipeline_properties" ) || ( extension == "VK_EXT_multisampled_render_to_single_sampled" ) ||
|
||||
( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_color_write_enable" ) ||
|
||||
( extension == "VK_EXT_primitives_generated_query" ) || ( extension == "VK_KHR_ray_tracing_maintenance1" ) ||
|
||||
( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) ||
|
||||
( extension == "VK_EXT_image_2d_view_of_3d" ) || ( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" )
|
||||
( extension == "VK_EXT_pipeline_properties" ) || ( extension == "VK_EXT_frame_boundary" ) ||
|
||||
( extension == "VK_EXT_multisampled_render_to_single_sampled" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
|
||||
( extension == "VK_EXT_color_write_enable" ) || ( extension == "VK_EXT_primitives_generated_query" ) ||
|
||||
( extension == "VK_KHR_ray_tracing_maintenance1" ) || ( extension == "VK_EXT_global_priority_query" ) ||
|
||||
( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) || ( extension == "VK_EXT_image_2d_view_of_3d" ) ||
|
||||
( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" )
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
|| ( extension == "VK_NV_displacement_micromap" )
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
@ -1502,20 +1523,26 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_NV_memory_decompression" ) ||
|
||||
( extension == "VK_NV_device_generated_commands_compute" ) || ( extension == "VK_NV_linear_color_attachment" ) ||
|
||||
( extension == "VK_EXT_image_compression_control_swapchain" ) || ( extension == "VK_QCOM_image_processing" ) ||
|
||||
( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) ||
|
||||
( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_EXT_shader_module_identifier" ) ||
|
||||
( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) ||
|
||||
( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
|
||||
( extension == "VK_KHR_ray_tracing_position_fetch" ) || ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_QCOM_tile_properties" ) ||
|
||||
( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
|
||||
( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) ||
|
||||
( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
|
||||
( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_KHR_cooperative_matrix" ) ||
|
||||
( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" )
|
||||
( extension == "VK_EXT_nested_command_buffer" ) || ( extension == "VK_EXT_external_memory_acquire_unmodified" ) ||
|
||||
( extension == "VK_EXT_extended_dynamic_state3" ) || ( extension == "VK_EXT_subpass_merge_feedback" ) ||
|
||||
( extension == "VK_EXT_shader_module_identifier" ) || ( extension == "VK_EXT_rasterization_order_attachment_access" ) ||
|
||||
( extension == "VK_NV_optical_flow" ) || ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" )
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
|| ( extension == "VK_ANDROID_external_format_resolve" )
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|| ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) || ( extension == "VK_EXT_shader_object" ) ||
|
||||
( extension == "VK_QCOM_tile_properties" ) || ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
|
||||
( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_extended_sparse_address_space" ) ||
|
||||
( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_ARM_shader_core_builtins" ) ||
|
||||
( extension == "VK_EXT_pipeline_library_group_handles" ) || ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) ||
|
||||
( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) ||
|
||||
( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_QCOM_image_processing2" ) ||
|
||||
( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) ||
|
||||
( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" )
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
|| ( extension == "VK_QNX_external_memory_screen_buffer" )
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
;
|
||||
|| ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_NV_descriptor_pool_overallocation" );
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
|
||||
|
|
131
thirdparty/vulkan/include/vulkan/vulkan_funcs.hpp
vendored
131
thirdparty/vulkan/include/vulkan/vulkan_funcs.hpp
vendored
|
@ -19495,6 +19495,17 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
|
||||
size_t dataSize,
|
||||
void * pDescriptor,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
|
||||
d.vkGetDescriptorEXT( m_device, reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), dataSize, pDescriptor );
|
||||
}
|
||||
|
||||
template <typename DescriptorType, typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorType Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
|
@ -22786,6 +22797,126 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
return static_cast<Result>(
|
||||
d.vkSetLatencySleepModeNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( pSleepModeInfo ) ) );
|
||||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo,
|
||||
Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
|
||||
VkResult result =
|
||||
d.vkSetLatencySleepModeNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( &sleepModeInfo ) );
|
||||
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setLatencySleepModeNV" );
|
||||
|
||||
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ) );
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
return static_cast<Result>(
|
||||
d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( pSleepInfo ) ) );
|
||||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<void>::type
|
||||
Device::latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo, Dispatch const & d ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
|
||||
VkResult result = d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( &sleepInfo ) );
|
||||
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::latencySleepNV" );
|
||||
|
||||
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ) );
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
d.vkSetLatencyMarkerNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( pLatencyMarkerInfo ) );
|
||||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
|
||||
d.vkSetLatencyMarkerNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
uint32_t * pTimingCount,
|
||||
VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
d.vkGetLatencyTimingsNV(
|
||||
m_device, static_cast<VkSwapchainKHR>( swapchain ), pTimingCount, reinterpret_cast<VkGetLatencyMarkerInfoNV *>( pLatencyMarkerInfo ) );
|
||||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
|
||||
Device::getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
|
||||
std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> data_;
|
||||
uint32_t & timingCount = data_.first;
|
||||
VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV & latencyMarkerInfo = data_.second;
|
||||
d.vkGetLatencyTimingsNV(
|
||||
m_device, static_cast<VkSwapchainKHR>( swapchain ), &timingCount, reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
|
||||
|
||||
return data_;
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
d.vkQueueNotifyOutOfBandNV( m_queue, reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( pQueueTypeInfo ) );
|
||||
}
|
||||
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo,
|
||||
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
|
||||
|
||||
d.vkQueueNotifyOutOfBandNV( m_queue, reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( &queueTypeInfo ) );
|
||||
}
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_KHR_cooperative_matrix ===
|
||||
|
||||
template <typename Dispatch>
|
||||
|
|
116
thirdparty/vulkan/include/vulkan/vulkan_handles.hpp
vendored
116
thirdparty/vulkan/include/vulkan/vulkan_handles.hpp
vendored
|
@ -1438,6 +1438,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
struct PipelinePropertiesIdentifierEXT;
|
||||
struct PhysicalDevicePipelinePropertiesFeaturesEXT;
|
||||
|
||||
//=== VK_EXT_frame_boundary ===
|
||||
struct PhysicalDeviceFrameBoundaryFeaturesEXT;
|
||||
struct FrameBoundaryEXT;
|
||||
|
||||
//=== VK_EXT_multisampled_render_to_single_sampled ===
|
||||
struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
|
||||
struct SubpassResolvePerformanceQueryEXT;
|
||||
|
@ -1562,6 +1566,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
struct PhysicalDeviceImageProcessingFeaturesQCOM;
|
||||
struct PhysicalDeviceImageProcessingPropertiesQCOM;
|
||||
|
||||
//=== VK_EXT_nested_command_buffer ===
|
||||
struct PhysicalDeviceNestedCommandBufferFeaturesEXT;
|
||||
struct PhysicalDeviceNestedCommandBufferPropertiesEXT;
|
||||
|
||||
//=== VK_EXT_external_memory_acquire_unmodified ===
|
||||
struct ExternalMemoryAcquireUnmodifiedEXT;
|
||||
|
||||
|
@ -1608,6 +1616,13 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_EXT_pipeline_protected_access ===
|
||||
struct PhysicalDevicePipelineProtectedAccessFeaturesEXT;
|
||||
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
//=== VK_ANDROID_external_format_resolve ===
|
||||
struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;
|
||||
struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;
|
||||
struct AndroidHardwareBufferFormatResolvePropertiesANDROID;
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|
||||
//=== VK_KHR_maintenance5 ===
|
||||
struct PhysicalDeviceMaintenance5FeaturesKHR;
|
||||
struct PhysicalDeviceMaintenance5PropertiesKHR;
|
||||
|
@ -1643,6 +1658,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
|
||||
struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
|
||||
|
||||
//=== VK_NV_extended_sparse_address_space ===
|
||||
struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
|
||||
struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
|
||||
|
||||
//=== VK_EXT_mutable_descriptor_type ===
|
||||
struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
|
||||
using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
|
||||
|
@ -1661,6 +1680,17 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
//=== VK_EXT_dynamic_rendering_unused_attachments ===
|
||||
struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
struct LatencySleepModeInfoNV;
|
||||
struct LatencySleepInfoNV;
|
||||
struct SetLatencyMarkerInfoNV;
|
||||
struct GetLatencyMarkerInfoNV;
|
||||
struct LatencyTimingsFrameReportNV;
|
||||
struct LatencySubmissionPresentIdNV;
|
||||
struct SwapchainLatencyCreateInfoNV;
|
||||
struct OutOfBandQueueTypeInfoNV;
|
||||
struct LatencySurfaceCapabilitiesNV;
|
||||
|
||||
//=== VK_KHR_cooperative_matrix ===
|
||||
struct CooperativeMatrixPropertiesKHR;
|
||||
struct PhysicalDeviceCooperativeMatrixFeaturesKHR;
|
||||
|
@ -1670,6 +1700,23 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
|
||||
struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
|
||||
|
||||
//=== VK_QCOM_image_processing2 ===
|
||||
struct PhysicalDeviceImageProcessing2FeaturesQCOM;
|
||||
struct PhysicalDeviceImageProcessing2PropertiesQCOM;
|
||||
struct SamplerBlockMatchWindowCreateInfoQCOM;
|
||||
|
||||
//=== VK_QCOM_filter_cubic_weights ===
|
||||
struct PhysicalDeviceCubicWeightsFeaturesQCOM;
|
||||
struct SamplerCubicWeightsCreateInfoQCOM;
|
||||
struct BlitImageCubicWeightsInfoQCOM;
|
||||
|
||||
//=== VK_QCOM_ycbcr_degamma ===
|
||||
struct PhysicalDeviceYcbcrDegammaFeaturesQCOM;
|
||||
struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
|
||||
|
||||
//=== VK_QCOM_filter_cubic_clamp ===
|
||||
struct PhysicalDeviceCubicClampFeaturesQCOM;
|
||||
|
||||
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
||||
struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
|
||||
|
||||
|
@ -1682,6 +1729,12 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_MSFT_layered_driver ===
|
||||
struct PhysicalDeviceLayeredDriverPropertiesMSFT;
|
||||
|
||||
//=== VK_NV_descriptor_pool_overallocation ===
|
||||
struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
|
||||
|
||||
//===================================
|
||||
//=== HANDLE forward declarations ===
|
||||
//===================================
|
||||
|
@ -8173,6 +8226,17 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
operator VkQueue() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_queue;
|
||||
|
@ -12363,6 +12427,11 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
void * pDescriptor,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
|
||||
size_t dataSize,
|
||||
void * pDescriptor,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
@ -13117,6 +13186,53 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
typename ResultValueType<void>::type setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD Result latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
typename ResultValueType<void>::type latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
void getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
uint32_t * pTimingCount,
|
||||
VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
VULKAN_HPP_NODISCARD std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
|
||||
getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
|
||||
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
|
||||
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_external_memory_screen_buffer ===
|
||||
|
||||
|
|
436
thirdparty/vulkan/include/vulkan/vulkan_hash.hpp
vendored
436
thirdparty/vulkan/include/vulkan/vulkan_hash.hpp
vendored
|
@ -975,6 +975,23 @@ namespace std
|
|||
};
|
||||
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|
||||
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|
||||
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>
|
||||
|
@ -1555,6 +1572,19 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>
|
||||
{
|
||||
|
@ -4887,6 +4917,27 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
|
||||
{
|
||||
|
@ -5009,6 +5060,45 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>
|
||||
{
|
||||
|
@ -6237,6 +6327,62 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::LayerProperties>
|
||||
{
|
||||
|
@ -6873,6 +7019,19 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
|
||||
{
|
||||
|
@ -7466,6 +7625,33 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM const & physicalDeviceCubicClampFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.cubicRangeClamp );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM const & physicalDeviceCubicWeightsFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.selectableCubicWeights );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>
|
||||
{
|
||||
|
@ -7731,6 +7917,20 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const &
|
||||
physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>
|
||||
{
|
||||
|
@ -8042,6 +8242,37 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & physicalDeviceExtendedSparseAddressSpaceFeaturesNV ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.extendedSparseAddressSpace );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const &
|
||||
physicalDeviceExtendedSparseAddressSpacePropertiesNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseAddressSpaceSize );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseImageUsageFlags );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseBufferUsageFlags );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo>
|
||||
{
|
||||
|
@ -8070,6 +8301,41 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|
||||
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const &
|
||||
physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo>
|
||||
{
|
||||
|
@ -8427,6 +8693,20 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR>
|
||||
{
|
||||
|
@ -8641,6 +8921,34 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM const & physicalDeviceImageProcessing2FeaturesQCOM ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.textureBlockMatch2 );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM const & physicalDeviceImageProcessing2PropertiesQCOM ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.maxBlockMatchWindow );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM>
|
||||
{
|
||||
|
@ -8819,6 +9127,20 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT>
|
||||
{
|
||||
|
@ -9425,6 +9747,36 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT const & physicalDeviceNestedCommandBufferFeaturesEXT ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBuffer );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferRendering );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferSimultaneousUse );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT const & physicalDeviceNestedCommandBufferPropertiesEXT ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.maxCommandBufferNestingLevel );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT>
|
||||
{
|
||||
|
@ -11536,6 +11888,20 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM const & physicalDeviceYcbcrDegammaFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.ycbcrDegamma );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT>
|
||||
{
|
||||
|
@ -13120,6 +13486,21 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM const & samplerBlockMatchWindowCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowExtent );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowCompareMode );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT>
|
||||
{
|
||||
|
@ -13176,6 +13557,19 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM const & samplerCubicWeightsCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.cubicWeights );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo>
|
||||
{
|
||||
|
@ -13236,6 +13630,21 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM )
|
||||
const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableYDegamma );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableCbCrDegamma );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
# if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX>
|
||||
|
@ -13411,6 +13820,20 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
|
||||
{
|
||||
|
@ -14027,6 +14450,19 @@ namespace std
|
|||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext );
|
||||
VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable );
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV>
|
||||
{
|
||||
|
|
270
thirdparty/vulkan/include/vulkan/vulkan_hpp_macros.hpp
vendored
Normal file
270
thirdparty/vulkan/include/vulkan/vulkan_hpp_macros.hpp
vendored
Normal file
|
@ -0,0 +1,270 @@
|
|||
// Copyright 2015-2023 The Khronos Group Inc.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
//
|
||||
|
||||
// This header is generated from the Khronos Vulkan XML API Registry.
|
||||
|
||||
#ifndef VULKAN_HPP_MACROS_HPP
|
||||
#define VULKAN_HPP_MACROS_HPP
|
||||
|
||||
#if defined( _MSVC_LANG )
|
||||
# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
|
||||
#else
|
||||
# define VULKAN_HPP_CPLUSPLUS __cplusplus
|
||||
#endif
|
||||
|
||||
#if 201703L < VULKAN_HPP_CPLUSPLUS
|
||||
# define VULKAN_HPP_CPP_VERSION 20
|
||||
#elif 201402L < VULKAN_HPP_CPLUSPLUS
|
||||
# define VULKAN_HPP_CPP_VERSION 17
|
||||
#elif 201103L < VULKAN_HPP_CPLUSPLUS
|
||||
# define VULKAN_HPP_CPP_VERSION 14
|
||||
#elif 199711L < VULKAN_HPP_CPLUSPLUS
|
||||
# define VULKAN_HPP_CPP_VERSION 11
|
||||
#else
|
||||
# error "vulkan.hpp needs at least c++ standard version 11"
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
|
||||
# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||
# define VULKAN_HPP_NO_SMART_HANDLE
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
|
||||
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
|
||||
# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
|
||||
# endif
|
||||
# if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
|
||||
# define VULKAN_HPP_NO_UNION_CONSTRUCTORS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_NO_SETTERS )
|
||||
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
|
||||
# define VULKAN_HPP_NO_STRUCT_SETTERS
|
||||
# endif
|
||||
# if !defined( VULKAN_HPP_NO_UNION_SETTERS )
|
||||
# define VULKAN_HPP_NO_UNION_SETTERS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_ASSERT )
|
||||
# define VULKAN_HPP_ASSERT assert
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
|
||||
# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_STATIC_ASSERT )
|
||||
# define VULKAN_HPP_STATIC_ASSERT static_assert
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
|
||||
# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
|
||||
#endif
|
||||
|
||||
#if !defined( __has_include )
|
||||
# define __has_include( x ) false
|
||||
#endif
|
||||
|
||||
#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
|
||||
# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
|
||||
#endif
|
||||
|
||||
#if ( 201803 <= __cpp_lib_span )
|
||||
# define VULKAN_HPP_SUPPORT_SPAN
|
||||
#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
|
||||
#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
||||
# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
|
||||
# define VULKAN_HPP_TYPESAFE_CONVERSION
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( __GNUC__ )
|
||||
# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
|
||||
# if defined( __clang__ )
|
||||
# if __has_feature( cxx_unrestricted_unions )
|
||||
# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
|
||||
# endif
|
||||
# elif defined( __GNUC__ )
|
||||
# if 40600 <= GCC_VERSION
|
||||
# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
|
||||
# endif
|
||||
# elif defined( _MSC_VER )
|
||||
# if 1900 <= _MSC_VER
|
||||
# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_INLINE )
|
||||
# if defined( __clang__ )
|
||||
# if __has_attribute( always_inline )
|
||||
# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
|
||||
# else
|
||||
# define VULKAN_HPP_INLINE inline
|
||||
# endif
|
||||
# elif defined( __GNUC__ )
|
||||
# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
|
||||
# elif defined( _MSC_VER )
|
||||
# define VULKAN_HPP_INLINE inline
|
||||
# else
|
||||
# define VULKAN_HPP_INLINE inline
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
|
||||
# define VULKAN_HPP_TYPESAFE_EXPLICIT
|
||||
#else
|
||||
# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
|
||||
#endif
|
||||
|
||||
#if defined( __cpp_constexpr )
|
||||
# define VULKAN_HPP_CONSTEXPR constexpr
|
||||
# if 201304 <= __cpp_constexpr
|
||||
# define VULKAN_HPP_CONSTEXPR_14 constexpr
|
||||
# else
|
||||
# define VULKAN_HPP_CONSTEXPR_14
|
||||
# endif
|
||||
# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) )
|
||||
# define VULKAN_HPP_CONSTEXPR_20 constexpr
|
||||
# else
|
||||
# define VULKAN_HPP_CONSTEXPR_20
|
||||
# endif
|
||||
# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
|
||||
#else
|
||||
# define VULKAN_HPP_CONSTEXPR
|
||||
# define VULKAN_HPP_CONSTEXPR_14
|
||||
# define VULKAN_HPP_CONST_OR_CONSTEXPR const
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_CONSTEXPR_INLINE )
|
||||
# if 201606L <= __cpp_inline_variables
|
||||
# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR inline
|
||||
# else
|
||||
# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_NOEXCEPT )
|
||||
# if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
|
||||
# define VULKAN_HPP_NOEXCEPT
|
||||
# else
|
||||
# define VULKAN_HPP_NOEXCEPT noexcept
|
||||
# define VULKAN_HPP_HAS_NOEXCEPT 1
|
||||
# if defined( VULKAN_HPP_NO_EXCEPTIONS )
|
||||
# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
|
||||
# else
|
||||
# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if 14 <= VULKAN_HPP_CPP_VERSION
|
||||
# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
|
||||
#else
|
||||
# define VULKAN_HPP_DEPRECATED( msg )
|
||||
#endif
|
||||
|
||||
#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
|
||||
# define VULKAN_HPP_NODISCARD [[nodiscard]]
|
||||
# if defined( VULKAN_HPP_NO_EXCEPTIONS )
|
||||
# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
|
||||
# else
|
||||
# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
|
||||
# endif
|
||||
#else
|
||||
# define VULKAN_HPP_NODISCARD
|
||||
# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_NAMESPACE )
|
||||
# define VULKAN_HPP_NAMESPACE vk
|
||||
#endif
|
||||
|
||||
#define VULKAN_HPP_STRINGIFY2( text ) #text
|
||||
#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
|
||||
#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
|
||||
|
||||
#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
|
||||
# if defined( VK_NO_PROTOTYPES )
|
||||
# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
|
||||
# else
|
||||
# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_STORAGE_API )
|
||||
# if defined( VULKAN_HPP_STORAGE_SHARED )
|
||||
# if defined( _MSC_VER )
|
||||
# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
|
||||
# define VULKAN_HPP_STORAGE_API __declspec( dllexport )
|
||||
# else
|
||||
# define VULKAN_HPP_STORAGE_API __declspec( dllimport )
|
||||
# endif
|
||||
# elif defined( __clang__ ) || defined( __GNUC__ )
|
||||
# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
|
||||
# define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) )
|
||||
# else
|
||||
# define VULKAN_HPP_STORAGE_API
|
||||
# endif
|
||||
# else
|
||||
# define VULKAN_HPP_STORAGE_API
|
||||
# pragma warning Unknown import / export semantics
|
||||
# endif
|
||||
# else
|
||||
# define VULKAN_HPP_STORAGE_API
|
||||
# endif
|
||||
#endif
|
||||
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
class DispatchLoaderDynamic;
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
|
||||
# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \
|
||||
namespace VULKAN_HPP_NAMESPACE \
|
||||
{ \
|
||||
VULKAN_HPP_STORAGE_API ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
|
||||
}
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
extern VULKAN_HPP_STORAGE_API VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic;
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
# else
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
|
||||
# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
|
||||
# else
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
|
||||
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
|
||||
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
|
||||
#else
|
||||
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
|
||||
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
|
||||
#endif
|
||||
|
||||
#endif
|
262
thirdparty/vulkan/include/vulkan/vulkan_raii.hpp
vendored
262
thirdparty/vulkan/include/vulkan/vulkan_raii.hpp
vendored
|
@ -1663,6 +1663,13 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
vkGetDynamicRenderingTilePropertiesQCOM =
|
||||
PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) );
|
||||
vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) );
|
||||
vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) );
|
||||
vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) );
|
||||
vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) );
|
||||
|
||||
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
||||
vkCmdSetAttachmentFeedbackLoopEnableEXT =
|
||||
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) );
|
||||
|
@ -2507,6 +2514,13 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
|
||||
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0;
|
||||
PFN_vkLatencySleepNV vkLatencySleepNV = 0;
|
||||
PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0;
|
||||
PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0;
|
||||
PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0;
|
||||
|
||||
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
||||
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0;
|
||||
|
||||
|
@ -2694,7 +2708,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Instance
|
||||
{
|
||||
public:
|
||||
using CType = VkInstance;
|
||||
using CType = VkInstance;
|
||||
using CppType = vk::Instance;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -2953,7 +2968,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class PhysicalDevice
|
||||
{
|
||||
public:
|
||||
using CType = VkPhysicalDevice;
|
||||
using CType = VkPhysicalDevice;
|
||||
using CppType = vk::PhysicalDevice;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -3411,7 +3427,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Device
|
||||
{
|
||||
public:
|
||||
using CType = VkDevice;
|
||||
using CType = VkDevice;
|
||||
using CppType = vk::Device;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -4178,6 +4195,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
|
||||
//=== VK_EXT_descriptor_buffer ===
|
||||
|
||||
void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
template <typename DescriptorType>
|
||||
VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
|
@ -4369,7 +4388,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class AccelerationStructureKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkAccelerationStructureKHR;
|
||||
using CType = VkAccelerationStructureKHR;
|
||||
using CppType = vk::AccelerationStructureKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -4489,7 +4509,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class AccelerationStructureNV
|
||||
{
|
||||
public:
|
||||
using CType = VkAccelerationStructureNV;
|
||||
using CType = VkAccelerationStructureNV;
|
||||
using CppType = vk::AccelerationStructureNV;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -4617,7 +4638,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Buffer
|
||||
{
|
||||
public:
|
||||
using CType = VkBuffer;
|
||||
using CType = VkBuffer;
|
||||
using CppType = vk::Buffer;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -4743,7 +4765,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class BufferCollectionFUCHSIA
|
||||
{
|
||||
public:
|
||||
using CType = VkBufferCollectionFUCHSIA;
|
||||
using CType = VkBufferCollectionFUCHSIA;
|
||||
using CppType = vk::BufferCollectionFUCHSIA;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -4872,7 +4895,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class BufferView
|
||||
{
|
||||
public:
|
||||
using CType = VkBufferView;
|
||||
using CType = VkBufferView;
|
||||
using CppType = vk::BufferView;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -4991,7 +5015,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class CommandPool
|
||||
{
|
||||
public:
|
||||
using CType = VkCommandPool;
|
||||
using CType = VkCommandPool;
|
||||
using CppType = vk::CommandPool;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -5122,7 +5147,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class CommandBuffer
|
||||
{
|
||||
public:
|
||||
using CType = VkCommandBuffer;
|
||||
using CType = VkCommandBuffer;
|
||||
using CppType = vk::CommandBuffer;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -6159,7 +6185,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class CuFunctionNVX
|
||||
{
|
||||
public:
|
||||
using CType = VkCuFunctionNVX;
|
||||
using CType = VkCuFunctionNVX;
|
||||
using CppType = vk::CuFunctionNVX;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -6278,7 +6305,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class CuModuleNVX
|
||||
{
|
||||
public:
|
||||
using CType = VkCuModuleNVX;
|
||||
using CType = VkCuModuleNVX;
|
||||
using CppType = vk::CuModuleNVX;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -6397,7 +6425,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DebugReportCallbackEXT
|
||||
{
|
||||
public:
|
||||
using CType = VkDebugReportCallbackEXT;
|
||||
using CType = VkDebugReportCallbackEXT;
|
||||
using CppType = vk::DebugReportCallbackEXT;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -6517,7 +6546,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DebugUtilsMessengerEXT
|
||||
{
|
||||
public:
|
||||
using CType = VkDebugUtilsMessengerEXT;
|
||||
using CType = VkDebugUtilsMessengerEXT;
|
||||
using CppType = vk::DebugUtilsMessengerEXT;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -6637,7 +6667,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DeferredOperationKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkDeferredOperationKHR;
|
||||
using CType = VkDeferredOperationKHR;
|
||||
using CppType = vk::DeferredOperationKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -6763,7 +6794,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DescriptorPool
|
||||
{
|
||||
public:
|
||||
using CType = VkDescriptorPool;
|
||||
using CType = VkDescriptorPool;
|
||||
using CppType = vk::DescriptorPool;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -6887,7 +6919,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DescriptorSet
|
||||
{
|
||||
public:
|
||||
using CType = VkDescriptorSet;
|
||||
using CType = VkDescriptorSet;
|
||||
using CppType = vk::DescriptorSet;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -7032,7 +7065,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DescriptorSetLayout
|
||||
{
|
||||
public:
|
||||
using CType = VkDescriptorSetLayout;
|
||||
using CType = VkDescriptorSetLayout;
|
||||
using CppType = vk::DescriptorSetLayout;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -7158,7 +7192,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DescriptorUpdateTemplate
|
||||
{
|
||||
public:
|
||||
using CType = VkDescriptorUpdateTemplate;
|
||||
using CType = VkDescriptorUpdateTemplate;
|
||||
using CppType = vk::DescriptorUpdateTemplate;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -7278,7 +7313,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DeviceMemory
|
||||
{
|
||||
public:
|
||||
using CType = VkDeviceMemory;
|
||||
using CType = VkDeviceMemory;
|
||||
using CppType = vk::DeviceMemory;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -7417,7 +7453,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DisplayKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkDisplayKHR;
|
||||
using CType = VkDisplayKHR;
|
||||
using CppType = vk::DisplayKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -7605,7 +7642,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class DisplayModeKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkDisplayModeKHR;
|
||||
using CType = VkDisplayModeKHR;
|
||||
using CppType = vk::DisplayModeKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -7711,7 +7749,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Event
|
||||
{
|
||||
public:
|
||||
using CType = VkEvent;
|
||||
using CType = VkEvent;
|
||||
using CppType = vk::Event;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -7838,7 +7877,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Fence
|
||||
{
|
||||
public:
|
||||
using CType = VkFence;
|
||||
using CType = VkFence;
|
||||
using CppType = vk::Fence;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -7999,7 +8039,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Framebuffer
|
||||
{
|
||||
public:
|
||||
using CType = VkFramebuffer;
|
||||
using CType = VkFramebuffer;
|
||||
using CppType = vk::Framebuffer;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -8122,7 +8163,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Image
|
||||
{
|
||||
public:
|
||||
using CType = VkImage;
|
||||
using CType = VkImage;
|
||||
using CppType = vk::Image;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -8274,7 +8316,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class ImageView
|
||||
{
|
||||
public:
|
||||
using CType = VkImageView;
|
||||
using CType = VkImageView;
|
||||
using CppType = vk::ImageView;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -8397,7 +8440,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class IndirectCommandsLayoutNV
|
||||
{
|
||||
public:
|
||||
using CType = VkIndirectCommandsLayoutNV;
|
||||
using CType = VkIndirectCommandsLayoutNV;
|
||||
using CppType = vk::IndirectCommandsLayoutNV;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -8517,7 +8561,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class MicromapEXT
|
||||
{
|
||||
public:
|
||||
using CType = VkMicromapEXT;
|
||||
using CType = VkMicromapEXT;
|
||||
using CppType = vk::MicromapEXT;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -8636,7 +8681,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class OpticalFlowSessionNV
|
||||
{
|
||||
public:
|
||||
using CType = VkOpticalFlowSessionNV;
|
||||
using CType = VkOpticalFlowSessionNV;
|
||||
using CppType = vk::OpticalFlowSessionNV;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -8762,7 +8808,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class PerformanceConfigurationINTEL
|
||||
{
|
||||
public:
|
||||
using CType = VkPerformanceConfigurationINTEL;
|
||||
using CType = VkPerformanceConfigurationINTEL;
|
||||
using CppType = vk::PerformanceConfigurationINTEL;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -8866,7 +8913,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class PipelineCache
|
||||
{
|
||||
public:
|
||||
using CType = VkPipelineCache;
|
||||
using CType = VkPipelineCache;
|
||||
using CppType = vk::PipelineCache;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -8992,7 +9040,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Pipeline
|
||||
{
|
||||
public:
|
||||
using CType = VkPipeline;
|
||||
using CType = VkPipeline;
|
||||
using CppType = vk::Pipeline;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -9420,7 +9469,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class PipelineLayout
|
||||
{
|
||||
public:
|
||||
using CType = VkPipelineLayout;
|
||||
using CType = VkPipelineLayout;
|
||||
using CppType = vk::PipelineLayout;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -9540,7 +9590,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class PrivateDataSlot
|
||||
{
|
||||
public:
|
||||
using CType = VkPrivateDataSlot;
|
||||
using CType = VkPrivateDataSlot;
|
||||
using CppType = vk::PrivateDataSlot;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -9660,7 +9711,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class QueryPool
|
||||
{
|
||||
public:
|
||||
using CType = VkQueryPool;
|
||||
using CType = VkQueryPool;
|
||||
using CppType = vk::QueryPool;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -9804,7 +9856,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Queue
|
||||
{
|
||||
public:
|
||||
using CType = VkQueue;
|
||||
using CType = VkQueue;
|
||||
using CppType = vk::Queue;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -9929,6 +9982,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
|
||||
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> getCheckpointData2NV() const;
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
|
||||
void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
private:
|
||||
VULKAN_HPP_NAMESPACE::Queue m_queue = {};
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
|
||||
|
@ -9937,7 +9994,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class RenderPass
|
||||
{
|
||||
public:
|
||||
using CType = VkRenderPass;
|
||||
using CType = VkRenderPass;
|
||||
using CppType = vk::RenderPass;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -10082,7 +10140,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Sampler
|
||||
{
|
||||
public:
|
||||
using CType = VkSampler;
|
||||
using CType = VkSampler;
|
||||
using CppType = vk::Sampler;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -10201,7 +10260,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class SamplerYcbcrConversion
|
||||
{
|
||||
public:
|
||||
using CType = VkSamplerYcbcrConversion;
|
||||
using CType = VkSamplerYcbcrConversion;
|
||||
using CppType = vk::SamplerYcbcrConversion;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -10321,7 +10381,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class Semaphore
|
||||
{
|
||||
public:
|
||||
using CType = VkSemaphore;
|
||||
using CType = VkSemaphore;
|
||||
using CppType = vk::Semaphore;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -10448,7 +10509,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class ShaderEXT
|
||||
{
|
||||
public:
|
||||
using CType = VkShaderEXT;
|
||||
using CType = VkShaderEXT;
|
||||
using CppType = vk::ShaderEXT;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -10610,7 +10672,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class ShaderModule
|
||||
{
|
||||
public:
|
||||
using CType = VkShaderModule;
|
||||
using CType = VkShaderModule;
|
||||
using CppType = vk::ShaderModule;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -10733,7 +10796,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class SurfaceKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkSurfaceKHR;
|
||||
using CType = VkSurfaceKHR;
|
||||
using CppType = vk::SurfaceKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -11130,7 +11194,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class SwapchainKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkSwapchainKHR;
|
||||
using CType = VkSwapchainKHR;
|
||||
using CppType = vk::SwapchainKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -11278,6 +11343,16 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
void releaseFullScreenExclusiveModeEXT() const;
|
||||
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
|
||||
void setLatencySleepModeNV( const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo ) const;
|
||||
|
||||
void latencySleepNV( const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo ) const;
|
||||
|
||||
void setLatencyMarkerNV( const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
VULKAN_HPP_NODISCARD std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> getLatencyTimingsNV() const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
private:
|
||||
VULKAN_HPP_NAMESPACE::Device m_device = {};
|
||||
VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {};
|
||||
|
@ -11326,7 +11401,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class ValidationCacheEXT
|
||||
{
|
||||
public:
|
||||
using CType = VkValidationCacheEXT;
|
||||
using CType = VkValidationCacheEXT;
|
||||
using CppType = vk::ValidationCacheEXT;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -11452,7 +11528,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class VideoSessionKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkVideoSessionKHR;
|
||||
using CType = VkVideoSessionKHR;
|
||||
using CppType = vk::VideoSessionKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -11578,7 +11655,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
class VideoSessionParametersKHR
|
||||
{
|
||||
public:
|
||||
using CType = VkVideoSessionParametersKHR;
|
||||
using CType = VkVideoSessionParametersKHR;
|
||||
using CppType = vk::VideoSessionParametersKHR;
|
||||
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
|
||||
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
|
||||
|
@ -18975,6 +19053,16 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
return offset;
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE void Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
|
||||
size_t dataSize,
|
||||
void * pDescriptor ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" );
|
||||
|
||||
getDispatcher()->vkGetDescriptorEXT(
|
||||
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), dataSize, pDescriptor );
|
||||
}
|
||||
|
||||
template <typename DescriptorType>
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorType
|
||||
Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT
|
||||
|
@ -20639,6 +20727,58 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
return properties;
|
||||
}
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
|
||||
VULKAN_HPP_INLINE void SwapchainKHR::setLatencySleepModeNV( const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencySleepModeNV && "Function <vkSetLatencySleepModeNV> requires <VK_NV_low_latency2>" );
|
||||
|
||||
VkResult result = getDispatcher()->vkSetLatencySleepModeNV(
|
||||
static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( &sleepModeInfo ) );
|
||||
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::setLatencySleepModeNV" );
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE void SwapchainKHR::latencySleepNV( const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo ) const
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkLatencySleepNV && "Function <vkLatencySleepNV> requires <VK_NV_low_latency2>" );
|
||||
|
||||
VkResult result = getDispatcher()->vkLatencySleepNV(
|
||||
static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( &sleepInfo ) );
|
||||
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::latencySleepNV" );
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE void SwapchainKHR::setLatencyMarkerNV( const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencyMarkerNV && "Function <vkSetLatencyMarkerNV> requires <VK_NV_low_latency2>" );
|
||||
|
||||
getDispatcher()->vkSetLatencyMarkerNV( static_cast<VkDevice>( m_device ),
|
||||
static_cast<VkSwapchainKHR>( m_swapchain ),
|
||||
reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
|
||||
}
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>
|
||||
SwapchainKHR::getLatencyTimingsNV() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkGetLatencyTimingsNV && "Function <vkGetLatencyTimingsNV> requires <VK_NV_low_latency2>" );
|
||||
|
||||
std::pair<uint32_t, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV> data_;
|
||||
uint32_t & timingCount = data_.first;
|
||||
VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV & latencyMarkerInfo = data_.second;
|
||||
getDispatcher()->vkGetLatencyTimingsNV( static_cast<VkDevice>( m_device ),
|
||||
static_cast<VkSwapchainKHR>( m_swapchain ),
|
||||
&timingCount,
|
||||
reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
|
||||
|
||||
return data_;
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( getDispatcher()->vkQueueNotifyOutOfBandNV && "Function <vkQueueNotifyOutOfBandNV> requires <VK_NV_low_latency2>" );
|
||||
|
||||
getDispatcher()->vkQueueNotifyOutOfBandNV( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( &queueTypeInfo ) );
|
||||
}
|
||||
|
||||
//=== VK_KHR_cooperative_matrix ===
|
||||
|
||||
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>
|
||||
|
@ -20715,6 +20855,32 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//====================
|
||||
//=== RAII Helpers ===
|
||||
//====================
|
||||
|
||||
template <typename RAIIType>
|
||||
std::vector<typename RAIIType::CppType> filterCppTypes( std::vector<RAIIType> const & raiiTypes )
|
||||
{
|
||||
std::vector<typename RAIIType::CppType> cppTypes( raiiTypes.size() );
|
||||
std::transform( raiiTypes.begin(), raiiTypes.end(), cppTypes.begin(), []( RAIIType const & d ) { return *d; } );
|
||||
return cppTypes;
|
||||
}
|
||||
|
||||
template <typename RAIIType, class UnaryPredicate>
|
||||
std::vector<typename RAIIType::CppType> filterCppTypes( std::vector<RAIIType> const & raiiTypes, UnaryPredicate p )
|
||||
{
|
||||
std::vector<typename RAIIType::CppType> cppTypes;
|
||||
for ( auto const & t : raiiTypes )
|
||||
{
|
||||
if ( p( t ) )
|
||||
{
|
||||
cppTypes.push_back( *t );
|
||||
}
|
||||
}
|
||||
return cppTypes;
|
||||
}
|
||||
|
||||
} // namespace VULKAN_HPP_RAII_NAMESPACE
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
#endif
|
||||
|
|
988
thirdparty/vulkan/include/vulkan/vulkan_shared.hpp
vendored
Normal file
988
thirdparty/vulkan/include/vulkan/vulkan_shared.hpp
vendored
Normal file
|
@ -0,0 +1,988 @@
|
|||
// Copyright 2015-2023 The Khronos Group Inc.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
//
|
||||
|
||||
// This header is generated from the Khronos Vulkan XML API Registry.
|
||||
|
||||
#ifndef VULKAN_SHARED_HPP
|
||||
#define VULKAN_SHARED_HPP
|
||||
|
||||
#include <atomic> // std::atomic_size_t
|
||||
#include <vulkan/vulkan.hpp>
|
||||
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||
|
||||
template <typename HandleType>
|
||||
class SharedHandleTraits;
|
||||
|
||||
class NoDestructor
|
||||
{
|
||||
};
|
||||
|
||||
template <typename HandleType, typename = void>
|
||||
struct HasDestructorType : std::false_type
|
||||
{
|
||||
};
|
||||
|
||||
template <typename HandleType>
|
||||
struct HasDestructorType<HandleType, decltype( (void)typename SharedHandleTraits<HandleType>::DestructorType() )> : std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
template <typename HandleType, typename Enable = void>
|
||||
struct GetDestructorType
|
||||
{
|
||||
using type = NoDestructor;
|
||||
};
|
||||
|
||||
template <typename HandleType>
|
||||
struct GetDestructorType<HandleType, typename std::enable_if<HasDestructorType<HandleType>::value>::type>
|
||||
{
|
||||
using type = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||
};
|
||||
|
||||
template <class HandleType>
|
||||
using DestructorTypeOf = typename GetDestructorType<HandleType>::type;
|
||||
|
||||
template <class HandleType>
|
||||
struct HasDestructor : std::integral_constant<bool, !std::is_same<DestructorTypeOf<HandleType>, NoDestructor>::value>
|
||||
{
|
||||
};
|
||||
|
||||
//=====================================================================================================================
|
||||
|
||||
template <typename HandleType>
|
||||
class SharedHandle;
|
||||
|
||||
template <typename DestructorType, typename Deleter>
|
||||
struct SharedHeader
|
||||
{
|
||||
SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
|
||||
: parent( std::move( parent ) )
|
||||
, deleter( std::move( deleter ) )
|
||||
{
|
||||
}
|
||||
|
||||
SharedHandle<DestructorType> parent;
|
||||
Deleter deleter;
|
||||
};
|
||||
|
||||
template <typename Deleter>
|
||||
struct SharedHeader<NoDestructor, Deleter>
|
||||
{
|
||||
SharedHeader( Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
|
||||
|
||||
Deleter deleter;
|
||||
};
|
||||
|
||||
//=====================================================================================================================
|
||||
|
||||
template <typename HeaderType>
|
||||
class ReferenceCounter
|
||||
{
|
||||
public:
|
||||
template <typename... Args>
|
||||
ReferenceCounter( Args &&... control_args ) : m_header( std::forward<Args>( control_args )... )
|
||||
{
|
||||
}
|
||||
ReferenceCounter( const ReferenceCounter & ) = delete;
|
||||
ReferenceCounter & operator=( const ReferenceCounter & ) = delete;
|
||||
|
||||
public:
|
||||
size_t addRef() VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
// Relaxed memory order is sufficient since this does not impose any ordering on other operations
|
||||
return m_ref_cnt.fetch_add( 1, std::memory_order_relaxed );
|
||||
}
|
||||
|
||||
size_t release() VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
// A release memory order to ensure that all releases are ordered
|
||||
return m_ref_cnt.fetch_sub( 1, std::memory_order_release );
|
||||
}
|
||||
|
||||
public:
|
||||
std::atomic_size_t m_ref_cnt{ 1 };
|
||||
HeaderType m_header{};
|
||||
};
|
||||
|
||||
//=====================================================================================================================
|
||||
|
||||
template <typename HandleType, typename HeaderType, typename ForwardType = SharedHandle<HandleType>>
|
||||
class SharedHandleBase
|
||||
{
|
||||
public:
|
||||
SharedHandleBase() = default;
|
||||
|
||||
template <typename... Args>
|
||||
SharedHandleBase( HandleType handle, Args &&... control_args )
|
||||
: m_control( new ReferenceCounter<HeaderType>( std::forward<Args>( control_args )... ) ), m_handle( handle )
|
||||
{
|
||||
}
|
||||
|
||||
SharedHandleBase( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
o.addRef();
|
||||
m_handle = o.m_handle;
|
||||
m_control = o.m_control;
|
||||
}
|
||||
|
||||
SharedHandleBase( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
|
||||
: m_control( o.m_control )
|
||||
, m_handle( o.m_handle )
|
||||
{
|
||||
o.m_handle = nullptr;
|
||||
o.m_control = nullptr;
|
||||
}
|
||||
|
||||
SharedHandleBase & operator=( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
SharedHandleBase( o ).swap( *this );
|
||||
return *this;
|
||||
}
|
||||
|
||||
SharedHandleBase & operator=( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
SharedHandleBase( std::move( o ) ).swap( *this );
|
||||
return *this;
|
||||
}
|
||||
|
||||
~SharedHandleBase()
|
||||
{
|
||||
// only this function owns the last reference to the control block
|
||||
// the same principle is used in the default deleter of std::shared_ptr
|
||||
if ( m_control && ( m_control->release() == 1 ) )
|
||||
{
|
||||
// noop in x86, but does thread synchronization in ARM
|
||||
// it is required to ensure that last thread is getting to destroy the control block
|
||||
// by ordering all atomic operations before this fence
|
||||
std::atomic_thread_fence( std::memory_order_acquire );
|
||||
ForwardType::internalDestroy( getHeader(), m_handle );
|
||||
delete m_control;
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
HandleType get() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_handle;
|
||||
}
|
||||
|
||||
HandleType operator*() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_handle;
|
||||
}
|
||||
|
||||
explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return bool( m_handle );
|
||||
}
|
||||
|
||||
const HandleType * operator->() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return &m_handle;
|
||||
}
|
||||
|
||||
HandleType * operator->() VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return &m_handle;
|
||||
}
|
||||
|
||||
void reset() VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
SharedHandleBase().swap( *this );
|
||||
}
|
||||
|
||||
void swap( SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::swap( m_handle, o.m_handle );
|
||||
std::swap( m_control, o.m_control );
|
||||
}
|
||||
|
||||
template <typename T = HandleType>
|
||||
typename std::enable_if<HasDestructor<T>::value, const SharedHandle<DestructorTypeOf<HandleType>> &>::type getDestructorType() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return getHeader().parent;
|
||||
}
|
||||
|
||||
protected:
|
||||
template <typename T = HandleType>
|
||||
static typename std::enable_if<!HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
control.deleter.destroy( handle );
|
||||
}
|
||||
|
||||
template <typename T = HandleType>
|
||||
static typename std::enable_if<HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
control.deleter.destroy( control.parent.get(), handle );
|
||||
}
|
||||
|
||||
const HeaderType & getHeader() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return m_control->m_header;
|
||||
}
|
||||
|
||||
private:
|
||||
void addRef() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
if ( m_control )
|
||||
m_control->addRef();
|
||||
}
|
||||
|
||||
protected:
|
||||
ReferenceCounter<HeaderType> * m_control = nullptr;
|
||||
HandleType m_handle{};
|
||||
};
|
||||
|
||||
template <typename HandleType>
|
||||
class SharedHandle : public SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>
|
||||
{
|
||||
private:
|
||||
using BaseType = SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>;
|
||||
using DeleterType = typename SharedHandleTraits<HandleType>::deleter;
|
||||
friend BaseType;
|
||||
|
||||
public:
|
||||
SharedHandle() = default;
|
||||
|
||||
template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value>::type>
|
||||
explicit SharedHandle( HandleType handle, SharedHandle<DestructorTypeOf<HandleType>> parent, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
|
||||
: BaseType( handle, std::move( parent ), std::move( deleter ) )
|
||||
{
|
||||
}
|
||||
|
||||
template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
|
||||
explicit SharedHandle( HandleType handle, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT : BaseType( handle, std::move( deleter ) )
|
||||
{
|
||||
}
|
||||
|
||||
protected:
|
||||
using BaseType::internalDestroy;
|
||||
};
|
||||
|
||||
template <typename HandleType>
|
||||
class SharedHandleTraits;
|
||||
|
||||
// Silence the function cast warnings.
|
||||
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
|
||||
# pragma GCC diagnostic push
|
||||
# pragma GCC diagnostic ignored "-Wcast-function-type"
|
||||
# endif
|
||||
|
||||
template <typename HandleType>
|
||||
class ObjectDestroyShared
|
||||
{
|
||||
public:
|
||||
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||
|
||||
template <class Dispatcher>
|
||||
using DestroyFunctionPointerType =
|
||||
typename std::conditional<HasDestructor<HandleType>::value,
|
||||
void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
|
||||
void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
|
||||
|
||||
using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
|
||||
|
||||
template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
|
||||
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
|
||||
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
|
||||
, m_dispatch( &dispatch )
|
||||
, m_allocationCallbacks( allocationCallbacks )
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
template <typename T = HandleType>
|
||||
typename std::enable_if<HasDestructor<T>::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
|
||||
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
|
||||
}
|
||||
|
||||
template <typename T = HandleType>
|
||||
typename std::enable_if<!HasDestructor<T>::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
|
||||
( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch );
|
||||
}
|
||||
|
||||
private:
|
||||
DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
|
||||
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
|
||||
};
|
||||
|
||||
template <typename HandleType>
|
||||
class ObjectFreeShared
|
||||
{
|
||||
public:
|
||||
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||
|
||||
template <class Dispatcher>
|
||||
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
|
||||
|
||||
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
|
||||
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
|
||||
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
|
||||
, m_dispatch( &dispatch )
|
||||
, m_allocationCallbacks( allocationCallbacks )
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
|
||||
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
|
||||
}
|
||||
|
||||
private:
|
||||
DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
|
||||
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
|
||||
};
|
||||
|
||||
template <typename HandleType>
|
||||
class ObjectReleaseShared
|
||||
{
|
||||
public:
|
||||
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||
|
||||
template <class Dispatcher>
|
||||
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
|
||||
|
||||
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
|
||||
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
|
||||
, m_dispatch( &dispatch )
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
|
||||
( parent.*m_destroy )( handle, *m_dispatch );
|
||||
}
|
||||
|
||||
private:
|
||||
DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
|
||||
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||
};
|
||||
|
||||
template <typename HandleType, typename PoolType>
|
||||
class PoolFreeShared
|
||||
{
|
||||
public:
|
||||
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||
|
||||
template <class Dispatcher>
|
||||
using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
|
||||
|
||||
template <class Dispatcher>
|
||||
using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
|
||||
|
||||
PoolFreeShared() = default;
|
||||
|
||||
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
|
||||
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
|
||||
, m_dispatch( &dispatch )
|
||||
, m_pool( std::move( pool ) )
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
|
||||
( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
|
||||
}
|
||||
|
||||
private:
|
||||
DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
|
||||
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||
SharedHandle<PoolType> m_pool{};
|
||||
};
|
||||
|
||||
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
|
||||
# pragma GCC diagnostic pop
|
||||
# endif
|
||||
|
||||
//======================
|
||||
//=== SHARED HANDLEs ===
|
||||
//======================
|
||||
|
||||
//=== VK_VERSION_1_0 ===
|
||||
template <>
|
||||
class SharedHandleTraits<Instance>
|
||||
{
|
||||
public:
|
||||
using DestructorType = NoDestructor;
|
||||
using deleter = ObjectDestroyShared<Instance>;
|
||||
};
|
||||
using SharedInstance = SharedHandle<Instance>;
|
||||
template <>
|
||||
class SharedHandleTraits<Device>
|
||||
{
|
||||
public:
|
||||
using DestructorType = NoDestructor;
|
||||
using deleter = ObjectDestroyShared<Device>;
|
||||
};
|
||||
using SharedDevice = SharedHandle<Device>;
|
||||
template <>
|
||||
class SharedHandleTraits<DeviceMemory>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectFreeShared<DeviceMemory>;
|
||||
};
|
||||
using SharedDeviceMemory = SharedHandle<DeviceMemory>;
|
||||
template <>
|
||||
class SharedHandleTraits<Fence>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<Fence>;
|
||||
};
|
||||
using SharedFence = SharedHandle<Fence>;
|
||||
template <>
|
||||
class SharedHandleTraits<Semaphore>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<Semaphore>;
|
||||
};
|
||||
using SharedSemaphore = SharedHandle<Semaphore>;
|
||||
template <>
|
||||
class SharedHandleTraits<Event>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<Event>;
|
||||
};
|
||||
using SharedEvent = SharedHandle<Event>;
|
||||
template <>
|
||||
class SharedHandleTraits<QueryPool>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<QueryPool>;
|
||||
};
|
||||
using SharedQueryPool = SharedHandle<QueryPool>;
|
||||
template <>
|
||||
class SharedHandleTraits<Buffer>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<Buffer>;
|
||||
};
|
||||
using SharedBuffer = SharedHandle<Buffer>;
|
||||
template <>
|
||||
class SharedHandleTraits<BufferView>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<BufferView>;
|
||||
};
|
||||
using SharedBufferView = SharedHandle<BufferView>;
|
||||
template <>
|
||||
class SharedHandleTraits<Image>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<Image>;
|
||||
};
|
||||
using SharedImage = SharedHandle<Image>;
|
||||
template <>
|
||||
class SharedHandleTraits<ImageView>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<ImageView>;
|
||||
};
|
||||
using SharedImageView = SharedHandle<ImageView>;
|
||||
template <>
|
||||
class SharedHandleTraits<ShaderModule>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<ShaderModule>;
|
||||
};
|
||||
using SharedShaderModule = SharedHandle<ShaderModule>;
|
||||
template <>
|
||||
class SharedHandleTraits<PipelineCache>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<PipelineCache>;
|
||||
};
|
||||
using SharedPipelineCache = SharedHandle<PipelineCache>;
|
||||
template <>
|
||||
class SharedHandleTraits<Pipeline>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<Pipeline>;
|
||||
};
|
||||
using SharedPipeline = SharedHandle<Pipeline>;
|
||||
template <>
|
||||
class SharedHandleTraits<PipelineLayout>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<PipelineLayout>;
|
||||
};
|
||||
using SharedPipelineLayout = SharedHandle<PipelineLayout>;
|
||||
template <>
|
||||
class SharedHandleTraits<Sampler>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<Sampler>;
|
||||
};
|
||||
using SharedSampler = SharedHandle<Sampler>;
|
||||
template <>
|
||||
class SharedHandleTraits<DescriptorPool>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<DescriptorPool>;
|
||||
};
|
||||
using SharedDescriptorPool = SharedHandle<DescriptorPool>;
|
||||
template <>
|
||||
class SharedHandleTraits<DescriptorSet>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = PoolFreeShared<DescriptorSet, DescriptorPool>;
|
||||
};
|
||||
using SharedDescriptorSet = SharedHandle<DescriptorSet>;
|
||||
template <>
|
||||
class SharedHandleTraits<DescriptorSetLayout>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<DescriptorSetLayout>;
|
||||
};
|
||||
using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
|
||||
template <>
|
||||
class SharedHandleTraits<Framebuffer>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<Framebuffer>;
|
||||
};
|
||||
using SharedFramebuffer = SharedHandle<Framebuffer>;
|
||||
template <>
|
||||
class SharedHandleTraits<RenderPass>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<RenderPass>;
|
||||
};
|
||||
using SharedRenderPass = SharedHandle<RenderPass>;
|
||||
template <>
|
||||
class SharedHandleTraits<CommandPool>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<CommandPool>;
|
||||
};
|
||||
using SharedCommandPool = SharedHandle<CommandPool>;
|
||||
template <>
|
||||
class SharedHandleTraits<CommandBuffer>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = PoolFreeShared<CommandBuffer, CommandPool>;
|
||||
};
|
||||
using SharedCommandBuffer = SharedHandle<CommandBuffer>;
|
||||
|
||||
//=== VK_VERSION_1_1 ===
|
||||
template <>
|
||||
class SharedHandleTraits<SamplerYcbcrConversion>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<SamplerYcbcrConversion>;
|
||||
};
|
||||
using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
|
||||
using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>;
|
||||
template <>
|
||||
class SharedHandleTraits<DescriptorUpdateTemplate>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<DescriptorUpdateTemplate>;
|
||||
};
|
||||
using SharedDescriptorUpdateTemplate = SharedHandle<DescriptorUpdateTemplate>;
|
||||
using SharedDescriptorUpdateTemplateKHR = SharedHandle<DescriptorUpdateTemplate>;
|
||||
//=== VK_VERSION_1_3 ===
|
||||
template <>
|
||||
class SharedHandleTraits<PrivateDataSlot>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<PrivateDataSlot>;
|
||||
};
|
||||
using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>;
|
||||
using SharedPrivateDataSlotEXT = SharedHandle<PrivateDataSlot>;
|
||||
//=== VK_KHR_surface ===
|
||||
template <>
|
||||
class SharedHandleTraits<SurfaceKHR>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Instance;
|
||||
using deleter = ObjectDestroyShared<SurfaceKHR>;
|
||||
};
|
||||
using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
|
||||
|
||||
//=== VK_KHR_swapchain ===
|
||||
template <>
|
||||
class SharedHandleTraits<SwapchainKHR>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<SwapchainKHR>;
|
||||
};
|
||||
using SharedSwapchainKHR = SharedHandle<SwapchainKHR>;
|
||||
|
||||
//=== VK_EXT_debug_report ===
|
||||
template <>
|
||||
class SharedHandleTraits<DebugReportCallbackEXT>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Instance;
|
||||
using deleter = ObjectDestroyShared<DebugReportCallbackEXT>;
|
||||
};
|
||||
using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>;
|
||||
|
||||
//=== VK_KHR_video_queue ===
|
||||
template <>
|
||||
class SharedHandleTraits<VideoSessionKHR>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<VideoSessionKHR>;
|
||||
};
|
||||
using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>;
|
||||
template <>
|
||||
class SharedHandleTraits<VideoSessionParametersKHR>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<VideoSessionParametersKHR>;
|
||||
};
|
||||
using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>;
|
||||
|
||||
//=== VK_NVX_binary_import ===
|
||||
template <>
|
||||
class SharedHandleTraits<CuModuleNVX>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<CuModuleNVX>;
|
||||
};
|
||||
using SharedCuModuleNVX = SharedHandle<CuModuleNVX>;
|
||||
template <>
|
||||
class SharedHandleTraits<CuFunctionNVX>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<CuFunctionNVX>;
|
||||
};
|
||||
using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>;
|
||||
|
||||
//=== VK_EXT_debug_utils ===
|
||||
template <>
|
||||
class SharedHandleTraits<DebugUtilsMessengerEXT>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Instance;
|
||||
using deleter = ObjectDestroyShared<DebugUtilsMessengerEXT>;
|
||||
};
|
||||
using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
|
||||
|
||||
//=== VK_KHR_acceleration_structure ===
|
||||
template <>
|
||||
class SharedHandleTraits<AccelerationStructureKHR>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<AccelerationStructureKHR>;
|
||||
};
|
||||
using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>;
|
||||
|
||||
//=== VK_EXT_validation_cache ===
|
||||
template <>
|
||||
class SharedHandleTraits<ValidationCacheEXT>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<ValidationCacheEXT>;
|
||||
};
|
||||
using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>;
|
||||
|
||||
//=== VK_NV_ray_tracing ===
|
||||
template <>
|
||||
class SharedHandleTraits<AccelerationStructureNV>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<AccelerationStructureNV>;
|
||||
};
|
||||
using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>;
|
||||
|
||||
//=== VK_KHR_deferred_host_operations ===
|
||||
template <>
|
||||
class SharedHandleTraits<DeferredOperationKHR>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<DeferredOperationKHR>;
|
||||
};
|
||||
using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>;
|
||||
|
||||
//=== VK_NV_device_generated_commands ===
|
||||
template <>
|
||||
class SharedHandleTraits<IndirectCommandsLayoutNV>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<IndirectCommandsLayoutNV>;
|
||||
};
|
||||
using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>;
|
||||
|
||||
# if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||
//=== VK_FUCHSIA_buffer_collection ===
|
||||
template <>
|
||||
class SharedHandleTraits<BufferCollectionFUCHSIA>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<BufferCollectionFUCHSIA>;
|
||||
};
|
||||
using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>;
|
||||
# endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
//=== VK_EXT_opacity_micromap ===
|
||||
template <>
|
||||
class SharedHandleTraits<MicromapEXT>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<MicromapEXT>;
|
||||
};
|
||||
using SharedMicromapEXT = SharedHandle<MicromapEXT>;
|
||||
|
||||
//=== VK_NV_optical_flow ===
|
||||
template <>
|
||||
class SharedHandleTraits<OpticalFlowSessionNV>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<OpticalFlowSessionNV>;
|
||||
};
|
||||
using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>;
|
||||
|
||||
//=== VK_EXT_shader_object ===
|
||||
template <>
|
||||
class SharedHandleTraits<ShaderEXT>
|
||||
{
|
||||
public:
|
||||
using DestructorType = Device;
|
||||
using deleter = ObjectDestroyShared<ShaderEXT>;
|
||||
};
|
||||
using SharedShaderEXT = SharedHandle<ShaderEXT>;
|
||||
|
||||
enum class SwapchainOwns
|
||||
{
|
||||
no,
|
||||
yes,
|
||||
};
|
||||
|
||||
struct ImageHeader : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>
|
||||
{
|
||||
ImageHeader(
|
||||
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
|
||||
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter deleter = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter(),
|
||||
SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
|
||||
: SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>( std::move( parent ),
|
||||
std::move( deleter ) )
|
||||
, swapchainOwned( swapchainOwned )
|
||||
{
|
||||
}
|
||||
|
||||
SwapchainOwns swapchainOwned = SwapchainOwns::no;
|
||||
};
|
||||
|
||||
template <>
|
||||
class SharedHandle<VULKAN_HPP_NAMESPACE::Image> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>
|
||||
{
|
||||
using BaseType = SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>;
|
||||
using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter;
|
||||
friend BaseType;
|
||||
|
||||
public:
|
||||
SharedHandle() = default;
|
||||
|
||||
explicit SharedHandle( VULKAN_HPP_NAMESPACE::Image handle,
|
||||
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
|
||||
SwapchainOwns swapchain_owned = SwapchainOwns::no,
|
||||
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
|
||||
: BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
|
||||
{
|
||||
}
|
||||
|
||||
protected:
|
||||
static void internalDestroy( const ImageHeader & control, VULKAN_HPP_NAMESPACE::Image handle ) VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
if ( control.swapchainOwned == SwapchainOwns::no )
|
||||
{
|
||||
control.deleter.destroy( control.parent.get(), handle );
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct SwapchainHeader
|
||||
{
|
||||
SwapchainHeader( SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface,
|
||||
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent,
|
||||
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter =
|
||||
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
|
||||
: surface( std::move( surface ) )
|
||||
, parent( std::move( parent ) )
|
||||
, deleter( std::move( deleter ) )
|
||||
{
|
||||
}
|
||||
|
||||
SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface{};
|
||||
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent{};
|
||||
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter{};
|
||||
};
|
||||
|
||||
template <>
|
||||
class SharedHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>
|
||||
{
|
||||
using BaseType = SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>;
|
||||
using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter;
|
||||
friend BaseType;
|
||||
|
||||
public:
|
||||
SharedHandle() = default;
|
||||
|
||||
explicit SharedHandle( VULKAN_HPP_NAMESPACE::SwapchainKHR handle,
|
||||
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent,
|
||||
SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface,
|
||||
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
|
||||
: BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
const SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return getHeader().surface;
|
||||
}
|
||||
|
||||
protected:
|
||||
using BaseType::internalDestroy;
|
||||
};
|
||||
|
||||
template <typename HandleType, typename DestructorType>
|
||||
class SharedHandleBaseNoDestroy : public SharedHandleBase<HandleType, DestructorType>
|
||||
{
|
||||
public:
|
||||
using SharedHandleBase<HandleType, DestructorType>::SharedHandleBase;
|
||||
|
||||
const DestructorType & getDestructorType() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return SharedHandleBase<HandleType, DestructorType>::getHeader();
|
||||
}
|
||||
|
||||
protected:
|
||||
static void internalDestroy( const DestructorType &, HandleType ) VULKAN_HPP_NOEXCEPT {}
|
||||
};
|
||||
|
||||
//=== VK_VERSION_1_0 ===
|
||||
|
||||
template <>
|
||||
class SharedHandle<PhysicalDevice> : public SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>
|
||||
{
|
||||
friend SharedHandleBase<PhysicalDevice, SharedInstance>;
|
||||
|
||||
public:
|
||||
SharedHandle() = default;
|
||||
explicit SharedHandle( PhysicalDevice handle, SharedInstance parent ) noexcept
|
||||
: SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>( handle, std::move( parent ) )
|
||||
{
|
||||
}
|
||||
};
|
||||
using SharedPhysicalDevice = SharedHandle<PhysicalDevice>;
|
||||
|
||||
template <>
|
||||
class SharedHandle<Queue> : public SharedHandleBaseNoDestroy<Queue, SharedDevice>
|
||||
{
|
||||
friend SharedHandleBase<Queue, SharedDevice>;
|
||||
|
||||
public:
|
||||
SharedHandle() = default;
|
||||
explicit SharedHandle( Queue handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy<Queue, SharedDevice>( handle, std::move( parent ) ) {}
|
||||
};
|
||||
using SharedQueue = SharedHandle<Queue>;
|
||||
|
||||
//=== VK_KHR_display ===
|
||||
|
||||
template <>
|
||||
class SharedHandle<DisplayKHR> : public SharedHandleBaseNoDestroy<DisplayKHR, SharedPhysicalDevice>
|
||||
{
|
||||
friend SharedHandleBase<DisplayKHR, SharedPhysicalDevice>;
|
||||
|
||||
public:
|
||||
SharedHandle() = default;
|
||||
explicit SharedHandle( DisplayKHR handle, SharedPhysicalDevice parent ) noexcept
|
||||
: SharedHandleBaseNoDestroy<DisplayKHR, SharedPhysicalDevice>( handle, std::move( parent ) )
|
||||
{
|
||||
}
|
||||
};
|
||||
using SharedDisplayKHR = SharedHandle<DisplayKHR>;
|
||||
|
||||
template <>
|
||||
class SharedHandle<DisplayModeKHR> : public SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>
|
||||
{
|
||||
friend SharedHandleBase<DisplayModeKHR, SharedDisplayKHR>;
|
||||
|
||||
public:
|
||||
SharedHandle() = default;
|
||||
explicit SharedHandle( DisplayModeKHR handle, SharedDisplayKHR parent ) noexcept
|
||||
: SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>( handle, std::move( parent ) )
|
||||
{
|
||||
}
|
||||
};
|
||||
using SharedDisplayModeKHR = SharedHandle<DisplayModeKHR>;
|
||||
|
||||
//=== VK_INTEL_performance_query ===
|
||||
|
||||
template <>
|
||||
class SharedHandle<PerformanceConfigurationINTEL> : public SharedHandleBaseNoDestroy<PerformanceConfigurationINTEL, SharedDevice>
|
||||
{
|
||||
friend SharedHandleBase<PerformanceConfigurationINTEL, SharedDevice>;
|
||||
|
||||
public:
|
||||
SharedHandle() = default;
|
||||
explicit SharedHandle( PerformanceConfigurationINTEL handle, SharedDevice parent ) noexcept
|
||||
: SharedHandleBaseNoDestroy<PerformanceConfigurationINTEL, SharedDevice>( handle, std::move( parent ) )
|
||||
{
|
||||
}
|
||||
};
|
||||
using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>;
|
||||
#endif // !VULKAN_HPP_NO_SMART_HANDLE
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
#endif // VULKAN_SHARED_HPP
|
|
@ -5882,6 +5882,20 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT>::value,
|
||||
"PhysicalDevicePipelinePropertiesFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_frame_boundary ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT ) == sizeof( VkPhysicalDeviceFrameBoundaryFeaturesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT>::value,
|
||||
"PhysicalDeviceFrameBoundaryFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT ) == sizeof( VkFrameBoundaryEXT ), "struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::FrameBoundaryEXT>::value,
|
||||
"FrameBoundaryEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_multisampled_render_to_single_sampled ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) ==
|
||||
|
@ -6405,6 +6419,24 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM>::value,
|
||||
"PhysicalDeviceImageProcessingPropertiesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_nested_command_buffer ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT ) ==
|
||||
sizeof( VkPhysicalDeviceNestedCommandBufferFeaturesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT>::value,
|
||||
"PhysicalDeviceNestedCommandBufferFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT ) ==
|
||||
sizeof( VkPhysicalDeviceNestedCommandBufferPropertiesEXT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT>::value,
|
||||
"PhysicalDeviceNestedCommandBufferPropertiesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_external_memory_acquire_unmodified ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT ) == sizeof( VkExternalMemoryAcquireUnmodifiedEXT ),
|
||||
|
@ -6613,6 +6645,34 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT>::value,
|
||||
"PhysicalDevicePipelineProtectedAccessFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
//=== VK_ANDROID_external_format_resolve ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID ) ==
|
||||
sizeof( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID>::value,
|
||||
"PhysicalDeviceExternalFormatResolveFeaturesANDROID is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID ) ==
|
||||
sizeof( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID>::value,
|
||||
"PhysicalDeviceExternalFormatResolvePropertiesANDROID is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID ) ==
|
||||
sizeof( VkAndroidHardwareBufferFormatResolvePropertiesANDROID ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID>::value,
|
||||
"AndroidHardwareBufferFormatResolvePropertiesANDROID is not nothrow_move_constructible!" );
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|
||||
//=== VK_KHR_maintenance5 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance5FeaturesKHR ),
|
||||
|
@ -6754,6 +6814,24 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV>::value,
|
||||
"PhysicalDeviceRayTracingInvocationReorderFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_extended_sparse_address_space ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV ) ==
|
||||
sizeof( VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>::value,
|
||||
"PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV ) ==
|
||||
sizeof( VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV>::value,
|
||||
"PhysicalDeviceExtendedSparseAddressSpacePropertiesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_mutable_descriptor_type ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT ) ==
|
||||
|
@ -6815,6 +6893,61 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
|
|||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>::value,
|
||||
"PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV ) == sizeof( VkLatencySleepModeInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>::value,
|
||||
"LatencySleepModeInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV ) == sizeof( VkLatencySleepInfoNV ), "struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencySleepInfoNV>::value,
|
||||
"LatencySleepInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV ) == sizeof( VkSetLatencyMarkerInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV>::value,
|
||||
"SetLatencyMarkerInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV ) == sizeof( VkGetLatencyMarkerInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV>::value,
|
||||
"GetLatencyMarkerInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV ) == sizeof( VkLatencyTimingsFrameReportNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>::value,
|
||||
"LatencyTimingsFrameReportNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV ) == sizeof( VkLatencySubmissionPresentIdNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV>::value,
|
||||
"LatencySubmissionPresentIdNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV ) == sizeof( VkSwapchainLatencyCreateInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>::value,
|
||||
"SwapchainLatencyCreateInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV ) == sizeof( VkOutOfBandQueueTypeInfoNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV>::value,
|
||||
"OutOfBandQueueTypeInfoNV is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV ) == sizeof( VkLatencySurfaceCapabilitiesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV>::value,
|
||||
"LatencySurfaceCapabilitiesNV is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_KHR_cooperative_matrix ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR ) == sizeof( VkCooperativeMatrixPropertiesKHR ),
|
||||
|
@ -6856,6 +6989,77 @@ 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_QCOM_image_processing2 ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM ) == sizeof( VkPhysicalDeviceImageProcessing2FeaturesQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM>::value,
|
||||
"PhysicalDeviceImageProcessing2FeaturesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM ) ==
|
||||
sizeof( VkPhysicalDeviceImageProcessing2PropertiesQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM>::value,
|
||||
"PhysicalDeviceImageProcessing2PropertiesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM ) == sizeof( VkSamplerBlockMatchWindowCreateInfoQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM>::value,
|
||||
"SamplerBlockMatchWindowCreateInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_QCOM_filter_cubic_weights ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM ) == sizeof( VkPhysicalDeviceCubicWeightsFeaturesQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM>::value,
|
||||
"PhysicalDeviceCubicWeightsFeaturesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM ) == sizeof( VkSamplerCubicWeightsCreateInfoQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM>::value,
|
||||
"SamplerCubicWeightsCreateInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM ) == sizeof( VkBlitImageCubicWeightsInfoQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM>::value,
|
||||
"BlitImageCubicWeightsInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_QCOM_ycbcr_degamma ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM ) == sizeof( VkPhysicalDeviceYcbcrDegammaFeaturesQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM>::value,
|
||||
"PhysicalDeviceYcbcrDegammaFeaturesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ) ==
|
||||
sizeof( VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>::value,
|
||||
"SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_QCOM_filter_cubic_clamp ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM ) == sizeof( VkPhysicalDeviceCubicClampFeaturesQCOM ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM>::value,
|
||||
"PhysicalDeviceCubicClampFeaturesQCOM is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) ==
|
||||
|
@ -6901,4 +7105,23 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
|
|||
"PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX is not nothrow_move_constructible!" );
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|
||||
//=== VK_MSFT_layered_driver ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT ) == sizeof( VkPhysicalDeviceLayeredDriverPropertiesMSFT ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value,
|
||||
"PhysicalDeviceLayeredDriverPropertiesMSFT is not nothrow_move_constructible!" );
|
||||
|
||||
//=== VK_NV_descriptor_pool_overallocation ===
|
||||
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV ) ==
|
||||
sizeof( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV ),
|
||||
"struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>::value,
|
||||
"struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>::value,
|
||||
"PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" );
|
||||
|
||||
#endif
|
||||
|
|
3226
thirdparty/vulkan/include/vulkan/vulkan_structs.hpp
vendored
3226
thirdparty/vulkan/include/vulkan/vulkan_structs.hpp
vendored
File diff suppressed because it is too large
Load diff
|
@ -935,6 +935,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
result += "UpdateAfterBind | ";
|
||||
if ( value & DescriptorPoolCreateFlagBits::eHostOnlyEXT )
|
||||
result += "HostOnlyEXT | ";
|
||||
if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV )
|
||||
result += "AllowOverallocationSetsNV | ";
|
||||
if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV )
|
||||
result += "AllowOverallocationPoolsNV | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
@ -1456,6 +1460,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
result += "Min | ";
|
||||
if ( value & ResolveModeFlagBits::eMax )
|
||||
result += "Max | ";
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
if ( value & ResolveModeFlagBits::eExternalFormatDownsampleANDROID )
|
||||
result += "ExternalFormatDownsampleANDROID | ";
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
@ -1733,6 +1741,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
result += "Suspending | ";
|
||||
if ( value & RenderingFlagBits::eResuming )
|
||||
result += "Resuming | ";
|
||||
if ( value & RenderingFlagBits::eContentsInlineEXT )
|
||||
result += "ContentsInlineEXT | ";
|
||||
if ( value & RenderingFlagBits::eEnableLegacyDitheringEXT )
|
||||
result += "EnableLegacyDitheringEXT | ";
|
||||
|
||||
|
@ -2256,6 +2266,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
result += "DeblockingFilterEnabled | ";
|
||||
if ( value & VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial )
|
||||
result += "DeblockingFilterPartial | ";
|
||||
if ( value & VideoEncodeH264StdFlagBitsEXT::eSliceQpDelta )
|
||||
result += "SliceQpDelta | ";
|
||||
if ( value & VideoEncodeH264StdFlagBitsEXT::eDifferentSliceQpDelta )
|
||||
result += "DifferentSliceQpDelta | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
@ -2358,6 +2372,10 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
result += "DependentSliceSegmentsEnabledFlagSet | ";
|
||||
if ( value & VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet )
|
||||
result += "DependentSliceSegmentFlagSet | ";
|
||||
if ( value & VideoEncodeH265StdFlagBitsEXT::eSliceQpDelta )
|
||||
result += "SliceQpDelta | ";
|
||||
if ( value & VideoEncodeH265StdFlagBitsEXT::eDifferentSliceQpDelta )
|
||||
result += "DifferentSliceQpDelta | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
@ -2893,6 +2911,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
std::string result;
|
||||
if ( value & VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes )
|
||||
result += "PrecedingExternallyEncodedBytes | ";
|
||||
if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit )
|
||||
result += "InsufficientstreamBufferRangeDetectionBit | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
@ -3175,6 +3195,20 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
//=== VK_EXT_frame_boundary ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( FrameBoundaryFlagsEXT value )
|
||||
{
|
||||
if ( !value )
|
||||
return "{}";
|
||||
|
||||
std::string result;
|
||||
if ( value & FrameBoundaryFlagBitsEXT::eFrameEnd )
|
||||
result += "FrameEnd | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_screen_surface ===
|
||||
|
||||
|
@ -4304,6 +4338,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV: return "PhysicalDeviceExternalMemoryRdmaFeaturesNV";
|
||||
case StructureType::ePipelinePropertiesIdentifierEXT: return "PipelinePropertiesIdentifierEXT";
|
||||
case StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT: return "PhysicalDevicePipelinePropertiesFeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT: return "PhysicalDeviceFrameBoundaryFeaturesEXT";
|
||||
case StructureType::eFrameBoundaryEXT: return "FrameBoundaryEXT";
|
||||
case StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT: return "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT";
|
||||
case StructureType::eSubpassResolvePerformanceQueryEXT: return "SubpassResolvePerformanceQueryEXT";
|
||||
case StructureType::eMultisampledRenderToSingleSampledInfoEXT: return "MultisampledRenderToSingleSampledInfoEXT";
|
||||
|
@ -4365,6 +4401,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM: return "PhysicalDeviceImageProcessingFeaturesQCOM";
|
||||
case StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM: return "PhysicalDeviceImageProcessingPropertiesQCOM";
|
||||
case StructureType::eImageViewSampleWeightCreateInfoQCOM: return "ImageViewSampleWeightCreateInfoQCOM";
|
||||
case StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT: return "PhysicalDeviceNestedCommandBufferFeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT: return "PhysicalDeviceNestedCommandBufferPropertiesEXT";
|
||||
case StructureType::eExternalMemoryAcquireUnmodifiedEXT: return "ExternalMemoryAcquireUnmodifiedEXT";
|
||||
case StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT: return "PhysicalDeviceExtendedDynamicState3FeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT: return "PhysicalDeviceExtendedDynamicState3PropertiesEXT";
|
||||
|
@ -4388,6 +4426,11 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV: return "OpticalFlowSessionCreatePrivateDataInfoNV";
|
||||
case StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT: return "PhysicalDeviceLegacyDitheringFeaturesEXT";
|
||||
case StructureType::ePhysicalDevicePipelineProtectedAccessFeaturesEXT: return "PhysicalDevicePipelineProtectedAccessFeaturesEXT";
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
case StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID: return "PhysicalDeviceExternalFormatResolveFeaturesANDROID";
|
||||
case StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID: return "PhysicalDeviceExternalFormatResolvePropertiesANDROID";
|
||||
case StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID: return "AndroidHardwareBufferFormatResolvePropertiesANDROID";
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
case StructureType::ePhysicalDeviceMaintenance5FeaturesKHR: return "PhysicalDeviceMaintenance5FeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceMaintenance5PropertiesKHR: return "PhysicalDeviceMaintenance5PropertiesKHR";
|
||||
case StructureType::eRenderingAreaInfoKHR: return "RenderingAreaInfoKHR";
|
||||
|
@ -4407,17 +4450,37 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM: return "PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM";
|
||||
case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV: return "PhysicalDeviceRayTracingInvocationReorderFeaturesNV";
|
||||
case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV: return "PhysicalDeviceRayTracingInvocationReorderPropertiesNV";
|
||||
case StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV: return "PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV";
|
||||
case StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV: return "PhysicalDeviceExtendedSparseAddressSpacePropertiesNV";
|
||||
case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT: return "PhysicalDeviceMutableDescriptorTypeFeaturesEXT";
|
||||
case StructureType::eMutableDescriptorTypeCreateInfoEXT: return "MutableDescriptorTypeCreateInfoEXT";
|
||||
case StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM: return "PhysicalDeviceShaderCoreBuiltinsFeaturesARM";
|
||||
case StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM: return "PhysicalDeviceShaderCoreBuiltinsPropertiesARM";
|
||||
case StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT: return "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT";
|
||||
case StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT: return "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT";
|
||||
case StructureType::eLatencySleepModeInfoNV: return "LatencySleepModeInfoNV";
|
||||
case StructureType::eLatencySleepInfoNV: return "LatencySleepInfoNV";
|
||||
case StructureType::eSetLatencyMarkerInfoNV: return "SetLatencyMarkerInfoNV";
|
||||
case StructureType::eGetLatencyMarkerInfoNV: return "GetLatencyMarkerInfoNV";
|
||||
case StructureType::eLatencyTimingsFrameReportNV: return "LatencyTimingsFrameReportNV";
|
||||
case StructureType::eLatencySubmissionPresentIdNV: return "LatencySubmissionPresentIdNV";
|
||||
case StructureType::eOutOfBandQueueTypeInfoNV: return "OutOfBandQueueTypeInfoNV";
|
||||
case StructureType::eSwapchainLatencyCreateInfoNV: return "SwapchainLatencyCreateInfoNV";
|
||||
case StructureType::eLatencySurfaceCapabilitiesNV: return "LatencySurfaceCapabilitiesNV";
|
||||
case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR: return "PhysicalDeviceCooperativeMatrixFeaturesKHR";
|
||||
case StructureType::eCooperativeMatrixPropertiesKHR: return "CooperativeMatrixPropertiesKHR";
|
||||
case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR: return "PhysicalDeviceCooperativeMatrixPropertiesKHR";
|
||||
case StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM: return "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM";
|
||||
case StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM: return "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM";
|
||||
case StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM: return "PhysicalDeviceImageProcessing2FeaturesQCOM";
|
||||
case StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM: return "PhysicalDeviceImageProcessing2PropertiesQCOM";
|
||||
case StructureType::eSamplerBlockMatchWindowCreateInfoQCOM: return "SamplerBlockMatchWindowCreateInfoQCOM";
|
||||
case StructureType::eSamplerCubicWeightsCreateInfoQCOM: return "SamplerCubicWeightsCreateInfoQCOM";
|
||||
case StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM: return "PhysicalDeviceCubicWeightsFeaturesQCOM";
|
||||
case StructureType::eBlitImageCubicWeightsInfoQCOM: return "BlitImageCubicWeightsInfoQCOM";
|
||||
case StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM: return "PhysicalDeviceYcbcrDegammaFeaturesQCOM";
|
||||
case StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM: return "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM";
|
||||
case StructureType::ePhysicalDeviceCubicClampFeaturesQCOM: return "PhysicalDeviceCubicClampFeaturesQCOM";
|
||||
case StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT: return "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT";
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
case StructureType::eScreenBufferPropertiesQNX: return "ScreenBufferPropertiesQNX";
|
||||
|
@ -4426,6 +4489,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case StructureType::eExternalFormatQNX: return "ExternalFormatQNX";
|
||||
case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT: return "PhysicalDeviceLayeredDriverPropertiesMSFT";
|
||||
case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -5002,6 +5067,15 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
return "(void)";
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case DeviceQueueCreateFlagBits::eProtected: return "Protected";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineStageFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
|
@ -5323,6 +5397,15 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
return "(void)";
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case PipelineCacheCreateFlagBits::eExternallySynchronized: return "ExternallySynchronized";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( BlendFactor value )
|
||||
{
|
||||
switch ( value )
|
||||
|
@ -5697,6 +5780,25 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT: return "RasterizationOrderAttachmentAccessEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT: return "RasterizationOrderAttachmentDepthAccessEXT";
|
||||
case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits )
|
||||
{
|
||||
return "(void)";
|
||||
|
@ -5707,6 +5809,15 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
return "(void)";
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
|
||||
{
|
||||
return "(void)";
|
||||
|
@ -5802,6 +5913,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet";
|
||||
case DescriptorPoolCreateFlagBits::eUpdateAfterBind: return "UpdateAfterBind";
|
||||
case DescriptorPoolCreateFlagBits::eHostOnlyEXT: return "HostOnlyEXT";
|
||||
case DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV: return "AllowOverallocationSetsNV";
|
||||
case DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV: return "AllowOverallocationPoolsNV";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -6068,6 +6181,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{
|
||||
case SubpassContents::eInline: return "Inline";
|
||||
case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers";
|
||||
case SubpassContents::eInlineAndSecondaryCommandBuffersEXT: return "InlineAndSecondaryCommandBuffersEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -6139,15 +6253,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case DeviceQueueCreateFlagBits::eProtected: return "Protected";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrModelConversion value )
|
||||
{
|
||||
switch ( value )
|
||||
|
@ -6332,6 +6437,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case DriverId::eMesaDozen: return "MesaDozen";
|
||||
case DriverId::eMesaNvk: return "MesaNvk";
|
||||
case DriverId::eImaginationOpenSourceMESA: return "ImaginationOpenSourceMESA";
|
||||
case DriverId::eMesaAgxv: return "MesaAgxv";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -6368,6 +6474,9 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case ResolveModeFlagBits::eAverage: return "Average";
|
||||
case ResolveModeFlagBits::eMin: return "Min";
|
||||
case ResolveModeFlagBits::eMax: return "Max";
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
case ResolveModeFlagBits::eExternalFormatDownsampleANDROID: return "ExternalFormatDownsampleANDROID";
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -6379,6 +6488,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case SamplerReductionMode::eWeightedAverage: return "WeightedAverage";
|
||||
case SamplerReductionMode::eMin: return "Min";
|
||||
case SamplerReductionMode::eMax: return "Max";
|
||||
case SamplerReductionMode::eWeightedAverageRangeclampQCOM: return "WeightedAverageRangeclampQCOM";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -6556,6 +6666,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case RenderingFlagBits::eContentsSecondaryCommandBuffers: return "ContentsSecondaryCommandBuffers";
|
||||
case RenderingFlagBits::eSuspending: return "Suspending";
|
||||
case RenderingFlagBits::eResuming: return "Resuming";
|
||||
case RenderingFlagBits::eContentsInlineEXT: return "ContentsInlineEXT";
|
||||
case RenderingFlagBits::eEnableLegacyDitheringEXT: return "EnableLegacyDitheringEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
|
@ -6939,6 +7050,9 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case QueryResultStatusKHR::eError: return "Error";
|
||||
case QueryResultStatusKHR::eNotReady: return "NotReady";
|
||||
case QueryResultStatusKHR::eComplete: return "Complete";
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
case QueryResultStatusKHR::eInsufficientBitstreamBufferRange: return "InsufficientBitstreamBufferRange";
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -7036,6 +7150,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterDisabled: return "DeblockingFilterDisabled";
|
||||
case VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled: return "DeblockingFilterEnabled";
|
||||
case VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial";
|
||||
case VideoEncodeH264StdFlagBitsEXT::eSliceQpDelta: return "SliceQpDelta";
|
||||
case VideoEncodeH264StdFlagBitsEXT::eDifferentSliceQpDelta: return "DifferentSliceQpDelta";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -7098,6 +7214,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
case VideoEncodeH265StdFlagBitsEXT::eDeblockingFilterOverrideEnabledFlagSet: return "DeblockingFilterOverrideEnabledFlagSet";
|
||||
case VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentsEnabledFlagSet: return "DependentSliceSegmentsEnabledFlagSet";
|
||||
case VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet: return "DependentSliceSegmentFlagSet";
|
||||
case VideoEncodeH265StdFlagBitsEXT::eSliceQpDelta: return "SliceQpDelta";
|
||||
case VideoEncodeH265StdFlagBitsEXT::eDifferentSliceQpDelta: return "DifferentSliceQpDelta";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -8097,17 +8215,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
return "(void)";
|
||||
}
|
||||
|
||||
//=== VK_EXT_pipeline_creation_cache_control ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case PipelineCacheCreateFlagBits::eExternallySynchronized: return "ExternallySynchronized";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_KHR_video_encode_queue ===
|
||||
|
||||
|
@ -8116,6 +8223,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
switch ( value )
|
||||
{
|
||||
case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes: return "PrecedingExternallyEncodedBytes";
|
||||
case VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit: return "InsufficientstreamBufferRangeDetectionBit";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
@ -8238,15 +8346,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_NV_fragment_shading_rate_enums ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( FragmentShadingRateNV value )
|
||||
|
@ -8427,6 +8526,17 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
//=== VK_EXT_frame_boundary ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( FrameBoundaryFlagBitsEXT value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case FrameBoundaryFlagBitsEXT::eFrameEnd: return "FrameEnd";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
||||
//=== VK_QNX_screen_surface ===
|
||||
|
||||
|
@ -8580,27 +8690,6 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
return "(void)";
|
||||
}
|
||||
|
||||
//=== VK_EXT_rasterization_order_attachment_access ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT: return "RasterizationOrderAttachmentAccessEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT: return "RasterizationOrderAttachmentDepthAccessEXT";
|
||||
case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_NV_optical_flow ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( OpticalFlowUsageFlagBitsNV value )
|
||||
|
@ -8799,6 +8888,38 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
}
|
||||
|
||||
//=== VK_NV_low_latency2 ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( LatencyMarkerNV value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case LatencyMarkerNV::eSimulationStart: return "SimulationStart";
|
||||
case LatencyMarkerNV::eSimulationEnd: return "SimulationEnd";
|
||||
case LatencyMarkerNV::eRendersubmitStart: return "RendersubmitStart";
|
||||
case LatencyMarkerNV::eRendersubmitEnd: return "RendersubmitEnd";
|
||||
case LatencyMarkerNV::ePresentStart: return "PresentStart";
|
||||
case LatencyMarkerNV::ePresentEnd: return "PresentEnd";
|
||||
case LatencyMarkerNV::eInputSample: return "InputSample";
|
||||
case LatencyMarkerNV::eTriggerFlash: return "TriggerFlash";
|
||||
case LatencyMarkerNV::eOutOfBandRendersubmitStart: return "OutOfBandRendersubmitStart";
|
||||
case LatencyMarkerNV::eOutOfBandRendersubmitEnd: return "OutOfBandRendersubmitEnd";
|
||||
case LatencyMarkerNV::eOutOfBandPresentStart: return "OutOfBandPresentStart";
|
||||
case LatencyMarkerNV::eOutOfBandPresentEnd: return "OutOfBandPresentEnd";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( OutOfBandQueueTypeNV value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case OutOfBandQueueTypeNV::eRender: return "Render";
|
||||
case OutOfBandQueueTypeNV::ePresent: return "Present";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_KHR_cooperative_matrix ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( ScopeKHR value )
|
||||
|
@ -8832,5 +8953,43 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
}
|
||||
|
||||
//=== VK_QCOM_image_processing2 ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( BlockMatchWindowCompareModeQCOM value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case BlockMatchWindowCompareModeQCOM::eMin: return "Min";
|
||||
case BlockMatchWindowCompareModeQCOM::eMax: return "Max";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_QCOM_filter_cubic_weights ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( CubicFilterWeightsQCOM value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case CubicFilterWeightsQCOM::eCatmullRom: return "CatmullRom";
|
||||
case CubicFilterWeightsQCOM::eZeroTangentCardinal: return "ZeroTangentCardinal";
|
||||
case CubicFilterWeightsQCOM::eBSpline: return "BSpline";
|
||||
case CubicFilterWeightsQCOM::eMitchellNetravali: return "MitchellNetravali";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
//=== VK_MSFT_layered_driver ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( LayeredDriverUnderlyingApiMSFT value )
|
||||
{
|
||||
switch ( value )
|
||||
{
|
||||
case LayeredDriverUnderlyingApiMSFT::eNone: return "None";
|
||||
case LayeredDriverUnderlyingApiMSFT::eD3D12: return "D3D12";
|
||||
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
#endif
|
||||
|
|
|
@ -1028,9 +1028,9 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
|
||||
bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ( operation == rhs.operation ) && ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) &&
|
||||
( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) &&
|
||||
( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 );
|
||||
return ( memory_management_control_operation == rhs.memory_management_control_operation ) &&
|
||||
( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && ( long_term_pic_num == rhs.long_term_pic_num ) &&
|
||||
( long_term_frame_idx == rhs.long_term_frame_idx ) && ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 );
|
||||
}
|
||||
|
||||
bool operator!=( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
|
@ -1039,7 +1039,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
}
|
||||
|
||||
public:
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp operation =
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp memory_management_control_operation =
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp::eEnd;
|
||||
uint16_t difference_of_pic_nums_minus1 = {};
|
||||
uint16_t long_term_pic_num = {};
|
||||
|
@ -1185,7 +1185,7 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
{
|
||||
return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) &&
|
||||
( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) &&
|
||||
( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) &&
|
||||
( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) &&
|
||||
( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && ( pWeightTable == rhs.pWeightTable );
|
||||
}
|
||||
|
||||
|
@ -1200,7 +1200,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType::eP;
|
||||
int8_t slice_alpha_c0_offset_div2 = {};
|
||||
int8_t slice_beta_offset_div2 = {};
|
||||
uint16_t reserved1 = {};
|
||||
int8_t slice_qp_delta = {};
|
||||
uint8_t reserved1 = {};
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc cabac_init_idc =
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc::e0;
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc disable_deblocking_filter_idc =
|
||||
|
@ -2416,7 +2417,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) &&
|
||||
( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) &&
|
||||
( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) &&
|
||||
( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( reserved1 == rhs.reserved1 ) && ( pWeightTable == rhs.pWeightTable );
|
||||
( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) &&
|
||||
( pWeightTable == rhs.pWeightTable );
|
||||
}
|
||||
|
||||
bool operator!=( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
|
@ -2437,7 +2439,8 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
int8_t slice_act_y_qp_offset = {};
|
||||
int8_t slice_act_cb_qp_offset = {};
|
||||
int8_t slice_act_cr_qp_offset = {};
|
||||
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {};
|
||||
int8_t slice_qp_delta = {};
|
||||
uint16_t reserved1 = {};
|
||||
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable * pWeightTable = {};
|
||||
};
|
||||
|
||||
|
@ -2550,28 +2553,28 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
uint32_t reserved : 23;
|
||||
};
|
||||
|
||||
struct EncodeH265SliceSegmentLongTermRefPics
|
||||
struct EncodeH265LongTermRefPics
|
||||
{
|
||||
using NativeType = StdVideoEncodeH265SliceSegmentLongTermRefPics;
|
||||
using NativeType = StdVideoEncodeH265LongTermRefPics;
|
||||
|
||||
operator StdVideoEncodeH265SliceSegmentLongTermRefPics const &() const VULKAN_HPP_NOEXCEPT
|
||||
operator StdVideoEncodeH265LongTermRefPics const &() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentLongTermRefPics *>( this );
|
||||
return *reinterpret_cast<const StdVideoEncodeH265LongTermRefPics *>( this );
|
||||
}
|
||||
|
||||
operator StdVideoEncodeH265SliceSegmentLongTermRefPics &() VULKAN_HPP_NOEXCEPT
|
||||
operator StdVideoEncodeH265LongTermRefPics &() VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return *reinterpret_cast<StdVideoEncodeH265SliceSegmentLongTermRefPics *>( this );
|
||||
return *reinterpret_cast<StdVideoEncodeH265LongTermRefPics *>( this );
|
||||
}
|
||||
|
||||
bool operator==( EncodeH265SliceSegmentLongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
bool operator==( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return ( num_long_term_sps == rhs.num_long_term_sps ) && ( num_long_term_pics == rhs.num_long_term_pics ) && ( lt_idx_sps == rhs.lt_idx_sps ) &&
|
||||
( poc_lsb_lt == rhs.poc_lsb_lt ) && ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) &&
|
||||
( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt );
|
||||
}
|
||||
|
||||
bool operator!=( EncodeH265SliceSegmentLongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
bool operator!=( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return !operator==( rhs );
|
||||
}
|
||||
|
@ -2617,16 +2620,16 @@ namespace VULKAN_HPP_NAMESPACE
|
|||
public:
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags flags = {};
|
||||
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP;
|
||||
uint8_t sps_video_parameter_set_id = {};
|
||||
uint8_t pps_seq_parameter_set_id = {};
|
||||
uint8_t pps_pic_parameter_set_id = {};
|
||||
uint8_t short_term_ref_pic_set_idx = {};
|
||||
int32_t PicOrderCntVal = {};
|
||||
uint8_t TemporalId = {};
|
||||
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {};
|
||||
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {};
|
||||
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {};
|
||||
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentLongTermRefPics * pLongTermRefPics = {};
|
||||
uint8_t sps_video_parameter_set_id = {};
|
||||
uint8_t pps_seq_parameter_set_id = {};
|
||||
uint8_t pps_pic_parameter_set_id = {};
|
||||
uint8_t short_term_ref_pic_set_idx = {};
|
||||
int32_t PicOrderCntVal = {};
|
||||
uint8_t TemporalId = {};
|
||||
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {};
|
||||
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {};
|
||||
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {};
|
||||
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics * pLongTermRefPics = {};
|
||||
};
|
||||
|
||||
struct EncodeH265ReferenceInfoFlags
|
||||
|
|
1068
thirdparty/vulkan/vk_enum_string_helper.h
vendored
1068
thirdparty/vulkan/vk_enum_string_helper.h
vendored
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue