AuroraMiddleware/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp synced 2024-11-21 20:00:11 +00:00
Code Issues Releases Wiki Activity

Remove implicit cast operators on ResultValue<T>

Browse Source 
As it turned out to not provide a complete solution to the C++-API-change issue on logical-change of the C-API, we simply remove those implicit cast operators. That is, accessing the result and the value need to be explicit.
This commit is contained in:
asuessenbach 2020-07-20 13:48:03 +02:00 committed by Markus Tavenrath
parent 4cdc51ba0f
commit fba2516d9c
9 changed files with 206 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.md
View File

@ -271,8 +271,7 @@ switch (result.result)
}
```
Note, that there are implicit cast operators in vk::ResultValue, which allow direct assignments of the returned value. That way, any success code is imlicitly ignored. If you want to make sure, you don't miss any such cases and correctly handle or explicitly ignore the success codes, define VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST before including vulkan.hpp.
As time passes, some vulkan functions might change, such that they start to support more result codes than `vk::Result::eSuccess` as a success code. That logical change would not be visible in the C-API, but in the C++-API, as such a function would now return a `vk::ResultValue<SomeType>` instead of just `SomeType`. If you have VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST defined, you suddenly get compiler errors, that force you to handle the changed logic.
As time passes, some vulkan functions might change, such that they start to support more result codes than `vk::Result::eSuccess` as a success code. That logical change would not be visible in the C-API, but in the C++-API, as such a function would now return a `vk::ResultValue<SomeType>` instead of just `SomeType`. In such (rare) cases, you would have to adjust your cpp-sources to reflect that API change.
If exception handling is disabled by defining `VULKAN_HPP_NO_EXCEPTIONS` the type of `ResultValue<SomeType>::type` is a struct holding a `vk::Result` and a `SomeType`. This struct supports unpacking the return values by using `std::tie`.

83
VulkanHppGenerator.cpp
View File

@ -2557,7 +2557,7 @@ ${i} ${uniqueTypeVariable}s.push_back( UniqueHandle<${type}, Dispatch>( ${t
${i} }
${i} }
${i} return createResultValue( result, ${uniqueTypeVariable}s, VULKAN_HPP_NAMESPACE_STRING "::${class}::${commandName}Unique"${successCodes} );
${i} return createResultValue( result, std::move( ${uniqueTypeVariable}s ), VULKAN_HPP_NAMESPACE_STRING "::${class}::${commandName}Unique"${successCodes} );
)";
std::string type = ( returnParamIndex != INVALID_INDEX ) ? commandData.params[returnParamIndex].type.type : "";
@ -8631,21 +8631,25 @@ namespace std
operator std::tuple<Result&, T&>() VULKAN_HPP_NOEXCEPT { return std::tuple<Result&, T&>(result, value); }
#if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
operator T const& () const & VULKAN_HPP_NOEXCEPT
{
return value;
}
VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
operator T& () & VULKAN_HPP_NOEXCEPT
{
return value;
}
VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
operator T const&& () const && VULKAN_HPP_NOEXCEPT
{
return std::move( value );
}
VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
operator T&& () && VULKAN_HPP_NOEXCEPT
{
return std::move( value );
@ -8672,17 +8676,40 @@ namespace std
operator std::tuple<Result&, UniqueHandle<Type, Dispatch>&>() VULKAN_HPP_NOEXCEPT { return std::tuple<Result&, UniqueHandle<Type, Dispatch>&>(result, value); }
# if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
operator UniqueHandle<Type, Dispatch>& () & VULKAN_HPP_NOEXCEPT
{
return value;
}
VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
operator UniqueHandle<Type, Dispatch>() VULKAN_HPP_NOEXCEPT
{
return std::move(value);
}
# endif
};
template <typename Type, typename Dispatch>
struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
{
# ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) VULKAN_HPP_NOEXCEPT
# else
ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v )
# endif
: result( r )
, value( std::move( v ) )
{}
Result result;
std::vector<UniqueHandle<Type, Dispatch>> value;
operator std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>() VULKAN_HPP_NOEXCEPT
{
return std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>( result, value );
}
};
#endif
template <typename T>
@ -8782,19 +8809,59 @@ namespace std
}
template <typename T, typename D>
VULKAN_HPP_INLINE ResultValue<UniqueHandle<T,D>> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes, typename UniqueHandleTraits<T,D>::deleter const& deleter )
VULKAN_HPP_INLINE ResultValue<UniqueHandle<T, D>>
createResultValue( Result result,
T & data,
char const * message,
std::initializer_list<Result> successCodes,
typename UniqueHandleTraits<T, D>::deleter const & deleter )
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
ignore(message);
# ifdef VULKAN_HPP_NO_EXCEPTIONS
ignore( message );
VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
return ResultValue<UniqueHandle<T,D>>( result, UniqueHandle<T,D>(data, deleter) );
#else
# else
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
{
throwResultException( result, message );
}
return ResultValue<UniqueHandle<T,D>>( result, UniqueHandle<T,D>(data, deleter) );
#endif
# endif
return ResultValue<UniqueHandle<T, D>>( result, UniqueHandle<T, D>( data, deleter ) );
}
template <typename T, typename D>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<T, D>>>::type
createResultValue( Result result, std::vector<UniqueHandle<T, D>> && data, char const * message )
{
# ifdef VULKAN_HPP_NO_EXCEPTIONS
ignore( message );
VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
return ResultValue<std::vector<UniqueHandle<T, D>>>( result, std::move( data ) );
# else
if ( result != Result::eSuccess )
{
throwResultException( result, message );
}
return std::move( data );
# endif
}
template <typename T, typename D>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<T, D>>>
createResultValue( Result result,
std::vector<UniqueHandle<T, D>> && data,
char const * message,
std::initializer_list<Result> successCodes )
{
# ifdef VULKAN_HPP_NO_EXCEPTIONS
ignore( message );
VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
# else
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
{
throwResultException( result, message );
}
# endif
return ResultValue<std::vector<UniqueHandle<T, D>>>( result, std::move( data ) );
}
#endif
)";

11
samples/14_InitPipeline/14_InitPipeline.cpp
View File

@ -161,7 +161,16 @@ int main( int /*argc*/, char ** /*argv*/ )
renderPass.get() // renderPass
);
vk::UniquePipeline pipeline = device->createGraphicsPipelineUnique( nullptr, graphicsPipelineCreateInfo );
vk::ResultValue<vk::UniquePipeline> pipeline =
device->createGraphicsPipelineUnique( nullptr, graphicsPipelineCreateInfo );
switch ( pipeline.result )
{
case vk::Result::eSuccess: break;
case vk::Result::ePipelineCompileRequiredEXT:
// something meaningfull here
break;
default: assert( false ); // should never happen
}
/* VULKAN_KEY_END */
}

23
samples/PipelineDerivative/PipelineDerivative.cpp
View File

@ -204,8 +204,17 @@ int main( int /*argc*/, char ** /*argv*/ )
pipelineLayout.get(),
renderPass.get() );
vk::UniquePipeline basePipeline =
vk::UniquePipeline basePipeline;
vk::ResultValue<vk::UniquePipeline> rvPipeline =
device->createGraphicsPipelineUnique( pipelineCache.get(), graphicsPipelineCreateInfo );
switch ( rvPipeline.result )
{
case vk::Result::eSuccess: basePipeline = std::move( rvPipeline.value ); break;
case vk::Result::ePipelineCompileRequiredEXT:
// something meaningfull here
break;
default: assert( false ); // should never happen
}
// Now create the derivative pipeline, using a different fragment shader
// This shader will shade the cube faces with interpolated colors
@ -236,8 +245,16 @@ void main()
graphicsPipelineCreateInfo.basePipelineIndex = -1;
// And create the derived pipeline
vk::UniquePipeline derivedPipeline =
device->createGraphicsPipelineUnique( pipelineCache.get(), graphicsPipelineCreateInfo );
vk::UniquePipeline derivedPipeline;
rvPipeline = device->createGraphicsPipelineUnique( *pipelineCache, graphicsPipelineCreateInfo );
switch ( rvPipeline.result )
{
case vk::Result::eSuccess: derivedPipeline = std::move( rvPipeline.value ); break;
case vk::Result::ePipelineCompileRequiredEXT:
// something meaningfull here
break;
default: assert( false ); // should never happen
}
/* VULKAN_KEY_END */

11
samples/RayTracing/RayTracing.cpp
View File

@ -1097,8 +1097,17 @@ int main( int /*argc*/, char ** /*argv*/ )
uint32_t maxRecursionDepth = 2;
vk::RayTracingPipelineCreateInfoNV rayTracingPipelineCreateInfo(
{}, shaderStages, shaderGroups, maxRecursionDepth, *rayTracingPipelineLayout );
vk::UniquePipeline rayTracingPipeline =
vk::UniquePipeline rayTracingPipeline;
vk::ResultValue<vk::UniquePipeline> rvPipeline =
device->createRayTracingPipelineNVUnique( nullptr, rayTracingPipelineCreateInfo );
switch ( rvPipeline.result )
{
case vk::Result::eSuccess: rayTracingPipeline = std::move( rvPipeline.value ); break;
case vk::Result::ePipelineCompileRequiredEXT:
// something meaningfull here
break;
default: assert( false ); // should never happen
}
uint32_t shaderGroupHandleSize =
physicalDevice.getProperties2<vk::PhysicalDeviceProperties2, vk::PhysicalDeviceRayTracingPropertiesNV>()

2
tests/DeviceFunctions/DeviceFunctions.cpp
View File

@ -67,6 +67,8 @@ int main( int /*argc*/, char ** /*argv*/ )
vk::DeviceMemory deviceMemory = device->allocateMemory( {} );
vk::UniqueDeviceMemory uniqueDeviceMemory = vk::UniqueDeviceMemory( deviceMemory, *device );
vk::ResultValue<std::vector<vk::UniquePipeline>> pipelines = device->createGraphicsPipelinesUnique( nullptr, {} );
}
catch ( vk::SystemError const & err )
{

34
tests/ResultValue/CMakeLists.txt
View File

@ -1,34 +0,0 @@
# Copyright(c) 2020, Collabora Ltd. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
cmake_minimum_required(VERSION 3.2)
project(ResultValue)
set(HEADERS
)
set(SOURCES
ResultValue.cpp
)
source_group(headers FILES ${HEADERS})
source_group(sources FILES ${SOURCES})
add_executable(ResultValue
${HEADERS}
${SOURCES}
)
set_target_properties(ResultValue PROPERTIES FOLDER "Tests")

67
tests/ResultValue/ResultValue.cpp
View File

@ -1,67 +0,0 @@
// Copyright(c) 2020, Collabora Ltd. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// VulkanHpp Tests : ResultValue
// Compile-test for ResultValue
#define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
#include "vulkan/vulkan.hpp"
VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
void as_value( int ) {}
void as_ref( int & ) {}
void as_rvref( int && ) {}
void as_cref( const int & ) {}
void as_crvref( const int && ) {}
void as_cref( const vk::UniquePipeline & ) {}
int main( int /*argc*/, char ** /*argv*/ )
{
#if defined( VULKAN_DISABLE_IMPLICIT_RESULT_VALUE_CAST )
static_assert( false, "Conversions not enabled" );
#endif
using result = vk::ResultValue<int>;
auto val = result{ vk::Result{}, 42 };
const auto cval = result{ vk::Result{}, 42 };
as_value( val );
as_value( cval );
as_ref( val );
// as_ref(cval); // should fail
as_cref( val );
as_cref( cval );
as_rvref( std::move( val ) );
// as_rvref(std::move(cval)); // should fail
as_crvref( std::move( val ) );
as_crvref( std::move( cval ) );
vk::Pipeline pipe( VkPipeline( 0x8 ) ); // fake a Pipeline here, to have something different from zero
vk::UniquePipeline pipeline( pipe );
vk::ResultValue<vk::UniquePipeline> rv( {}, std::move( pipeline ) );
as_cref( rv ); // does not move out handle
assert( rv.value );
auto p = std::move( rv.value );
p.release(); // release the faked Pipeline, to prevent error on trying to destroy it
return 0;
}

106
vulkan/vulkan.hpp
View File

@ -16299,21 +16299,29 @@ namespace VULKAN_HPP_NAMESPACE
}
#if !defined( VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST )
VULKAN_HPP_DEPRECATED(
"Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." )
operator T const &() const & VULKAN_HPP_NOEXCEPT
{
return value;
}
VULKAN_HPP_DEPRECATED(
"Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." )
operator T &() & VULKAN_HPP_NOEXCEPT
{
return value;
}
VULKAN_HPP_DEPRECATED(
"Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." )
operator T const &&() const && VULKAN_HPP_NOEXCEPT
{
return std::move( value );
}
VULKAN_HPP_DEPRECATED(
"Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." )
operator T &&() && VULKAN_HPP_NOEXCEPT
{
return std::move( value );
@ -16343,17 +16351,42 @@ namespace VULKAN_HPP_NAMESPACE
}
# if !defined( VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST )
VULKAN_HPP_DEPRECATED(
"Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." )
operator UniqueHandle<Type, Dispatch> &() & VULKAN_HPP_NOEXCEPT
{
return value;
}
VULKAN_HPP_DEPRECATED(
"Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." )
operator UniqueHandle<Type, Dispatch>() VULKAN_HPP_NOEXCEPT
{
return std::move( value );
}
# endif
};
template <typename Type, typename Dispatch>
struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
{
# ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) VULKAN_HPP_NOEXCEPT
# else
ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v )
# endif
: result( r )
, value( std::move( v ) )
{}
Result result;
std::vector<UniqueHandle<Type, Dispatch>> value;
operator std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>() VULKAN_HPP_NOEXCEPT
{
return std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>( result, value );
}
};
#endif
template <typename T>
@ -16467,14 +16500,49 @@ namespace VULKAN_HPP_NAMESPACE
# ifdef VULKAN_HPP_NO_EXCEPTIONS
ignore( message );
VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
return ResultValue<UniqueHandle<T, D>>( result, UniqueHandle<T, D>( data, deleter ) );
# else
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
{
throwResultException( result, message );
}
return ResultValue<UniqueHandle<T, D>>( result, UniqueHandle<T, D>( data, deleter ) );
# endif
return ResultValue<UniqueHandle<T, D>>( result, UniqueHandle<T, D>( data, deleter ) );
}
template <typename T, typename D>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<T, D>>>::type
createResultValue( Result result, std::vector<UniqueHandle<T, D>> && data, char const * message )
{
# ifdef VULKAN_HPP_NO_EXCEPTIONS
ignore( message );
VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
return ResultValue<std::vector<UniqueHandle<T, D>>>( result, std::move( data ) );
# else
if ( result != Result::eSuccess )
{
throwResultException( result, message );
}
return std::move( data );
# endif
}
template <typename T, typename D>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<T, D>>>
createResultValue( Result result,
std::vector<UniqueHandle<T, D>> && data,
char const * message,
std::initializer_list<Result> successCodes )
{
# ifdef VULKAN_HPP_NO_EXCEPTIONS
ignore( message );
VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
# else
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
{
throwResultException( result, message );
}
# endif
return ResultValue<std::vector<UniqueHandle<T, D>>>( result, std::move( data ) );
}
#endif
@ -89785,7 +89853,7 @@ namespace VULKAN_HPP_NAMESPACE
}
return createResultValue(
result, uniqueCommandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
}
template <typename Allocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@ -89811,7 +89879,7 @@ namespace VULKAN_HPP_NAMESPACE
}
return createResultValue(
result, uniqueCommandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
}
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -89877,7 +89945,7 @@ namespace VULKAN_HPP_NAMESPACE
}
return createResultValue(
result, uniqueDescriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
}
template <typename Allocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@ -89903,7 +89971,7 @@ namespace VULKAN_HPP_NAMESPACE
}
return createResultValue(
result, uniqueDescriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
}
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -90645,7 +90713,7 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValue(
result,
uniquePipelines,
std::move( uniquePipelines ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
@ -90680,7 +90748,7 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValue(
result,
uniquePipelines,
std::move( uniquePipelines ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
@ -91224,7 +91292,7 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValue(
result,
uniquePipelines,
std::move( uniquePipelines ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
@ -91259,7 +91327,7 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValue(
result,
uniquePipelines,
std::move( uniquePipelines ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
@ -91768,7 +91836,7 @@ namespace VULKAN_HPP_NAMESPACE
}
return createResultValue( result,
uniquePipelines,
std::move( uniquePipelines ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess,
VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
@ -91807,7 +91875,7 @@ namespace VULKAN_HPP_NAMESPACE
}
return createResultValue( result,
uniquePipelines,
std::move( uniquePipelines ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess,
VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
@ -91957,7 +92025,7 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValue(
result,
uniquePipelines,
std::move( uniquePipelines ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
@ -91992,7 +92060,7 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValue(
result,
uniquePipelines,
std::move( uniquePipelines ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
}
@ -92522,8 +92590,9 @@ namespace VULKAN_HPP_NAMESPACE
}
}
return createResultValue(
result, uniqueSwapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
return createResultValue( result,
std::move( uniqueSwapchainKHRs ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
}
template <typename Allocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
@ -92552,8 +92621,9 @@ namespace VULKAN_HPP_NAMESPACE
}
}
return createResultValue(
result, uniqueSwapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
return createResultValue( result,
std::move( uniqueSwapchainKHRs ),
VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
}
template <typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE