mirror of
https://github.com/KhronosGroup/Vulkan-Hpp.git
synced 2024-10-14 16:32:17 +00:00
Correct actual function called by aliased member functions
This commit is contained in:
asuessenbach
Markus Tavenrath
parent
0ea8a527ba
commit
732274919b
@ -978,38 +978,38 @@ void VulkanHppGenerator::appendBitmaskToStringFunction(std::string & str, std::s
|
||||
str += " }\n";
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendCall(std::string & str, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool firstCall, bool singular) const
|
||||
void VulkanHppGenerator::appendCall(std::string & str, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool firstCall, bool singular) const
|
||||
{
|
||||
// the original function call
|
||||
str += "d." + commandData.first + "( ";
|
||||
str += "d." + name + "( ";
|
||||
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(commandData.first)->second;
|
||||
assert(m_commandToHandle.find(name) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(name)->second;
|
||||
if (!handle.empty())
|
||||
{
|
||||
// if it's member of a class -> the first argument is the member variable, starting with "m_"
|
||||
assert(handle == commandData.second.params[0].type.type);
|
||||
assert(handle == commandData.params[0].type.type);
|
||||
str += "m_" + startLowerCase(stripPrefix(handle, "Vk"));
|
||||
if (1 < commandData.second.params.size())
|
||||
if (1 < commandData.params.size())
|
||||
{
|
||||
str += ", ";
|
||||
}
|
||||
}
|
||||
|
||||
appendArguments(str, commandData.second, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, firstCall, singular, handle.empty() ? 0 : 1, commandData.second.params.size());
|
||||
appendArguments(str, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, firstCall, singular, handle.empty() ? 0 : 1, commandData.params.size());
|
||||
str += " )";
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendCommand(std::string & str, std::string const& indentation, std::string const& name, std::pair<std::string, CommandData> const& commandData, bool definition) const
|
||||
void VulkanHppGenerator::appendCommand(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, bool definition) const
|
||||
{
|
||||
bool twoStep = isTwoStepAlgorithm(commandData.second.params);
|
||||
std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices(commandData.second.params);
|
||||
bool twoStep = isTwoStepAlgorithm(commandData.params);
|
||||
std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices(commandData.params);
|
||||
|
||||
size_t returnParamIndex = determineReturnParamIndex(commandData.second, vectorParamIndices, twoStep);
|
||||
bool isStructureChain = (returnParamIndex != INVALID_INDEX) && determineStructureChaining(commandData.second.params[returnParamIndex].type.type, m_extendedStructs, m_structureAliases);
|
||||
std::string enhancedReturnType = determineEnhancedReturnType(commandData.second, returnParamIndex, vectorParamIndices, false); // get the enhanced return type without structureChain
|
||||
size_t returnParamIndex = determineReturnParamIndex(commandData, vectorParamIndices, twoStep);
|
||||
bool isStructureChain = (returnParamIndex != INVALID_INDEX) && determineStructureChaining(commandData.params[returnParamIndex].type.type, m_extendedStructs, m_structureAliases);
|
||||
std::string enhancedReturnType = determineEnhancedReturnType(commandData, returnParamIndex, vectorParamIndices, false); // get the enhanced return type without structureChain
|
||||
|
||||
size_t templateParamIndex = determineTemplateParamIndex(commandData.second.params, vectorParamIndices);
|
||||
size_t templateParamIndex = determineTemplateParamIndex(commandData.params, vectorParamIndices);
|
||||
|
||||
// first create the standard version of the function
|
||||
std::string standard;
|
||||
@ -1026,7 +1026,7 @@ void VulkanHppGenerator::appendCommand(std::string & str, std::string const& ind
|
||||
|
||||
if (isStructureChain)
|
||||
{
|
||||
std::string enhancedReturnTypeWithStructureChain = determineEnhancedReturnType(commandData.second, returnParamIndex, vectorParamIndices, true);
|
||||
std::string enhancedReturnTypeWithStructureChain = determineEnhancedReturnType(commandData, returnParamIndex, vectorParamIndices, true);
|
||||
appendFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnTypeWithStructureChain, definition, true, false, false, true, false);
|
||||
|
||||
if (enhancedReturnTypeWithStructureChain.find("Allocator") != std::string::npos)
|
||||
@ -1039,23 +1039,23 @@ void VulkanHppGenerator::appendCommand(std::string & str, std::string const& ind
|
||||
std::map<size_t, size_t>::const_iterator returnVector = vectorParamIndices.find(returnParamIndex);
|
||||
bool singular = (returnVector != vectorParamIndices.end()) &&
|
||||
(returnVector->second != INVALID_INDEX) &&
|
||||
(commandData.second.params[returnVector->first].type.type != "void") &&
|
||||
(commandData.second.params[returnVector->second].type.postfix.empty() || (commandData.second.params[returnVector->second].type.postfix.back() != '*'));
|
||||
(commandData.params[returnVector->first].type.type != "void") &&
|
||||
(commandData.params[returnVector->second].type.postfix.empty() || (commandData.params[returnVector->second].type.postfix.back() != '*'));
|
||||
if (singular)
|
||||
{
|
||||
appendFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, definition, true, true, false, false, false);
|
||||
}
|
||||
|
||||
// special handling for createDevice and createInstance !
|
||||
bool specialWriteUnique = (commandData.first == "vkCreateDevice") || (commandData.first == "vkCreateInstance");
|
||||
bool specialWriteUnique = (name == "vkCreateDevice") || (name == "vkCreateInstance");
|
||||
|
||||
// and then the same for the Unique* versions (a deleteCommand is available for the commandData's class, and the function starts with 'allocate' or 'create')
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
auto handleIt = m_handles.find(m_commandToHandle.find(commandData.first)->second);
|
||||
assert(m_commandToHandle.find(name) != m_commandToHandle.end());
|
||||
auto handleIt = m_handles.find(m_commandToHandle.find(name)->second);
|
||||
assert(handleIt != m_handles.end());
|
||||
if ((!handleIt->second.deleteCommand.empty() || specialWriteUnique)
|
||||
&& ((commandData.first.substr(2, 8) == "Allocate") || (commandData.first.substr(2, 6) == "Create")
|
||||
|| ((commandData.first.substr(2, 8) == "Register") && (returnParamIndex + 1 == commandData.second.params.size()))))
|
||||
&& ((name.substr(2, 8) == "Allocate") || (name.substr(2, 6) == "Create")
|
||||
|| ((name.substr(2, 8) == "Register") && (returnParamIndex + 1 == commandData.params.size()))))
|
||||
{
|
||||
enhanced += "#ifndef VULKAN_HPP_NO_SMART_HANDLE\n";
|
||||
appendFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, definition, true, false, true, false, false);
|
||||
@ -1574,34 +1574,35 @@ bool needsMultiVectorSizeCheck(size_t returnParamIndex, std::map<size_t, size_t>
|
||||
return false;
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunction(std::string & str, std::string const& indentation, std::string const& name, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool definition, bool enhanced, bool singular, bool unique, bool isStructureChain, bool withAllocator) const
|
||||
void VulkanHppGenerator::appendFunction(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool definition, bool enhanced, bool singular, bool unique, bool isStructureChain, bool withAllocator) const
|
||||
{
|
||||
appendFunctionHeaderTemplate(str, indentation, returnParamIndex, templateParamIndex, enhancedReturnType, enhanced, singular, unique, !definition, isStructureChain);
|
||||
|
||||
str += indentation + (definition ? "VULKAN_HPP_INLINE " : "");
|
||||
|
||||
appendFunctionHeaderReturnType(str, commandData.second, returnParamIndex, vectorParamIndices, enhancedReturnType, enhanced, twoStep, singular, unique, isStructureChain);
|
||||
appendFunctionHeaderReturnType(str, commandData, returnParamIndex, vectorParamIndices, enhancedReturnType, enhanced, twoStep, singular, unique, isStructureChain);
|
||||
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(commandData.first)->second;
|
||||
assert(m_commandToHandle.find(name) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(name)->second;
|
||||
if (definition && !handle.empty())
|
||||
{
|
||||
str += stripPrefix(handle, "Vk") + "::";
|
||||
}
|
||||
|
||||
// append the function header name
|
||||
str += (singular ? stripPluralS(name) : name);
|
||||
std::string commandName = determineCommandName(name, commandData.params[0].type.type);
|
||||
str += (singular ? stripPluralS(commandName) : commandName);
|
||||
if (unique)
|
||||
{
|
||||
str += "Unique";
|
||||
}
|
||||
|
||||
appendFunctionHeaderArguments(str, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, enhanced, singular, !definition, withAllocator);
|
||||
appendFunctionHeaderArguments(str, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, enhanced, singular, !definition, withAllocator);
|
||||
|
||||
// Any function that originally does not return VkResult can be marked noexcept,
|
||||
// if it is enhanced it must not include anything with an Allocator or needs size checks on multiple vectors
|
||||
bool hasAllocator = enhancedReturnType.find("Allocator") != std::string::npos;
|
||||
if (!enhanced || (commandData.second.returnType != "VkResult" && !(enhanced && (hasAllocator || needsMultiVectorSizeCheck(returnParamIndex, vectorParamIndices)))))
|
||||
if (!enhanced || (commandData.returnType != "VkResult" && !(enhanced && (hasAllocator || needsMultiVectorSizeCheck(returnParamIndex, vectorParamIndices)))))
|
||||
{
|
||||
str += " VULKAN_HPP_NOEXCEPT";
|
||||
}
|
||||
@ -1618,49 +1619,49 @@ void VulkanHppGenerator::appendFunction(std::string & str, std::string const& in
|
||||
}
|
||||
else
|
||||
{
|
||||
appendFunctionBodyStandard(str, indentation, commandData);
|
||||
appendFunctionBodyStandard(str, indentation, name, commandData);
|
||||
}
|
||||
str += indentation + "}\n";
|
||||
}
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhanced(std::string & str, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool singular, bool unique, bool isStructureChain, bool withAllocator) const
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhanced(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool singular, bool unique, bool isStructureChain, bool withAllocator) const
|
||||
{
|
||||
if (unique && !singular && (vectorParamIndices.find(returnParamIndex) != vectorParamIndices.end())) // returns a vector of UniqueStuff
|
||||
{
|
||||
appendFunctionBodyEnhancedVectorOfUniqueHandles(str, indentation, commandName, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, singular, withAllocator);
|
||||
appendFunctionBodyEnhancedVectorOfUniqueHandles(str, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, singular, withAllocator);
|
||||
}
|
||||
else if (isStructureChain && (vectorParamIndices.find(returnParamIndex) != vectorParamIndices.end()))
|
||||
{
|
||||
appendFunctionBodyEnhancedVectorOfStructureChain(str, indentation, commandData, returnParamIndex, vectorParamIndices, withAllocator);
|
||||
appendFunctionBodyEnhancedVectorOfStructureChain(str, indentation, name, commandData, returnParamIndex, vectorParamIndices, withAllocator);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (1 < vectorParamIndices.size())
|
||||
{
|
||||
appendFunctionBodyEnhancedMultiVectorSizeCheck(str, indentation, commandName, commandData, returnParamIndex, vectorParamIndices);
|
||||
appendFunctionBodyEnhancedMultiVectorSizeCheck(str, indentation, name, commandData, returnParamIndex, vectorParamIndices);
|
||||
}
|
||||
|
||||
std::string returnName;
|
||||
if (returnParamIndex != INVALID_INDEX)
|
||||
{
|
||||
returnName = appendFunctionBodyEnhancedLocalReturnVariable(str, indentation, commandData.second, returnParamIndex, vectorParamIndices, twoStep, enhancedReturnType, singular, isStructureChain, withAllocator);
|
||||
returnName = appendFunctionBodyEnhancedLocalReturnVariable(str, indentation, commandData, returnParamIndex, vectorParamIndices, twoStep, enhancedReturnType, singular, isStructureChain, withAllocator);
|
||||
}
|
||||
|
||||
if (twoStep)
|
||||
{
|
||||
appendFunctionBodyEnhancedTwoStep(str, indentation, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, singular, returnName);
|
||||
appendFunctionBodyEnhancedTwoStep(str, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, singular, returnName);
|
||||
}
|
||||
else
|
||||
{
|
||||
appendFunctionBodyEnhancedSingleStep(str, indentation, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, singular);
|
||||
appendFunctionBodyEnhancedSingleStep(str, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, singular);
|
||||
}
|
||||
|
||||
if ((commandData.second.returnType == "VkResult") || !commandData.second.successCodes.empty())
|
||||
if ((commandData.returnType == "VkResult") || !commandData.successCodes.empty())
|
||||
{
|
||||
appendFunctionBodyEnhancedReturnResultValue(str, indentation, returnName, commandName, commandData, returnParamIndex, twoStep, singular, unique);
|
||||
appendFunctionBodyEnhancedReturnResultValue(str, indentation, returnName, name, commandData, returnParamIndex, twoStep, singular, unique);
|
||||
}
|
||||
else if ((returnParamIndex != INVALID_INDEX) && (stripPrefix(commandData.second.returnType, "Vk") != enhancedReturnType))
|
||||
else if ((returnParamIndex != INVALID_INDEX) && (stripPrefix(commandData.returnType, "Vk") != enhancedReturnType))
|
||||
{
|
||||
// for the other returning cases, when the return type is somhow enhanced, just return the local returnVariable
|
||||
str += indentation + " return " + returnName + ";\n";
|
||||
@ -1756,7 +1757,7 @@ void VulkanHppGenerator::appendFunctionBodyEnhancedLocalReturnVariableVectorSize
|
||||
str += "( " + size + (withAllocator ? ", vectorAllocator" : "") + " )";
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedMultiVectorSizeCheck(std::string & str, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices) const
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedMultiVectorSizeCheck(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices) const
|
||||
{
|
||||
std::string const sizeCheckTemplate =
|
||||
R"#(#ifdef VULKAN_HPP_NO_EXCEPTIONS
|
||||
@ -1769,10 +1770,11 @@ ${i} }
|
||||
#endif /*VULKAN_HPP_NO_EXCEPTIONS*/
|
||||
)#";
|
||||
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(commandData.first)->second;
|
||||
assert(m_commandToHandle.find(name) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(name)->second;
|
||||
|
||||
// add some error checks if multiple vectors need to have the same size
|
||||
std::string commandName = determineCommandName(name, commandData.params[0].type.type);
|
||||
for (std::map<size_t, size_t>::const_iterator it0 = vectorParamIndices.begin(); it0 != vectorParamIndices.end(); ++it0)
|
||||
{
|
||||
if (it0->first != returnParamIndex)
|
||||
@ -1782,8 +1784,8 @@ ${i} }
|
||||
if ((it1->first != returnParamIndex) && (it0->second == it1->second))
|
||||
{
|
||||
str += replaceWithMap(sizeCheckTemplate, std::map<std::string, std::string>({
|
||||
{ "firstVectorName", startLowerCase(stripPrefix(commandData.second.params[it0->first].name, "p")) },
|
||||
{ "secondVectorName", startLowerCase(stripPrefix(commandData.second.params[it1->first].name, "p")) },
|
||||
{ "firstVectorName", startLowerCase(stripPrefix(commandData.params[it0->first].name, "p")) },
|
||||
{ "secondVectorName", startLowerCase(stripPrefix(commandData.params[it1->first].name, "p")) },
|
||||
{ "className", handle },
|
||||
{ "commandName", commandName },
|
||||
{ "i", indentation }
|
||||
@ -1794,27 +1796,29 @@ ${i} }
|
||||
}
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedReturnResultValue(std::string & str, std::string const& indentation, std::string const& returnName, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, bool twoStep, bool singular, bool unique) const
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedReturnResultValue(std::string & str, std::string const& indentation, std::string const& returnName, std::string const& name, CommandData const& commandData, size_t returnParamIndex, bool twoStep, bool singular, bool unique) const
|
||||
{
|
||||
std::string type = (returnParamIndex != INVALID_INDEX) ? commandData.second.params[returnParamIndex].type.type : "";
|
||||
std::string returnVectorName = (returnParamIndex != INVALID_INDEX) ? stripPostfix(stripPrefix(commandData.second.params[returnParamIndex].name, "p"), "s") : "";
|
||||
std::string type = (returnParamIndex != INVALID_INDEX) ? commandData.params[returnParamIndex].type.type : "";
|
||||
std::string returnVectorName = (returnParamIndex != INVALID_INDEX) ? stripPostfix(stripPrefix(commandData.params[returnParamIndex].name, "p"), "s") : "";
|
||||
std::string commandName = determineCommandName(name, commandData.params[0].type.type);
|
||||
|
||||
if (commandData.second.returnType == "void") {
|
||||
if (commandData.returnType == "void")
|
||||
{
|
||||
std::cerr << "warning: skipping appendFunctionBodyEnhancedReturnResultValue for function " << commandName << " because the returnType is void";
|
||||
return;
|
||||
}
|
||||
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(commandData.first)->second;
|
||||
assert(m_commandToHandle.find(name) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(name)->second;
|
||||
|
||||
if (unique)
|
||||
{
|
||||
// the unique version needs a Deleter object for destruction of the newly created stuff
|
||||
// get the DeleterData corresponding to the returned type
|
||||
// special handling for "createDevice", as Device is created from PhysicalDevice, but destroyed on its own
|
||||
bool noParent = handle.empty() || (commandData.first == "vkCreateDevice");
|
||||
bool noParent = handle.empty() || (name == "vkCreateDevice");
|
||||
str += "\n"
|
||||
+ indentation + ((commandData.first == "vkAllocateMemory") ? " ObjectFree<" : " ObjectDestroy<") + (noParent ? "NoParent" : stripPrefix(handle, "Vk")) + ",Dispatch> deleter( " + (noParent ? "" : "*this, ") + "allocator, d );\n"
|
||||
+ indentation + ((name == "vkAllocateMemory") ? " ObjectFree<" : " ObjectDestroy<") + (noParent ? "NoParent" : stripPrefix(handle, "Vk")) + ",Dispatch> deleter( " + (noParent ? "" : "*this, ") + "allocator, d );\n"
|
||||
+ indentation + " return createResultValue<" + stripPrefix(type, "Vk") + ",Dispatch>( result, ";
|
||||
}
|
||||
else
|
||||
@ -1832,13 +1836,13 @@ void VulkanHppGenerator::appendFunctionBodyEnhancedReturnResultValue(std::string
|
||||
// now the function name (with full namespace) as a string
|
||||
str += "VULKAN_HPP_NAMESPACE_STRING\"::" + (handle.empty() ? "" : stripPrefix(handle, "Vk") + "::") + (singular ? stripPluralS(commandName) : commandName) + (unique ? "Unique" : "") + "\"";
|
||||
|
||||
if (!twoStep && (1 < commandData.second.successCodes.size()))
|
||||
if (!twoStep && (1 < commandData.successCodes.size()))
|
||||
{
|
||||
// and for the single-step algorithms with more than one success code list them all
|
||||
str += ", { Result::" + createSuccessCode(commandData.second.successCodes[0], m_tags);
|
||||
for (size_t i = 1; i < commandData.second.successCodes.size(); i++)
|
||||
str += ", { Result::" + createSuccessCode(commandData.successCodes[0], m_tags);
|
||||
for (size_t i = 1; i < commandData.successCodes.size(); i++)
|
||||
{
|
||||
str += ", Result::" + createSuccessCode(commandData.second.successCodes[i], m_tags);
|
||||
str += ", Result::" + createSuccessCode(commandData.successCodes[i], m_tags);
|
||||
}
|
||||
str += " }";
|
||||
}
|
||||
@ -1851,29 +1855,29 @@ void VulkanHppGenerator::appendFunctionBodyEnhancedReturnResultValue(std::string
|
||||
str += " );\n";
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedSingleStep(std::string & str, std::string const& indentation, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular) const
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedSingleStep(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular) const
|
||||
{
|
||||
str += indentation + " ";
|
||||
if (commandData.second.returnType == "VkResult")
|
||||
if (commandData.returnType == "VkResult")
|
||||
{
|
||||
str += "Result result = static_cast<Result>( ";
|
||||
}
|
||||
else if (commandData.second.returnType != "void")
|
||||
else if (commandData.returnType != "void")
|
||||
{
|
||||
str += "return ";
|
||||
}
|
||||
appendCall(str, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, false, true, singular);
|
||||
if (commandData.second.returnType == "VkResult")
|
||||
appendCall(str, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, false, true, singular);
|
||||
if (commandData.returnType == "VkResult")
|
||||
{
|
||||
str += " )";
|
||||
}
|
||||
str += ";\n";
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedTwoStep(std::string & str, std::string const& indentation, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, std::string const& returnName) const
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedTwoStep(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, std::string const& returnName) const
|
||||
{
|
||||
assert(!singular);
|
||||
assert((commandData.second.returnType == "VkResult") || (commandData.second.returnType == "void"));
|
||||
assert((commandData.returnType == "VkResult") || (commandData.returnType == "void"));
|
||||
assert(returnParamIndex != INVALID_INDEX);
|
||||
|
||||
// local count variable to hold the size of the vector to fill
|
||||
@ -1881,8 +1885,8 @@ void VulkanHppGenerator::appendFunctionBodyEnhancedTwoStep(std::string & str, st
|
||||
assert(returnit != vectorParamIndices.end() && (returnit->second != INVALID_INDEX));
|
||||
|
||||
// take the pure type of the size parameter; strip the leading 'p' from its name for its local name
|
||||
std::string sizeName = startLowerCase(stripPrefix(commandData.second.params[returnit->second].name, "p"));
|
||||
str += indentation + " " + stripPrefix(commandData.second.params[returnit->second].type.type, "Vk") + " " + sizeName + ";\n";
|
||||
std::string sizeName = startLowerCase(stripPrefix(commandData.params[returnit->second].name, "p"));
|
||||
str += indentation + " " + stripPrefix(commandData.params[returnit->second].type.type, "Vk") + " " + sizeName + ";\n";
|
||||
|
||||
std::string const multiSuccessTemplate =
|
||||
R"(${i} Result result;
|
||||
@ -1914,11 +1918,11 @@ ${i} }
|
||||
${i} ${returnName}.resize( ${sizeName} );
|
||||
${i} ${call2};
|
||||
)";
|
||||
std::string const& selectedTemplate = (commandData.second.returnType == "VkResult") ? ((1 < commandData.second.successCodes.size()) ? multiSuccessTemplate : singleSuccessTemplate) : voidMultiCallTemplate;
|
||||
std::string const& selectedTemplate = (commandData.returnType == "VkResult") ? ((1 < commandData.successCodes.size()) ? multiSuccessTemplate : singleSuccessTemplate) : voidMultiCallTemplate;
|
||||
|
||||
std::string call1, call2;
|
||||
appendCall(call1, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, true, true, false);
|
||||
appendCall(call2, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, true, false, false);
|
||||
appendCall(call1, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, true, true, false);
|
||||
appendCall(call2, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, true, false, false);
|
||||
|
||||
str += replaceWithMap(selectedTemplate,
|
||||
{
|
||||
@ -1930,7 +1934,7 @@ ${i} ${call2};
|
||||
});
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedVectorOfStructureChain(std::string & str, std::string const& indentation, std::pair<std::string,CommandData> const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool withAllocator) const
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedVectorOfStructureChain(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool withAllocator) const
|
||||
{
|
||||
std::string const stringTemplate =
|
||||
R"(${i} std::vector<StructureChain,Allocator> ${returnName}${vectorAllocator};
|
||||
@ -1954,23 +1958,23 @@ ${i} return ${returnName};
|
||||
std::map<size_t, size_t>::const_iterator returnit = vectorParamIndices.find(returnParamIndex);
|
||||
assert(returnit != vectorParamIndices.end() && (returnit->second != INVALID_INDEX));
|
||||
|
||||
assert(m_commandToHandle.find(commandData.first)->second == commandData.second.params[0].type.type); // make sure, the first argument is the handle
|
||||
assert(commandData.second.params.size() == 3); // make sure, there are three args: the handle, the pointer to size, and the data pointer
|
||||
assert(m_commandToHandle.find(name)->second == commandData.params[0].type.type); // make sure, the first argument is the handle
|
||||
assert(commandData.params.size() == 3); // make sure, there are three args: the handle, the pointer to size, and the data pointer
|
||||
|
||||
str += replaceWithMap(stringTemplate,
|
||||
{
|
||||
{ "commandName", commandData.first},
|
||||
{ "handleName", startLowerCase(stripPrefix(commandData.second.params[0].type.type, "Vk")) },
|
||||
{ "commandName", name},
|
||||
{ "handleName", startLowerCase(stripPrefix(commandData.params[0].type.type, "Vk")) },
|
||||
{ "i", indentation },
|
||||
{ "returnName", startLowerCase(stripPrefix(commandData.second.params[returnParamIndex].name, "p")) },
|
||||
{ "returnType", stripPrefix(commandData.second.params[returnParamIndex].type.type, "Vk")},
|
||||
{ "sizeName", startLowerCase(stripPrefix(commandData.second.params[returnit->second].name, "p"))},
|
||||
{ "returnName", startLowerCase(stripPrefix(commandData.params[returnParamIndex].name, "p")) },
|
||||
{ "returnType", stripPrefix(commandData.params[returnParamIndex].type.type, "Vk")},
|
||||
{ "sizeName", startLowerCase(stripPrefix(commandData.params[returnit->second].name, "p"))},
|
||||
{ "vectorAllocator", withAllocator ? "( vectorAllocator )" : "" },
|
||||
{ "VkReturnType", commandData.second.params[returnParamIndex].type.type}
|
||||
{ "VkReturnType", commandData.params[returnParamIndex].type.type}
|
||||
});
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedVectorOfUniqueHandles(std::string & str, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool singular, bool withAllocator) const
|
||||
void VulkanHppGenerator::appendFunctionBodyEnhancedVectorOfUniqueHandles(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool singular, bool withAllocator) const
|
||||
{
|
||||
std::string const stringTemplate =
|
||||
R"(${i} static_assert( sizeof( ${type} ) <= sizeof( UniqueHandle<${type}, Dispatch> ), "${type} is greater than UniqueHandle<${type}, Dispatch>!" );
|
||||
@ -1990,39 +1994,40 @@ ${i} }
|
||||
${i} return createResultValue( result, ${typeVariable}s, VULKAN_HPP_NAMESPACE_STRING "::${class}::${commandName}Unique"${successCodes} );
|
||||
)";
|
||||
|
||||
std::string type = (returnParamIndex != INVALID_INDEX) ? commandData.second.params[returnParamIndex].type.type : "";
|
||||
std::string type = (returnParamIndex != INVALID_INDEX) ? commandData.params[returnParamIndex].type.type : "";
|
||||
std::string typeVariable = startLowerCase(stripPrefix(type, "Vk"));
|
||||
std::string arguments;
|
||||
appendArguments(arguments, commandData.second, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, true, singular, 1, commandData.second.params.size() - 1);
|
||||
appendArguments(arguments, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, true, singular, 1, commandData.params.size() - 1);
|
||||
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(commandData.first)->second;
|
||||
assert(m_commandToHandle.find(name) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(name)->second;
|
||||
|
||||
auto handleIt = m_handles.find(type);
|
||||
assert(handleIt != m_handles.end());
|
||||
|
||||
assert(!commandData.second.successCodes.empty());
|
||||
std::string successChecks = "result == VULKAN_HPP_NAMESPACE::Result::" + createSuccessCode(commandData.second.successCodes[0], m_tags);
|
||||
assert(!commandData.successCodes.empty());
|
||||
std::string successChecks = "result == VULKAN_HPP_NAMESPACE::Result::" + createSuccessCode(commandData.successCodes[0], m_tags);
|
||||
std::string successCodes;
|
||||
if (1 < commandData.second.successCodes.size())
|
||||
if (1 < commandData.successCodes.size())
|
||||
{
|
||||
successChecks = "( " + successChecks + " )";
|
||||
successCodes = ", { VULKAN_HPP_NAMESPACE::Result::" + createSuccessCode(commandData.second.successCodes[0], m_tags);
|
||||
for (size_t i = 1; i < commandData.second.successCodes.size(); i++)
|
||||
successCodes = ", { VULKAN_HPP_NAMESPACE::Result::" + createSuccessCode(commandData.successCodes[0], m_tags);
|
||||
for (size_t i = 1; i < commandData.successCodes.size(); i++)
|
||||
{
|
||||
successChecks += " || ( result == VULKAN_HPP_NAMESPACE::Result::" + createSuccessCode(commandData.second.successCodes[i], m_tags) + " )";
|
||||
successCodes += ", VULKAN_HPP_NAMESPACE::Result::" + createSuccessCode(commandData.second.successCodes[i], m_tags);
|
||||
successChecks += " || ( result == VULKAN_HPP_NAMESPACE::Result::" + createSuccessCode(commandData.successCodes[i], m_tags) + " )";
|
||||
successCodes += ", VULKAN_HPP_NAMESPACE::Result::" + createSuccessCode(commandData.successCodes[i], m_tags);
|
||||
}
|
||||
successCodes += " }";
|
||||
}
|
||||
|
||||
bool isCreateFunction = (commandData.first.substr(2, 6) == "Create");
|
||||
std::string commandName = determineCommandName(name, commandData.params[0].type.type);
|
||||
bool isCreateFunction = (name.substr(2, 6) == "Create");
|
||||
str += replaceWithMap(stringTemplate, std::map<std::string, std::string>
|
||||
{
|
||||
{ "allocator", withAllocator ? "( vectorAllocator )" : "" },
|
||||
{ "arguments", arguments },
|
||||
{ "class", stripPrefix(handle, "Vk") },
|
||||
{ "command", stripPrefix(commandData.first, "vk") },
|
||||
{ "command", stripPrefix(name, "vk") },
|
||||
{ "commandName", commandName },
|
||||
{ "Deleter", handleIt->second.deletePool.empty() ? "ObjectDestroy" : "PoolFree" },
|
||||
{ "deleterArg", handleIt->second.deletePool.empty() ? "allocator" : "allocateInfo." + startLowerCase(stripPrefix(handleIt->second.deletePool, "Vk")) },
|
||||
@ -2036,22 +2041,22 @@ ${i} return createResultValue( result, ${typeVariable}s, VULKAN_HPP_NAMESPACE_S
|
||||
});
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionBodyStandard(std::string & str, std::string const& indentation, std::pair<std::string, CommandData> const& commandData) const
|
||||
void VulkanHppGenerator::appendFunctionBodyStandard(std::string & str, std::string const& indentation, std::string const& commandName, CommandData const& commandData) const
|
||||
{
|
||||
std::pair<bool, std::string> returnData = generateFunctionBodyStandardReturn(commandData.second.returnType);
|
||||
std::pair<bool, std::string> returnData = generateFunctionBodyStandardReturn(commandData.returnType);
|
||||
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(commandData.first)->second;
|
||||
assert(handle.empty() || (handle == commandData.second.params[0].type.type));
|
||||
assert(m_commandToHandle.find(commandName) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(commandName)->second;
|
||||
assert(handle.empty() || (handle == commandData.params[0].type.type));
|
||||
|
||||
str += indentation + " " + returnData.second + "d." + commandData.first + "( " + (handle.empty() ? "" : ("m_" + startLowerCase(stripPrefix(handle, "Vk"))));
|
||||
for (size_t i = handle.empty() ? 0 : 1; i < commandData.second.params.size(); i++)
|
||||
str += indentation + " " + returnData.second + "d." + commandName + "( " + (handle.empty() ? "" : ("m_" + startLowerCase(stripPrefix(handle, "Vk"))));
|
||||
for (size_t i = handle.empty() ? 0 : 1; i < commandData.params.size(); i++)
|
||||
{
|
||||
if (0 < i)
|
||||
{
|
||||
str += ", ";
|
||||
}
|
||||
appendFunctionBodyStandardArgument(str, commandData.second.params[i].type, commandData.second.params[i].name, commandData.second.params[i].arraySizes);
|
||||
appendFunctionBodyStandardArgument(str, commandData.params[i].type, commandData.params[i].name, commandData.params[i].arraySizes);
|
||||
}
|
||||
str += std::string(" )") + (returnData.first ? " )" : "") + ";\n";
|
||||
}
|
||||
@ -2210,38 +2215,38 @@ void VulkanHppGenerator::appendFunctionHeaderArgumentEnhancedVector(std::string
|
||||
}
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionHeaderArguments(std::string & str, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool enhanced, bool singular, bool withDefaults, bool withAllocator) const
|
||||
void VulkanHppGenerator::appendFunctionHeaderArguments(std::string & str, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool enhanced, bool singular, bool withDefaults, bool withAllocator) const
|
||||
{
|
||||
str += "(";
|
||||
if (enhanced)
|
||||
{
|
||||
appendFunctionHeaderArgumentsEnhanced(str, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, singular, withDefaults, withAllocator);
|
||||
appendFunctionHeaderArgumentsEnhanced(str, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, singular, withDefaults, withAllocator);
|
||||
}
|
||||
else
|
||||
{
|
||||
appendFunctionHeaderArgumentsStandard(str, commandData, withDefaults);
|
||||
appendFunctionHeaderArgumentsStandard(str, name, commandData, withDefaults);
|
||||
}
|
||||
str += ")";
|
||||
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
if (!m_commandToHandle.find(commandData.first)->second.empty())
|
||||
assert(m_commandToHandle.find(name) != m_commandToHandle.end());
|
||||
if (!m_commandToHandle.find(name)->second.empty())
|
||||
{
|
||||
str += " const";
|
||||
}
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionHeaderArgumentsEnhanced(std::string & str, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, bool withDefaults, bool withAllocator) const
|
||||
void VulkanHppGenerator::appendFunctionHeaderArgumentsEnhanced(std::string & str, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, bool withDefaults, bool withAllocator) const
|
||||
{
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(commandData.first)->second;
|
||||
assert(m_commandToHandle.find(name) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(name)->second;
|
||||
|
||||
// check if there's at least one argument left to put in here
|
||||
std::set<size_t> skippedParams = determineSkippedParams(returnParamIndex, vectorParamIndices);
|
||||
if (skippedParams.size() + (handle.empty() ? 0 : 1) < commandData.second.params.size())
|
||||
if (skippedParams.size() + (handle.empty() ? 0 : 1) < commandData.params.size())
|
||||
{
|
||||
// determine the last argument, where we might provide some default for
|
||||
size_t lastArgument = INVALID_INDEX;
|
||||
for (size_t i = commandData.second.params.size() - 1; i < commandData.second.params.size(); i--)
|
||||
for (size_t i = commandData.params.size() - 1; i < commandData.params.size(); i--)
|
||||
{
|
||||
if (skippedParams.find(i) == skippedParams.end())
|
||||
{
|
||||
@ -2252,9 +2257,9 @@ void VulkanHppGenerator::appendFunctionHeaderArgumentsEnhanced(std::string & str
|
||||
|
||||
str += " ";
|
||||
bool argEncountered = false;
|
||||
for (size_t i = handle.empty() ? 0 : 1; i < commandData.second.params.size(); i++)
|
||||
for (size_t i = handle.empty() ? 0 : 1; i < commandData.params.size(); i++)
|
||||
{
|
||||
argEncountered = appendFunctionHeaderArgumentEnhanced(str, commandData.second.params[i], i, vectorParamIndices, skippedParams.find(i) != skippedParams.end(), argEncountered,
|
||||
argEncountered = appendFunctionHeaderArgumentEnhanced(str, commandData.params[i], i, vectorParamIndices, skippedParams.find(i) != skippedParams.end(), argEncountered,
|
||||
(templateParamIndex == i), (lastArgument == i), singular, withDefaults, withAllocator);
|
||||
}
|
||||
|
||||
@ -2275,19 +2280,19 @@ void VulkanHppGenerator::appendFunctionHeaderArgumentsEnhanced(std::string & str
|
||||
str += " ";
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::appendFunctionHeaderArgumentsStandard(std::string & str, std::pair<std::string, CommandData> const& commandData, bool withDefaults) const
|
||||
void VulkanHppGenerator::appendFunctionHeaderArgumentsStandard(std::string & str, std::string const& name, CommandData const& commandData, bool withDefaults) const
|
||||
{
|
||||
// for the standard case, just list all the arguments as we've got them
|
||||
// determine the last argument, where we might provide some default for
|
||||
size_t lastArgument = commandData.second.params.size() - 1;
|
||||
size_t lastArgument = commandData.params.size() - 1;
|
||||
|
||||
assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(commandData.first)->second;
|
||||
assert(m_commandToHandle.find(name) != m_commandToHandle.end());
|
||||
std::string const& handle = m_commandToHandle.find(name)->second;
|
||||
|
||||
bool argEncountered = false;
|
||||
for (size_t i = handle.empty() ? 0 : 1; i < commandData.second.params.size(); i++)
|
||||
for (size_t i = handle.empty() ? 0 : 1; i < commandData.params.size(); i++)
|
||||
{
|
||||
argEncountered = appendFunctionHeaderArgumentStandard(str, commandData.second.params[i], argEncountered, lastArgument == i, withDefaults);
|
||||
argEncountered = appendFunctionHeaderArgumentStandard(str, commandData.params[i], argEncountered, lastArgument == i, withDefaults);
|
||||
}
|
||||
if (argEncountered)
|
||||
{
|
||||
@ -2432,7 +2437,6 @@ void VulkanHppGenerator::appendHandle(std::string & str, std::pair<std::string,
|
||||
{
|
||||
for (auto const& command : handleData.second.commands)
|
||||
{
|
||||
std::string commandName = determineCommandName(command.first, command.second.params[0].type.type);
|
||||
if (command.first == "vkCreateInstance")
|
||||
{
|
||||
// special handling for createInstance, as we need to explicitly place the forward declarations and the deleter classes here
|
||||
@ -2446,11 +2450,11 @@ void VulkanHppGenerator::appendHandle(std::string & str, std::pair<std::string,
|
||||
}
|
||||
str += "\n";
|
||||
appendPlatformEnter(str, !command.second.aliases.empty(), command.second.platform);
|
||||
appendCommand(str, " ", commandName, command, false);
|
||||
appendCommand(str, " ", command.first, command.second, false);
|
||||
appendPlatformLeave(str, !command.second.aliases.empty(), command.second.platform);
|
||||
for (auto const& alias : command.second.aliases)
|
||||
{
|
||||
appendCommand(str, " ", determineCommandName(alias, command.second.params[0].type.type), command, false);
|
||||
appendCommand(str, " ", alias, command.second, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2476,13 +2480,12 @@ void VulkanHppGenerator::appendHandle(std::string & str, std::pair<std::string,
|
||||
appendPlatformLeave(leave, !command.second.aliases.empty(), command.second.platform);
|
||||
commands += "\n" + enter;
|
||||
std::string commandName = determineCommandName(command.first, command.second.params[0].type.type);
|
||||
appendCommand(commands, " ", commandName, command, false);
|
||||
appendCommand(commands, " ", command.first, command.second, false);
|
||||
for (auto const& alias : command.second.aliases)
|
||||
{
|
||||
assert(enter.empty() && leave.empty());
|
||||
commands += "\n";
|
||||
std::string aliasCommandName = determineCommandName(alias, command.second.params[0].type.type);
|
||||
appendCommand(commands, " ", aliasCommandName, command, false);
|
||||
appendCommand(commands, " ", alias, command.second, false);
|
||||
}
|
||||
|
||||
// special handling for destroy functions
|
||||
@ -2498,9 +2501,15 @@ void VulkanHppGenerator::appendHandle(std::string & str, std::pair<std::string,
|
||||
platformLeft = true;
|
||||
}
|
||||
|
||||
commandName = (command.first.substr(2, 7) == "Destroy") ? "destroy" : "free";
|
||||
std::string destroyCommandString;
|
||||
appendCommand(destroyCommandString, " ", commandName, command, false);
|
||||
appendCommand(destroyCommandString, " ", command.first, command.second, false);
|
||||
std::string shortenedName = (command.first.substr(2, 7) == "Destroy") ? "destroy" : "free";
|
||||
size_t pos = destroyCommandString.find(commandName);
|
||||
while (pos != std::string::npos)
|
||||
{
|
||||
destroyCommandString.replace(pos, commandName.length(), shortenedName);
|
||||
pos = destroyCommandString.find(commandName, pos);
|
||||
}
|
||||
commands += "\n" + destroyCommandString;
|
||||
}
|
||||
if (!platformLeft)
|
||||
@ -2625,20 +2634,20 @@ void VulkanHppGenerator::appendHandlesCommandDefintions(std::string & str) const
|
||||
// finally the commands, that are member functions of this handle
|
||||
for (auto const& command : handle.second.commands)
|
||||
{
|
||||
std::string commandName = determineCommandName(command.first, command.second.params[0].type.type);
|
||||
std::string strippedName = startLowerCase(stripPrefix(command.first, "vk"));
|
||||
|
||||
str += "\n";
|
||||
appendPlatformEnter(str, !command.second.aliases.empty(), command.second.platform);
|
||||
appendCommand(str, " ", commandName, command, true);
|
||||
appendCommand(str, " ", command.first, command.second, true);
|
||||
for (auto const& alias : command.second.aliases)
|
||||
{
|
||||
str += "\n";
|
||||
appendCommand(str, " ", determineCommandName(alias, command.second.params[0].type.type), command, true);
|
||||
appendCommand(str, " ", alias, command.second, true);
|
||||
}
|
||||
|
||||
// special handling for destroy functions
|
||||
bool platformLeft = false;
|
||||
std::string commandName = determineCommandName(command.first, command.second.params[0].type.type);
|
||||
if (((command.first.substr(2, 7) == "Destroy") && (commandName != "destroy")) || (command.first.substr(2, 4) == "Free"))
|
||||
{
|
||||
assert(1 < command.second.params.size());
|
||||
@ -2650,9 +2659,16 @@ void VulkanHppGenerator::appendHandlesCommandDefintions(std::string & str) const
|
||||
platformLeft = true;
|
||||
}
|
||||
|
||||
commandName = (command.first.substr(2, 7) == "Destroy") ? "destroy" : "free";
|
||||
str += "\n";
|
||||
appendCommand(str, " ", commandName, command, true);
|
||||
std::string destroyCommandString;
|
||||
appendCommand(destroyCommandString, " ", command.first, command.second, true);
|
||||
std::string shortenedName = (command.first.substr(2, 7) == "Destroy") ? "destroy" : "free";
|
||||
size_t pos = destroyCommandString.find(commandName);
|
||||
while (pos != std::string::npos)
|
||||
{
|
||||
destroyCommandString.replace(pos, commandName.length(), shortenedName);
|
||||
pos = destroyCommandString.find(commandName, pos);
|
||||
}
|
||||
str += "\n" + destroyCommandString;
|
||||
}
|
||||
if (!platformLeft)
|
||||
{
|
||||
|
||||
@ -240,30 +240,30 @@ class VulkanHppGenerator
|
||||
void appendArgumentVulkanType(std::string & str, ParamData const& paramData) const;
|
||||
void appendBitmask(std::string & os, std::string const& bitmaskName, std::string const& bitmaskType, std::string const& bitmaskAlias, std::string const& enumName, std::vector<EnumValueData> const& enumValues) const;
|
||||
void appendBitmaskToStringFunction(std::string & str, std::string const& flagsName, std::string const& enumName, std::vector<EnumValueData> const& enumValues) const;
|
||||
void appendCall(std::string &str, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool firstCall, bool singular) const;
|
||||
void appendCommand(std::string & str, std::string const& indentation, std::string const& name, std::pair<std::string, CommandData> const& commandData, bool definition) const;
|
||||
void appendCall(std::string &str, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool firstCall, bool singular) const;
|
||||
void appendCommand(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, bool definition) const;
|
||||
void appendEnum(std::string & str, std::pair<std::string, EnumData> const& enumData) const;
|
||||
void appendEnumInitializer(std::string& str, TypeData const& type, std::vector<std::string> const& arraySizes, std::vector<EnumValueData> const& values, bool argument) const;
|
||||
void appendEnumToString(std::string & str, std::pair<std::string, EnumData> const& enumData) const;
|
||||
void appendFunction(std::string & str, std::string const& indentation, std::string const& name, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool definition, bool enhanced, bool singular, bool unique, bool isStructureChain, bool withAllocator) const;
|
||||
void appendFunctionBodyEnhanced(std::string & str, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool singular, bool unique, bool isStructureChain, bool withAllocator) const;
|
||||
void appendFunction(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool definition, bool enhanced, bool singular, bool unique, bool isStructureChain, bool withAllocator) const;
|
||||
void appendFunctionBodyEnhanced(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool singular, bool unique, bool isStructureChain, bool withAllocator) const;
|
||||
std::string appendFunctionBodyEnhancedLocalReturnVariable(std::string & str, std::string const& indentation, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool singular, bool isStructureChain, bool withAllocator) const;
|
||||
void appendFunctionBodyEnhancedLocalReturnVariableVectorSize(std::string & str, std::vector<ParamData> const& params, std::pair<size_t, size_t> const& vectorParamIndex, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool withAllocator) const;
|
||||
void appendFunctionBodyEnhancedMultiVectorSizeCheck(std::string & str, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices) const;
|
||||
void appendFunctionBodyEnhancedReturnResultValue(std::string & str, std::string const& indentation, std::string const& returnName, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, bool twoStep, bool singular, bool unique) const;
|
||||
void appendFunctionBodyEnhancedSingleStep(std::string & str, std::string const& indentation, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular) const;
|
||||
void appendFunctionBodyEnhancedTwoStep(std::string & str, std::string const& indentation, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, std::string const& returnName) const;
|
||||
void appendFunctionBodyEnhancedVectorOfStructureChain(std::string & str, std::string const& indentation, std::pair<std::string,CommandData> const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool withAllocator) const;
|
||||
void appendFunctionBodyEnhancedVectorOfUniqueHandles(std::string & str, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool singular, bool withAllocator) const;
|
||||
void appendFunctionBodyStandard(std::string & str, std::string const& indentation, std::pair<std::string, CommandData> const& commandData) const;
|
||||
void appendFunctionBodyEnhancedMultiVectorSizeCheck(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices) const;
|
||||
void appendFunctionBodyEnhancedReturnResultValue(std::string & str, std::string const& indentation, std::string const& returnName, std::string const& name, CommandData const& commandData, size_t returnParamIndex, bool twoStep, bool singular, bool unique) const;
|
||||
void appendFunctionBodyEnhancedSingleStep(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular) const;
|
||||
void appendFunctionBodyEnhancedTwoStep(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, std::string const& returnName) const;
|
||||
void appendFunctionBodyEnhancedVectorOfStructureChain(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool withAllocator) const;
|
||||
void appendFunctionBodyEnhancedVectorOfUniqueHandles(std::string & str, std::string const& indentation, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool singular, bool withAllocator) const;
|
||||
void appendFunctionBodyStandard(std::string & str, std::string const& indentation, std::string const& commandName, CommandData const& commandData) const;
|
||||
void appendFunctionBodyStandardArgument(std::string & str, TypeData const& typeData, std::string const& name, std::vector<std::string> const& arraySizes) const;
|
||||
bool appendFunctionHeaderArgumentEnhanced(std::string & str, ParamData const& param, size_t paramIndex, std::map<size_t, size_t> const& vectorParamIndices, bool skip, bool argEncountered, bool isTemplateParam, bool isLastArgument, bool singular, bool withDefaults, bool withAllocator) const;
|
||||
void appendFunctionHeaderArgumentEnhancedPointer(std::string & str, ParamData const& param, std::string const& strippedParameterName, bool withDefaults, bool withAllocator) const;
|
||||
void appendFunctionHeaderArgumentEnhancedSimple(std::string & str, ParamData const& param, bool lastArgument, bool withDefaults, bool withAllocator) const;
|
||||
void appendFunctionHeaderArgumentEnhancedVector(std::string & str, ParamData const& param, std::string const& strippedParameterName, bool hasSizeParam, bool isTemplateParam, bool singular, bool withDefaults, bool withAllocator) const;
|
||||
void appendFunctionHeaderArguments(std::string & str, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool enhanced, bool singular, bool withDefaults, bool withAllocator) const;
|
||||
void appendFunctionHeaderArgumentsEnhanced(std::string & str, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, bool withDefaults, bool withAllocator) const;
|
||||
void appendFunctionHeaderArgumentsStandard(std::string & str, std::pair<std::string, CommandData> const& commandData, bool withDefaults) const;
|
||||
void appendFunctionHeaderArguments(std::string & str, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool enhanced, bool singular, bool withDefaults, bool withAllocator) const;
|
||||
void appendFunctionHeaderArgumentsEnhanced(std::string & str, std::string const& name, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, bool withDefaults, bool withAllocator) const;
|
||||
void appendFunctionHeaderArgumentsStandard(std::string & str, std::string const& name, CommandData const& commandData, bool withDefaults) const;
|
||||
bool appendFunctionHeaderArgumentStandard(std::string & str, ParamData const& param, bool argEncountered, bool isLastArgument, bool withDefaults) const;
|
||||
void appendFunctionHeaderReturnType(std::string & str, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, std::string const& enhancedReturnType, bool enhanced, bool twoStep, bool singular, bool unique, bool isStructureChain) const;
|
||||
void appendFunctionHeaderTemplate(std::string & str, std::string const& indentation, size_t returnParamIndex, size_t templateParamIndex, std::string const& enhancedReturnType, bool enhanced, bool singular, bool unique, bool withDefault, bool isStructureChain) const;
|
||||
|
||||
@ -67224,13 +67224,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo* pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo* pSubpassBeginInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdBeginRenderPass2( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo*>( pSubpassBeginInfo ) );
|
||||
d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo*>( pSubpassBeginInfo ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfo & subpassBeginInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdBeginRenderPass2( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo*>( &subpassBeginInfo ) );
|
||||
d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfo*>( &subpassBeginInfo ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -67682,13 +67682,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
|
||||
d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
|
||||
}
|
||||
#else
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
|
||||
d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -67766,13 +67766,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
}
|
||||
#else
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -67780,13 +67780,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
}
|
||||
#else
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDrawIndexedIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -67836,13 +67836,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDrawIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
}
|
||||
#else
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDrawIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -67850,13 +67850,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDrawIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
}
|
||||
#else
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdDrawIndirectCount( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -67988,13 +67988,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo* pSubpassEndInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo*>( pSubpassEndInfo ) );
|
||||
d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo*>( pSubpassEndInfo ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo*>( &subpassEndInfo ) );
|
||||
d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfo*>( &subpassEndInfo ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -68102,13 +68102,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo* pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo* pSubpassEndInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdNextSubpass2( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo*>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo*>( pSubpassEndInfo ) );
|
||||
d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo*>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo*>( pSubpassEndInfo ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, const SubpassEndInfo & subpassEndInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdNextSubpass2( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo*>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo*>( &subpassEndInfo ) );
|
||||
d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfo*>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfo*>( &subpassEndInfo ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -68306,13 +68306,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
|
||||
d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
|
||||
}
|
||||
#else
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
|
||||
d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -68619,13 +68619,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR* pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer, accelerationStructureCount, reinterpret_cast<const VkAccelerationStructureKHR*>( pAccelerationStructures ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
|
||||
d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructureCount, reinterpret_cast<const VkAccelerationStructureKHR*>( pAccelerationStructures ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer, accelerationStructures.size() , reinterpret_cast<const VkAccelerationStructureKHR*>( accelerationStructures.data() ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
|
||||
d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructures.size() , reinterpret_cast<const VkAccelerationStructureKHR*>( accelerationStructures.data() ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -68930,13 +68930,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoKHR* pBindInfos, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkBindAccelerationStructureMemoryKHR( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( pBindInfos ) ) );
|
||||
return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( pBindInfos ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoKHR> bindInfos, Dispatch const &d ) const
|
||||
{
|
||||
Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryKHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( bindInfos.data() ) ) );
|
||||
Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( bindInfos.data() ) ) );
|
||||
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -68973,13 +68973,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
|
||||
return static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
|
||||
{
|
||||
Result result = static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
|
||||
Result result = static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
|
||||
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2KHR" );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -69016,13 +69016,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo* pBindInfos, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
|
||||
return static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
|
||||
{
|
||||
Result result = static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
|
||||
Result result = static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
|
||||
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2KHR" );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -69433,14 +69433,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
|
||||
return static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
|
||||
Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
|
||||
Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
|
||||
return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHR" );
|
||||
}
|
||||
#ifndef VULKAN_HPP_NO_SMART_HANDLE
|
||||
@ -69448,7 +69448,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
|
||||
Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
|
||||
Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
|
||||
|
||||
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
|
||||
return createResultValue<DescriptorUpdateTemplate,Dispatch>( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHRUnique", deleter );
|
||||
@ -69981,14 +69981,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2* pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, VULKAN_HPP_NAMESPACE::RenderPass* pRenderPass, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkCreateRenderPass2( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
|
||||
return static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type Device::createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::RenderPass renderPass;
|
||||
Result result = static_cast<Result>( d.vkCreateRenderPass2( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
|
||||
Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
|
||||
return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHR" );
|
||||
}
|
||||
#ifndef VULKAN_HPP_NO_SMART_HANDLE
|
||||
@ -69996,7 +69996,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::RenderPass renderPass;
|
||||
Result result = static_cast<Result>( d.vkCreateRenderPass2( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
|
||||
Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
|
||||
|
||||
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
|
||||
return createResultValue<RenderPass,Dispatch>( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHRUnique", deleter );
|
||||
@ -70059,14 +70059,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo* pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
|
||||
return static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
|
||||
Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
|
||||
Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
|
||||
return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHR" );
|
||||
}
|
||||
#ifndef VULKAN_HPP_NO_SMART_HANDLE
|
||||
@ -70074,7 +70074,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
|
||||
Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
|
||||
Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
|
||||
|
||||
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
|
||||
return createResultValue<SamplerYcbcrConversion,Dispatch>( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHRUnique", deleter );
|
||||
@ -70325,13 +70325,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkDestroyAccelerationStructureKHR( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
|
||||
d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkDestroyAccelerationStructureKHR( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
|
||||
d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -70522,13 +70522,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
|
||||
d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
|
||||
d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -70886,13 +70886,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks* pAllocator, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
|
||||
d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
|
||||
d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -71254,26 +71254,26 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo* pInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) ) );
|
||||
return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
|
||||
return d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo* pInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) ) );
|
||||
return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return d.vkGetBufferDeviceAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
|
||||
return d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -71318,14 +71318,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2* pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
|
||||
d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
|
||||
d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
|
||||
d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
|
||||
return memoryRequirements;
|
||||
}
|
||||
template<typename X, typename Y, typename ...Z, typename Dispatch>
|
||||
@ -71333,7 +71333,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
StructureChain<X, Y, Z...> structureChain;
|
||||
VULKAN_HPP_NAMESPACE::MemoryRequirements2& memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
|
||||
d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
|
||||
d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
|
||||
return structureChain;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -71354,13 +71354,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo* pInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) );
|
||||
return d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( pInfo ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
|
||||
return d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkBufferDeviceAddressInfo*>( &info ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -71446,14 +71446,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo* pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
|
||||
d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
|
||||
d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
|
||||
d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
|
||||
return support;
|
||||
}
|
||||
template<typename X, typename Y, typename ...Z, typename Dispatch>
|
||||
@ -71461,7 +71461,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
StructureChain<X, Y, Z...> structureChain;
|
||||
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport& support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
|
||||
d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
|
||||
d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
|
||||
return structureChain;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -71500,14 +71500,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
|
||||
d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures;
|
||||
d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
|
||||
d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
|
||||
return peerMemoryFeatures;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -71590,13 +71590,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo* pInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( pInfo ) );
|
||||
return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( pInfo ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( &info ) );
|
||||
return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( &info ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -71784,14 +71784,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2* pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
|
||||
d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
|
||||
d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
|
||||
d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
|
||||
return memoryRequirements;
|
||||
}
|
||||
template<typename X, typename Y, typename ...Z, typename Dispatch>
|
||||
@ -71799,7 +71799,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
StructureChain<X, Y, Z...> structureChain;
|
||||
VULKAN_HPP_NAMESPACE::MemoryRequirements2& memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
|
||||
d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
|
||||
d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
|
||||
return structureChain;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -71863,7 +71863,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
|
||||
d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Allocator, typename Dispatch>
|
||||
@ -71871,9 +71871,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements;
|
||||
uint32_t sparseMemoryRequirementCount;
|
||||
d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
|
||||
d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
|
||||
sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
|
||||
d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
|
||||
d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
|
||||
return sparseMemoryRequirements;
|
||||
}
|
||||
template<typename Allocator, typename Dispatch>
|
||||
@ -71881,9 +71881,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
|
||||
uint32_t sparseMemoryRequirementCount;
|
||||
d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
|
||||
d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
|
||||
sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
|
||||
d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
|
||||
d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
|
||||
return sparseMemoryRequirements;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -72351,13 +72351,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
|
||||
return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename T, typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d ) const
|
||||
{
|
||||
Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
|
||||
Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
|
||||
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -72410,14 +72410,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t* pValue, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) );
|
||||
return static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type Device::getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const &d ) const
|
||||
{
|
||||
uint64_t value;
|
||||
Result result = static_cast<Result>( d.vkGetSemaphoreCounterValue( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
|
||||
Result result = static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
|
||||
return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreCounterValueKHR" );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -72946,13 +72946,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkResetQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
|
||||
d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
|
||||
}
|
||||
#else
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkResetQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
|
||||
d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -73051,13 +73051,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo* pSignalInfo, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo*>( pSignalInfo ) ) );
|
||||
return static_cast<Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo*>( pSignalInfo ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const &d ) const
|
||||
{
|
||||
Result result = static_cast<Result>( d.vkSignalSemaphore( m_device, reinterpret_cast<const VkSemaphoreSignalInfo*>( &signalInfo ) ) );
|
||||
Result result = static_cast<Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfo*>( &signalInfo ) ) );
|
||||
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::signalSemaphoreKHR" );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -73080,13 +73080,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
|
||||
d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
|
||||
}
|
||||
#else
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
|
||||
d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -73136,13 +73136,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
|
||||
d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
|
||||
}
|
||||
#else
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
|
||||
d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
@ -73190,13 +73190,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo* pWaitInfo, uint64_t timeout, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo*>( pWaitInfo ), timeout ) );
|
||||
return static_cast<Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo*>( pWaitInfo ), timeout ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const &d ) const
|
||||
{
|
||||
Result result = static_cast<Result>( d.vkWaitSemaphores( m_device, reinterpret_cast<const VkSemaphoreWaitInfo*>( &waitInfo ), timeout ) );
|
||||
Result result = static_cast<Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfo*>( &waitInfo ), timeout ) );
|
||||
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitSemaphoresKHR", { Result::eSuccess, Result::eTimeout } );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -73796,7 +73796,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
|
||||
return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Allocator, typename Dispatch>
|
||||
@ -73807,11 +73807,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
Result result;
|
||||
do
|
||||
{
|
||||
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
|
||||
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
|
||||
if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
|
||||
{
|
||||
physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
|
||||
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
|
||||
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
|
||||
}
|
||||
} while ( result == Result::eIncomplete );
|
||||
if ( result == Result::eSuccess )
|
||||
@ -73829,11 +73829,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
Result result;
|
||||
do
|
||||
{
|
||||
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
|
||||
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
|
||||
if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
|
||||
{
|
||||
physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
|
||||
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
|
||||
result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
|
||||
}
|
||||
} while ( result == Result::eIncomplete );
|
||||
if ( result == Result::eSuccess )
|
||||
@ -74653,14 +74653,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
|
||||
d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
|
||||
d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
|
||||
d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
|
||||
return externalBufferProperties;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -74683,14 +74683,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
|
||||
d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
|
||||
d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
|
||||
d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
|
||||
return externalFenceProperties;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -74728,14 +74728,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
|
||||
d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
|
||||
d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
|
||||
d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
|
||||
return externalSemaphoreProperties;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -74781,14 +74781,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
|
||||
d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
|
||||
d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
|
||||
d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
|
||||
return features;
|
||||
}
|
||||
template<typename X, typename Y, typename ...Z, typename Dispatch>
|
||||
@ -74796,7 +74796,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
StructureChain<X, Y, Z...> structureChain;
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2& features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
|
||||
d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
|
||||
d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
|
||||
return structureChain;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -74842,14 +74842,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2* pFormatProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
|
||||
d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
|
||||
d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
|
||||
d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
|
||||
return formatProperties;
|
||||
}
|
||||
template<typename X, typename Y, typename ...Z, typename Dispatch>
|
||||
@ -74857,7 +74857,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
StructureChain<X, Y, Z...> structureChain;
|
||||
VULKAN_HPP_NAMESPACE::FormatProperties2& formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
|
||||
d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
|
||||
d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
|
||||
return structureChain;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -74903,14 +74903,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
|
||||
return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
|
||||
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
|
||||
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
|
||||
return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
|
||||
}
|
||||
template<typename X, typename Y, typename ...Z, typename Dispatch>
|
||||
@ -74918,7 +74918,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
StructureChain<X, Y, Z...> structureChain;
|
||||
VULKAN_HPP_NAMESPACE::ImageFormatProperties2& imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
|
||||
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
|
||||
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
|
||||
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -74964,14 +74964,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
|
||||
d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
|
||||
d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
|
||||
d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
|
||||
return memoryProperties;
|
||||
}
|
||||
template<typename X, typename Y, typename ...Z, typename Dispatch>
|
||||
@ -74979,7 +74979,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
StructureChain<X, Y, Z...> structureChain;
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
|
||||
d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
|
||||
d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
|
||||
return structureChain;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -75092,14 +75092,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2* pProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
|
||||
d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
|
||||
d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
|
||||
d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
|
||||
return properties;
|
||||
}
|
||||
template<typename X, typename Y, typename ...Z, typename Dispatch>
|
||||
@ -75107,7 +75107,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
StructureChain<X, Y, Z...> structureChain;
|
||||
VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2& properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
|
||||
d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
|
||||
d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
|
||||
return structureChain;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
@ -75224,7 +75224,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Allocator, typename Dispatch>
|
||||
@ -75232,9 +75232,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties;
|
||||
uint32_t queueFamilyPropertyCount;
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
|
||||
queueFamilyProperties.resize( queueFamilyPropertyCount );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
|
||||
return queueFamilyProperties;
|
||||
}
|
||||
template<typename Allocator, typename Dispatch>
|
||||
@ -75242,9 +75242,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
|
||||
uint32_t queueFamilyPropertyCount;
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
|
||||
queueFamilyProperties.resize( queueFamilyPropertyCount );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
|
||||
return queueFamilyProperties;
|
||||
}
|
||||
template<typename StructureChain, typename Allocator, typename Dispatch>
|
||||
@ -75252,14 +75252,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
std::vector<StructureChain,Allocator> queueFamilyProperties;
|
||||
uint32_t queueFamilyPropertyCount;
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
|
||||
queueFamilyProperties.resize( queueFamilyPropertyCount );
|
||||
std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
|
||||
for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
|
||||
{
|
||||
localVector[i].pNext = queueFamilyProperties[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
|
||||
}
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
|
||||
for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
|
||||
{
|
||||
queueFamilyProperties[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = localVector[i];
|
||||
@ -75271,14 +75271,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
std::vector<StructureChain,Allocator> queueFamilyProperties( vectorAllocator );
|
||||
uint32_t queueFamilyPropertyCount;
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
|
||||
queueFamilyProperties.resize( queueFamilyPropertyCount );
|
||||
std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
|
||||
for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
|
||||
{
|
||||
localVector[i].pNext = queueFamilyProperties[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
|
||||
}
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
|
||||
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
|
||||
for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
|
||||
{
|
||||
queueFamilyProperties[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = localVector[i];
|
||||
@ -75346,7 +75346,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
template<typename Dispatch>
|
||||
VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2* pProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
|
||||
}
|
||||
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
|
||||
template<typename Allocator, typename Dispatch>
|
||||
@ -75354,9 +75354,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
std::vector<SparseImageFormatProperties2,Allocator> properties;
|
||||
uint32_t propertyCount;
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
|
||||
properties.resize( propertyCount );
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
|
||||
return properties;
|
||||
}
|
||||
template<typename Allocator, typename Dispatch>
|
||||
@ -75364,9 +75364,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
|
||||
uint32_t propertyCount;
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
|
||||
properties.resize( propertyCount );
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
|
||||
d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
|
||||
return properties;
|
||||
}
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
Loading…
Reference in New Issue
Block a user