diff --git a/VkCppGenerator.cpp b/VkCppGenerator.cpp index 02060fc..5b43566 100644 --- a/VkCppGenerator.cpp +++ b/VkCppGenerator.cpp @@ -216,6 +216,10 @@ struct MemberData struct StructData { + StructData() + : returnedOnly(false) + {} + bool returnedOnly; std::vector members; std::string protect; @@ -338,7 +342,7 @@ void writeExceptionCheck(std::ofstream & ofs, std::string const& indentation, st void writeFunctionHeader(std::ofstream & ofs, std::string const& indentation, std::string const& returnType, std::string const& name, CommandData const& commandData, size_t returnIndex, size_t templateIndex, std::map const& vectorParameters); void writeMemberData(std::ofstream & ofs, MemberData const& memberData, std::set const& vkTypes); void writeStructConstructor( std::ofstream & ofs, std::string const& name, std::string const& memberName, StructData const& structData, std::set const& vkTypes, std::map const& defaultValues ); -void writeStructGetter( std::ofstream & ofs, MemberData const& memberData, std::string const& memberName, std::set const& vkTypes ); +void writeStructGetter( std::ofstream & ofs, MemberData const& memberData, std::string const& memberName, std::set const& vkTypes, bool constVersion ); void writeStructSetter( std::ofstream & ofs, std::string const& name, MemberData const& memberData, std::string const& memberName, std::set const& vkTypes, std::map const& structs ); void writeTypeCommand( std::ofstream & ofs, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes ); void writeTypeCommandEnhanced(std::ofstream & ofs, std::string const& indentation, std::string const& className, DependencyData const& dependencyData, CommandData const& commandData, std::set const& vkTypes); @@ -1843,12 +1847,12 @@ void writeStructConstructor( std::ofstream & ofs, std::string const& name, std:: } -void writeStructGetter( std::ofstream & ofs, MemberData const& memberData, std::string const& memberName, std::set const& vkTypes ) +void writeStructGetter( std::ofstream & ofs, MemberData const& memberData, std::string const& memberName, std::set const& vkTypes, bool constVersion ) { ofs << " "; if ( memberData.type.back() == '*' ) { - if ( memberData.type.find( "const" ) != 0 ) + if ( constVersion && ( memberData.type.find( "const" ) != 0 ) ) { ofs << "const "; } @@ -1856,23 +1860,47 @@ void writeStructGetter( std::ofstream & ofs, MemberData const& memberData, std:: } else { - ofs << "const " << memberData.type << ( memberData.arraySize.empty() ? '&' : '*' ); + if (constVersion) + { + ofs << "const "; + } + ofs << memberData.type << ( memberData.arraySize.empty() ? '&' : '*' ); } - ofs << " " << memberData.name << "() const" << std::endl + ofs << " " << memberData.name << "()"; + if (constVersion) + { + ofs << " const"; + } + ofs << std::endl << " {" << std::endl << " return "; if ( ! memberData.arraySize.empty() ) { - ofs << "reinterpret_cast( " << memberName << "." << memberData.name << " )"; + ofs << "reinterpret_cast<"; + if (constVersion) + { + ofs << "const "; + } + ofs << memberData.type << "*>( " << memberName << "." << memberData.name << " )"; } else if ( memberData.type.back() == '*' ) { - ofs << "reinterpret_cast<" << memberData.type << ">( " << memberName << "." << memberData.name << " )"; + ofs << "reinterpret_cast<"; + if (constVersion && (memberData.type.find("const") != 0)) + { + ofs << "const "; + } + ofs << memberData.type << ">( " << memberName << "." << memberData.name << " )"; } else if ( vkTypes.find( memberData.pureType ) != vkTypes.end() ) { - ofs << "reinterpret_cast( " << memberName << "." << memberData.name << " )"; + ofs << "reinterpret_cast<"; + if (constVersion) + { + ofs << "const "; + } + ofs << memberData.pureType << "&>( " << memberName << "." << memberData.name << " )"; } else { @@ -2548,9 +2576,10 @@ void writeTypeStruct( std::ofstream & ofs, DependencyData const& dependencyData, // create the getters and setters for ( size_t i=0 ; isecond.members.size() ; i++ ) { - writeStructGetter( ofs, it->second.members[i], memberName, vkTypes ); - if ( !it->second.returnedOnly ) + writeStructGetter(ofs, it->second.members[i], memberName, vkTypes, true); + if (!it->second.returnedOnly) { + writeStructGetter(ofs, it->second.members[i], memberName, vkTypes, false); writeStructSetter( ofs, dependencyData.name, it->second.members[i], memberName, vkTypes ); } } @@ -2627,8 +2656,11 @@ void writeTypeUnion( std::ofstream & ofs, DependencyData const& dependencyData, << std::endl; // one getter/setter per union element - writeStructGetter( ofs, unionData.members[i], memberName, vkTypes ); - writeStructSetter( ofs, dependencyData.name, unionData.members[i], memberName, vkTypes ); + writeStructGetter(ofs, unionData.members[i], memberName, vkTypes, true); + + assert(!unionData.returnedOnly); + writeStructGetter(ofs, unionData.members[i], memberName, vkTypes, false); + writeStructSetter(ofs, dependencyData.name, unionData.members[i], memberName, vkTypes); } ofs << " operator Vk" << dependencyData.name << " const& () const" << std::endl << " {" << std::endl diff --git a/vulkan/vk_cpp.h b/vulkan/vk_cpp.h index 3e973a6..12bffd1 100644 --- a/vulkan/vk_cpp.h +++ b/vulkan/vk_cpp.h @@ -1685,6 +1685,11 @@ namespace vk return m_offset2D.x; } + int32_t& x() + { + return m_offset2D.x; + } + Offset2D& x( int32_t x ) { m_offset2D.x = x; @@ -1696,6 +1701,11 @@ namespace vk return m_offset2D.y; } + int32_t& y() + { + return m_offset2D.y; + } + Offset2D& y( int32_t y ) { m_offset2D.y = y; @@ -1742,6 +1752,11 @@ namespace vk return m_offset3D.x; } + int32_t& x() + { + return m_offset3D.x; + } + Offset3D& x( int32_t x ) { m_offset3D.x = x; @@ -1753,6 +1768,11 @@ namespace vk return m_offset3D.y; } + int32_t& y() + { + return m_offset3D.y; + } + Offset3D& y( int32_t y ) { m_offset3D.y = y; @@ -1764,6 +1784,11 @@ namespace vk return m_offset3D.z; } + int32_t& z() + { + return m_offset3D.z; + } + Offset3D& z( int32_t z ) { m_offset3D.z = z; @@ -1809,6 +1834,11 @@ namespace vk return m_extent2D.width; } + uint32_t& width() + { + return m_extent2D.width; + } + Extent2D& width( uint32_t width ) { m_extent2D.width = width; @@ -1820,6 +1850,11 @@ namespace vk return m_extent2D.height; } + uint32_t& height() + { + return m_extent2D.height; + } + Extent2D& height( uint32_t height ) { m_extent2D.height = height; @@ -1866,6 +1901,11 @@ namespace vk return m_extent3D.width; } + uint32_t& width() + { + return m_extent3D.width; + } + Extent3D& width( uint32_t width ) { m_extent3D.width = width; @@ -1877,6 +1917,11 @@ namespace vk return m_extent3D.height; } + uint32_t& height() + { + return m_extent3D.height; + } + Extent3D& height( uint32_t height ) { m_extent3D.height = height; @@ -1888,6 +1933,11 @@ namespace vk return m_extent3D.depth; } + uint32_t& depth() + { + return m_extent3D.depth; + } + Extent3D& depth( uint32_t depth ) { m_extent3D.depth = depth; @@ -1937,6 +1987,11 @@ namespace vk return m_viewport.x; } + float& x() + { + return m_viewport.x; + } + Viewport& x( float x ) { m_viewport.x = x; @@ -1948,6 +2003,11 @@ namespace vk return m_viewport.y; } + float& y() + { + return m_viewport.y; + } + Viewport& y( float y ) { m_viewport.y = y; @@ -1959,6 +2019,11 @@ namespace vk return m_viewport.width; } + float& width() + { + return m_viewport.width; + } + Viewport& width( float width ) { m_viewport.width = width; @@ -1970,6 +2035,11 @@ namespace vk return m_viewport.height; } + float& height() + { + return m_viewport.height; + } + Viewport& height( float height ) { m_viewport.height = height; @@ -1981,6 +2051,11 @@ namespace vk return m_viewport.minDepth; } + float& minDepth() + { + return m_viewport.minDepth; + } + Viewport& minDepth( float minDepth ) { m_viewport.minDepth = minDepth; @@ -1992,6 +2067,11 @@ namespace vk return m_viewport.maxDepth; } + float& maxDepth() + { + return m_viewport.maxDepth; + } + Viewport& maxDepth( float maxDepth ) { m_viewport.maxDepth = maxDepth; @@ -2037,6 +2117,11 @@ namespace vk return reinterpret_cast( m_rect2D.offset ); } + Offset2D& offset() + { + return reinterpret_cast( m_rect2D.offset ); + } + Rect2D& offset( Offset2D offset ) { m_rect2D.offset = static_cast( offset ); @@ -2048,6 +2133,11 @@ namespace vk return reinterpret_cast( m_rect2D.extent ); } + Extent2D& extent() + { + return reinterpret_cast( m_rect2D.extent ); + } + Rect2D& extent( Extent2D extent ) { m_rect2D.extent = static_cast( extent ); @@ -2094,6 +2184,11 @@ namespace vk return reinterpret_cast( m_clearRect.rect ); } + Rect2D& rect() + { + return reinterpret_cast( m_clearRect.rect ); + } + ClearRect& rect( Rect2D rect ) { m_clearRect.rect = static_cast( rect ); @@ -2105,6 +2200,11 @@ namespace vk return m_clearRect.baseArrayLayer; } + uint32_t& baseArrayLayer() + { + return m_clearRect.baseArrayLayer; + } + ClearRect& baseArrayLayer( uint32_t baseArrayLayer ) { m_clearRect.baseArrayLayer = baseArrayLayer; @@ -2116,6 +2216,11 @@ namespace vk return m_clearRect.layerCount; } + uint32_t& layerCount() + { + return m_clearRect.layerCount; + } + ClearRect& layerCount( uint32_t layerCount ) { m_clearRect.layerCount = layerCount; @@ -2213,6 +2318,11 @@ namespace vk } const void* pUserData() const + { + return reinterpret_cast( m_allocationCallbacks.pUserData ); + } + + void* pUserData() { return reinterpret_cast( m_allocationCallbacks.pUserData ); } @@ -2228,6 +2338,11 @@ namespace vk return m_allocationCallbacks.pfnAllocation; } + PFN_vkAllocationFunction& pfnAllocation() + { + return m_allocationCallbacks.pfnAllocation; + } + AllocationCallbacks& pfnAllocation( PFN_vkAllocationFunction pfnAllocation ) { m_allocationCallbacks.pfnAllocation = pfnAllocation; @@ -2239,6 +2354,11 @@ namespace vk return m_allocationCallbacks.pfnReallocation; } + PFN_vkReallocationFunction& pfnReallocation() + { + return m_allocationCallbacks.pfnReallocation; + } + AllocationCallbacks& pfnReallocation( PFN_vkReallocationFunction pfnReallocation ) { m_allocationCallbacks.pfnReallocation = pfnReallocation; @@ -2250,6 +2370,11 @@ namespace vk return m_allocationCallbacks.pfnFree; } + PFN_vkFreeFunction& pfnFree() + { + return m_allocationCallbacks.pfnFree; + } + AllocationCallbacks& pfnFree( PFN_vkFreeFunction pfnFree ) { m_allocationCallbacks.pfnFree = pfnFree; @@ -2261,6 +2386,11 @@ namespace vk return m_allocationCallbacks.pfnInternalAllocation; } + PFN_vkInternalAllocationNotification& pfnInternalAllocation() + { + return m_allocationCallbacks.pfnInternalAllocation; + } + AllocationCallbacks& pfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation ) { m_allocationCallbacks.pfnInternalAllocation = pfnInternalAllocation; @@ -2272,6 +2402,11 @@ namespace vk return m_allocationCallbacks.pfnInternalFree; } + PFN_vkInternalFreeNotification& pfnInternalFree() + { + return m_allocationCallbacks.pfnInternalFree; + } + AllocationCallbacks& pfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree ) { m_allocationCallbacks.pfnInternalFree = pfnInternalFree; @@ -2346,6 +2481,11 @@ namespace vk return reinterpret_cast( m_descriptorBufferInfo.buffer ); } + Buffer& buffer() + { + return reinterpret_cast( m_descriptorBufferInfo.buffer ); + } + DescriptorBufferInfo& buffer( Buffer buffer ) { m_descriptorBufferInfo.buffer = static_cast( buffer ); @@ -2357,6 +2497,11 @@ namespace vk return m_descriptorBufferInfo.offset; } + DeviceSize& offset() + { + return m_descriptorBufferInfo.offset; + } + DescriptorBufferInfo& offset( DeviceSize offset ) { m_descriptorBufferInfo.offset = offset; @@ -2368,6 +2513,11 @@ namespace vk return m_descriptorBufferInfo.range; } + DeviceSize& range() + { + return m_descriptorBufferInfo.range; + } + DescriptorBufferInfo& range( DeviceSize range ) { m_descriptorBufferInfo.range = range; @@ -2416,6 +2566,11 @@ namespace vk return m_subresourceLayout.offset; } + DeviceSize& offset() + { + return m_subresourceLayout.offset; + } + SubresourceLayout& offset( DeviceSize offset ) { m_subresourceLayout.offset = offset; @@ -2427,6 +2582,11 @@ namespace vk return m_subresourceLayout.size; } + DeviceSize& size() + { + return m_subresourceLayout.size; + } + SubresourceLayout& size( DeviceSize size ) { m_subresourceLayout.size = size; @@ -2438,6 +2598,11 @@ namespace vk return m_subresourceLayout.rowPitch; } + DeviceSize& rowPitch() + { + return m_subresourceLayout.rowPitch; + } + SubresourceLayout& rowPitch( DeviceSize rowPitch ) { m_subresourceLayout.rowPitch = rowPitch; @@ -2449,6 +2614,11 @@ namespace vk return m_subresourceLayout.arrayPitch; } + DeviceSize& arrayPitch() + { + return m_subresourceLayout.arrayPitch; + } + SubresourceLayout& arrayPitch( DeviceSize arrayPitch ) { m_subresourceLayout.arrayPitch = arrayPitch; @@ -2460,6 +2630,11 @@ namespace vk return m_subresourceLayout.depthPitch; } + DeviceSize& depthPitch() + { + return m_subresourceLayout.depthPitch; + } + SubresourceLayout& depthPitch( DeviceSize depthPitch ) { m_subresourceLayout.depthPitch = depthPitch; @@ -2506,6 +2681,11 @@ namespace vk return m_bufferCopy.srcOffset; } + DeviceSize& srcOffset() + { + return m_bufferCopy.srcOffset; + } + BufferCopy& srcOffset( DeviceSize srcOffset ) { m_bufferCopy.srcOffset = srcOffset; @@ -2517,6 +2697,11 @@ namespace vk return m_bufferCopy.dstOffset; } + DeviceSize& dstOffset() + { + return m_bufferCopy.dstOffset; + } + BufferCopy& dstOffset( DeviceSize dstOffset ) { m_bufferCopy.dstOffset = dstOffset; @@ -2528,6 +2713,11 @@ namespace vk return m_bufferCopy.size; } + DeviceSize& size() + { + return m_bufferCopy.size; + } + BufferCopy& size( DeviceSize size ) { m_bufferCopy.size = size; @@ -2574,6 +2764,11 @@ namespace vk return m_specializationMapEntry.constantID; } + uint32_t& constantID() + { + return m_specializationMapEntry.constantID; + } + SpecializationMapEntry& constantID( uint32_t constantID ) { m_specializationMapEntry.constantID = constantID; @@ -2585,6 +2780,11 @@ namespace vk return m_specializationMapEntry.offset; } + uint32_t& offset() + { + return m_specializationMapEntry.offset; + } + SpecializationMapEntry& offset( uint32_t offset ) { m_specializationMapEntry.offset = offset; @@ -2596,6 +2796,11 @@ namespace vk return m_specializationMapEntry.size; } + size_t& size() + { + return m_specializationMapEntry.size; + } + SpecializationMapEntry& size( size_t size ) { m_specializationMapEntry.size = size; @@ -2643,6 +2848,11 @@ namespace vk return m_specializationInfo.mapEntryCount; } + uint32_t& mapEntryCount() + { + return m_specializationInfo.mapEntryCount; + } + SpecializationInfo& mapEntryCount( uint32_t mapEntryCount ) { m_specializationInfo.mapEntryCount = mapEntryCount; @@ -2654,6 +2864,11 @@ namespace vk return reinterpret_cast( m_specializationInfo.pMapEntries ); } + const SpecializationMapEntry* pMapEntries() + { + return reinterpret_cast( m_specializationInfo.pMapEntries ); + } + SpecializationInfo& pMapEntries( const SpecializationMapEntry* pMapEntries ) { m_specializationInfo.pMapEntries = reinterpret_cast( pMapEntries ); @@ -2665,6 +2880,11 @@ namespace vk return m_specializationInfo.dataSize; } + size_t& dataSize() + { + return m_specializationInfo.dataSize; + } + SpecializationInfo& dataSize( size_t dataSize ) { m_specializationInfo.dataSize = dataSize; @@ -2676,6 +2896,11 @@ namespace vk return reinterpret_cast( m_specializationInfo.pData ); } + const void* pData() + { + return reinterpret_cast( m_specializationInfo.pData ); + } + SpecializationInfo& pData( const void* pData ) { m_specializationInfo.pData = pData; @@ -2705,6 +2930,11 @@ namespace vk return reinterpret_cast( m_clearColorValue.float32 ); } + float* float32() + { + return reinterpret_cast( m_clearColorValue.float32 ); + } + ClearColorValue& float32( std::array float32 ) { memcpy( &m_clearColorValue.float32, float32.data(), 4 * sizeof( float ) ); @@ -2721,6 +2951,11 @@ namespace vk return reinterpret_cast( m_clearColorValue.int32 ); } + int32_t* int32() + { + return reinterpret_cast( m_clearColorValue.int32 ); + } + ClearColorValue& int32( std::array int32 ) { memcpy( &m_clearColorValue.int32, int32.data(), 4 * sizeof( int32_t ) ); @@ -2737,6 +2972,11 @@ namespace vk return reinterpret_cast( m_clearColorValue.uint32 ); } + uint32_t* uint32() + { + return reinterpret_cast( m_clearColorValue.uint32 ); + } + ClearColorValue& uint32( std::array uint32 ) { memcpy( &m_clearColorValue.uint32, uint32.data(), 4 * sizeof( uint32_t ) ); @@ -2781,6 +3021,11 @@ namespace vk return m_clearDepthStencilValue.depth; } + float& depth() + { + return m_clearDepthStencilValue.depth; + } + ClearDepthStencilValue& depth( float depth ) { m_clearDepthStencilValue.depth = depth; @@ -2792,6 +3037,11 @@ namespace vk return m_clearDepthStencilValue.stencil; } + uint32_t& stencil() + { + return m_clearDepthStencilValue.stencil; + } + ClearDepthStencilValue& stencil( uint32_t stencil ) { m_clearDepthStencilValue.stencil = stencil; @@ -2821,6 +3071,11 @@ namespace vk return reinterpret_cast( m_clearValue.color ); } + ClearColorValue& color() + { + return reinterpret_cast( m_clearValue.color ); + } + ClearValue& color( ClearColorValue color ) { m_clearValue.color = static_cast( color ); @@ -2837,6 +3092,11 @@ namespace vk return reinterpret_cast( m_clearValue.depthStencil ); } + ClearDepthStencilValue& depthStencil() + { + return reinterpret_cast( m_clearValue.depthStencil ); + } + ClearValue& depthStencil( ClearDepthStencilValue depthStencil ) { m_clearValue.depthStencil = static_cast( depthStencil ); @@ -2934,6 +3194,11 @@ namespace vk return m_physicalDeviceFeatures.robustBufferAccess; } + Bool32& robustBufferAccess() + { + return m_physicalDeviceFeatures.robustBufferAccess; + } + PhysicalDeviceFeatures& robustBufferAccess( Bool32 robustBufferAccess ) { m_physicalDeviceFeatures.robustBufferAccess = robustBufferAccess; @@ -2945,6 +3210,11 @@ namespace vk return m_physicalDeviceFeatures.fullDrawIndexUint32; } + Bool32& fullDrawIndexUint32() + { + return m_physicalDeviceFeatures.fullDrawIndexUint32; + } + PhysicalDeviceFeatures& fullDrawIndexUint32( Bool32 fullDrawIndexUint32 ) { m_physicalDeviceFeatures.fullDrawIndexUint32 = fullDrawIndexUint32; @@ -2956,6 +3226,11 @@ namespace vk return m_physicalDeviceFeatures.imageCubeArray; } + Bool32& imageCubeArray() + { + return m_physicalDeviceFeatures.imageCubeArray; + } + PhysicalDeviceFeatures& imageCubeArray( Bool32 imageCubeArray ) { m_physicalDeviceFeatures.imageCubeArray = imageCubeArray; @@ -2967,6 +3242,11 @@ namespace vk return m_physicalDeviceFeatures.independentBlend; } + Bool32& independentBlend() + { + return m_physicalDeviceFeatures.independentBlend; + } + PhysicalDeviceFeatures& independentBlend( Bool32 independentBlend ) { m_physicalDeviceFeatures.independentBlend = independentBlend; @@ -2978,6 +3258,11 @@ namespace vk return m_physicalDeviceFeatures.geometryShader; } + Bool32& geometryShader() + { + return m_physicalDeviceFeatures.geometryShader; + } + PhysicalDeviceFeatures& geometryShader( Bool32 geometryShader ) { m_physicalDeviceFeatures.geometryShader = geometryShader; @@ -2989,6 +3274,11 @@ namespace vk return m_physicalDeviceFeatures.tessellationShader; } + Bool32& tessellationShader() + { + return m_physicalDeviceFeatures.tessellationShader; + } + PhysicalDeviceFeatures& tessellationShader( Bool32 tessellationShader ) { m_physicalDeviceFeatures.tessellationShader = tessellationShader; @@ -3000,6 +3290,11 @@ namespace vk return m_physicalDeviceFeatures.sampleRateShading; } + Bool32& sampleRateShading() + { + return m_physicalDeviceFeatures.sampleRateShading; + } + PhysicalDeviceFeatures& sampleRateShading( Bool32 sampleRateShading ) { m_physicalDeviceFeatures.sampleRateShading = sampleRateShading; @@ -3011,6 +3306,11 @@ namespace vk return m_physicalDeviceFeatures.dualSrcBlend; } + Bool32& dualSrcBlend() + { + return m_physicalDeviceFeatures.dualSrcBlend; + } + PhysicalDeviceFeatures& dualSrcBlend( Bool32 dualSrcBlend ) { m_physicalDeviceFeatures.dualSrcBlend = dualSrcBlend; @@ -3022,6 +3322,11 @@ namespace vk return m_physicalDeviceFeatures.logicOp; } + Bool32& logicOp() + { + return m_physicalDeviceFeatures.logicOp; + } + PhysicalDeviceFeatures& logicOp( Bool32 logicOp ) { m_physicalDeviceFeatures.logicOp = logicOp; @@ -3033,6 +3338,11 @@ namespace vk return m_physicalDeviceFeatures.multiDrawIndirect; } + Bool32& multiDrawIndirect() + { + return m_physicalDeviceFeatures.multiDrawIndirect; + } + PhysicalDeviceFeatures& multiDrawIndirect( Bool32 multiDrawIndirect ) { m_physicalDeviceFeatures.multiDrawIndirect = multiDrawIndirect; @@ -3044,6 +3354,11 @@ namespace vk return m_physicalDeviceFeatures.drawIndirectFirstInstance; } + Bool32& drawIndirectFirstInstance() + { + return m_physicalDeviceFeatures.drawIndirectFirstInstance; + } + PhysicalDeviceFeatures& drawIndirectFirstInstance( Bool32 drawIndirectFirstInstance ) { m_physicalDeviceFeatures.drawIndirectFirstInstance = drawIndirectFirstInstance; @@ -3055,6 +3370,11 @@ namespace vk return m_physicalDeviceFeatures.depthClamp; } + Bool32& depthClamp() + { + return m_physicalDeviceFeatures.depthClamp; + } + PhysicalDeviceFeatures& depthClamp( Bool32 depthClamp ) { m_physicalDeviceFeatures.depthClamp = depthClamp; @@ -3066,6 +3386,11 @@ namespace vk return m_physicalDeviceFeatures.depthBiasClamp; } + Bool32& depthBiasClamp() + { + return m_physicalDeviceFeatures.depthBiasClamp; + } + PhysicalDeviceFeatures& depthBiasClamp( Bool32 depthBiasClamp ) { m_physicalDeviceFeatures.depthBiasClamp = depthBiasClamp; @@ -3077,6 +3402,11 @@ namespace vk return m_physicalDeviceFeatures.fillModeNonSolid; } + Bool32& fillModeNonSolid() + { + return m_physicalDeviceFeatures.fillModeNonSolid; + } + PhysicalDeviceFeatures& fillModeNonSolid( Bool32 fillModeNonSolid ) { m_physicalDeviceFeatures.fillModeNonSolid = fillModeNonSolid; @@ -3088,6 +3418,11 @@ namespace vk return m_physicalDeviceFeatures.depthBounds; } + Bool32& depthBounds() + { + return m_physicalDeviceFeatures.depthBounds; + } + PhysicalDeviceFeatures& depthBounds( Bool32 depthBounds ) { m_physicalDeviceFeatures.depthBounds = depthBounds; @@ -3099,6 +3434,11 @@ namespace vk return m_physicalDeviceFeatures.wideLines; } + Bool32& wideLines() + { + return m_physicalDeviceFeatures.wideLines; + } + PhysicalDeviceFeatures& wideLines( Bool32 wideLines ) { m_physicalDeviceFeatures.wideLines = wideLines; @@ -3110,6 +3450,11 @@ namespace vk return m_physicalDeviceFeatures.largePoints; } + Bool32& largePoints() + { + return m_physicalDeviceFeatures.largePoints; + } + PhysicalDeviceFeatures& largePoints( Bool32 largePoints ) { m_physicalDeviceFeatures.largePoints = largePoints; @@ -3121,6 +3466,11 @@ namespace vk return m_physicalDeviceFeatures.alphaToOne; } + Bool32& alphaToOne() + { + return m_physicalDeviceFeatures.alphaToOne; + } + PhysicalDeviceFeatures& alphaToOne( Bool32 alphaToOne ) { m_physicalDeviceFeatures.alphaToOne = alphaToOne; @@ -3132,6 +3482,11 @@ namespace vk return m_physicalDeviceFeatures.multiViewport; } + Bool32& multiViewport() + { + return m_physicalDeviceFeatures.multiViewport; + } + PhysicalDeviceFeatures& multiViewport( Bool32 multiViewport ) { m_physicalDeviceFeatures.multiViewport = multiViewport; @@ -3143,6 +3498,11 @@ namespace vk return m_physicalDeviceFeatures.samplerAnisotropy; } + Bool32& samplerAnisotropy() + { + return m_physicalDeviceFeatures.samplerAnisotropy; + } + PhysicalDeviceFeatures& samplerAnisotropy( Bool32 samplerAnisotropy ) { m_physicalDeviceFeatures.samplerAnisotropy = samplerAnisotropy; @@ -3154,6 +3514,11 @@ namespace vk return m_physicalDeviceFeatures.textureCompressionETC2; } + Bool32& textureCompressionETC2() + { + return m_physicalDeviceFeatures.textureCompressionETC2; + } + PhysicalDeviceFeatures& textureCompressionETC2( Bool32 textureCompressionETC2 ) { m_physicalDeviceFeatures.textureCompressionETC2 = textureCompressionETC2; @@ -3165,6 +3530,11 @@ namespace vk return m_physicalDeviceFeatures.textureCompressionASTC_LDR; } + Bool32& textureCompressionASTC_LDR() + { + return m_physicalDeviceFeatures.textureCompressionASTC_LDR; + } + PhysicalDeviceFeatures& textureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR ) { m_physicalDeviceFeatures.textureCompressionASTC_LDR = textureCompressionASTC_LDR; @@ -3176,6 +3546,11 @@ namespace vk return m_physicalDeviceFeatures.textureCompressionBC; } + Bool32& textureCompressionBC() + { + return m_physicalDeviceFeatures.textureCompressionBC; + } + PhysicalDeviceFeatures& textureCompressionBC( Bool32 textureCompressionBC ) { m_physicalDeviceFeatures.textureCompressionBC = textureCompressionBC; @@ -3187,6 +3562,11 @@ namespace vk return m_physicalDeviceFeatures.occlusionQueryPrecise; } + Bool32& occlusionQueryPrecise() + { + return m_physicalDeviceFeatures.occlusionQueryPrecise; + } + PhysicalDeviceFeatures& occlusionQueryPrecise( Bool32 occlusionQueryPrecise ) { m_physicalDeviceFeatures.occlusionQueryPrecise = occlusionQueryPrecise; @@ -3198,6 +3578,11 @@ namespace vk return m_physicalDeviceFeatures.pipelineStatisticsQuery; } + Bool32& pipelineStatisticsQuery() + { + return m_physicalDeviceFeatures.pipelineStatisticsQuery; + } + PhysicalDeviceFeatures& pipelineStatisticsQuery( Bool32 pipelineStatisticsQuery ) { m_physicalDeviceFeatures.pipelineStatisticsQuery = pipelineStatisticsQuery; @@ -3209,6 +3594,11 @@ namespace vk return m_physicalDeviceFeatures.vertexPipelineStoresAndAtomics; } + Bool32& vertexPipelineStoresAndAtomics() + { + return m_physicalDeviceFeatures.vertexPipelineStoresAndAtomics; + } + PhysicalDeviceFeatures& vertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics ) { m_physicalDeviceFeatures.vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics; @@ -3220,6 +3610,11 @@ namespace vk return m_physicalDeviceFeatures.fragmentStoresAndAtomics; } + Bool32& fragmentStoresAndAtomics() + { + return m_physicalDeviceFeatures.fragmentStoresAndAtomics; + } + PhysicalDeviceFeatures& fragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics ) { m_physicalDeviceFeatures.fragmentStoresAndAtomics = fragmentStoresAndAtomics; @@ -3231,6 +3626,11 @@ namespace vk return m_physicalDeviceFeatures.shaderTessellationAndGeometryPointSize; } + Bool32& shaderTessellationAndGeometryPointSize() + { + return m_physicalDeviceFeatures.shaderTessellationAndGeometryPointSize; + } + PhysicalDeviceFeatures& shaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize ) { m_physicalDeviceFeatures.shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize; @@ -3242,6 +3642,11 @@ namespace vk return m_physicalDeviceFeatures.shaderImageGatherExtended; } + Bool32& shaderImageGatherExtended() + { + return m_physicalDeviceFeatures.shaderImageGatherExtended; + } + PhysicalDeviceFeatures& shaderImageGatherExtended( Bool32 shaderImageGatherExtended ) { m_physicalDeviceFeatures.shaderImageGatherExtended = shaderImageGatherExtended; @@ -3253,6 +3658,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageExtendedFormats; } + Bool32& shaderStorageImageExtendedFormats() + { + return m_physicalDeviceFeatures.shaderStorageImageExtendedFormats; + } + PhysicalDeviceFeatures& shaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats ) { m_physicalDeviceFeatures.shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats; @@ -3264,6 +3674,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageMultisample; } + Bool32& shaderStorageImageMultisample() + { + return m_physicalDeviceFeatures.shaderStorageImageMultisample; + } + PhysicalDeviceFeatures& shaderStorageImageMultisample( Bool32 shaderStorageImageMultisample ) { m_physicalDeviceFeatures.shaderStorageImageMultisample = shaderStorageImageMultisample; @@ -3275,6 +3690,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageReadWithoutFormat; } + Bool32& shaderStorageImageReadWithoutFormat() + { + return m_physicalDeviceFeatures.shaderStorageImageReadWithoutFormat; + } + PhysicalDeviceFeatures& shaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat ) { m_physicalDeviceFeatures.shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat; @@ -3286,6 +3706,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat; } + Bool32& shaderStorageImageWriteWithoutFormat() + { + return m_physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat; + } + PhysicalDeviceFeatures& shaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat ) { m_physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat; @@ -3297,6 +3722,11 @@ namespace vk return m_physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing; } + Bool32& shaderUniformBufferArrayDynamicIndexing() + { + return m_physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing; + } + PhysicalDeviceFeatures& shaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing ) { m_physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing; @@ -3308,6 +3738,11 @@ namespace vk return m_physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing; } + Bool32& shaderSampledImageArrayDynamicIndexing() + { + return m_physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing; + } + PhysicalDeviceFeatures& shaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing ) { m_physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing; @@ -3319,6 +3754,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing; } + Bool32& shaderStorageBufferArrayDynamicIndexing() + { + return m_physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing; + } + PhysicalDeviceFeatures& shaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing ) { m_physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing; @@ -3330,6 +3770,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing; } + Bool32& shaderStorageImageArrayDynamicIndexing() + { + return m_physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing; + } + PhysicalDeviceFeatures& shaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing ) { m_physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing; @@ -3341,6 +3786,11 @@ namespace vk return m_physicalDeviceFeatures.shaderClipDistance; } + Bool32& shaderClipDistance() + { + return m_physicalDeviceFeatures.shaderClipDistance; + } + PhysicalDeviceFeatures& shaderClipDistance( Bool32 shaderClipDistance ) { m_physicalDeviceFeatures.shaderClipDistance = shaderClipDistance; @@ -3352,6 +3802,11 @@ namespace vk return m_physicalDeviceFeatures.shaderCullDistance; } + Bool32& shaderCullDistance() + { + return m_physicalDeviceFeatures.shaderCullDistance; + } + PhysicalDeviceFeatures& shaderCullDistance( Bool32 shaderCullDistance ) { m_physicalDeviceFeatures.shaderCullDistance = shaderCullDistance; @@ -3363,6 +3818,11 @@ namespace vk return m_physicalDeviceFeatures.shaderFloat64; } + Bool32& shaderFloat64() + { + return m_physicalDeviceFeatures.shaderFloat64; + } + PhysicalDeviceFeatures& shaderFloat64( Bool32 shaderFloat64 ) { m_physicalDeviceFeatures.shaderFloat64 = shaderFloat64; @@ -3374,6 +3834,11 @@ namespace vk return m_physicalDeviceFeatures.shaderInt64; } + Bool32& shaderInt64() + { + return m_physicalDeviceFeatures.shaderInt64; + } + PhysicalDeviceFeatures& shaderInt64( Bool32 shaderInt64 ) { m_physicalDeviceFeatures.shaderInt64 = shaderInt64; @@ -3385,6 +3850,11 @@ namespace vk return m_physicalDeviceFeatures.shaderInt16; } + Bool32& shaderInt16() + { + return m_physicalDeviceFeatures.shaderInt16; + } + PhysicalDeviceFeatures& shaderInt16( Bool32 shaderInt16 ) { m_physicalDeviceFeatures.shaderInt16 = shaderInt16; @@ -3396,6 +3866,11 @@ namespace vk return m_physicalDeviceFeatures.shaderResourceResidency; } + Bool32& shaderResourceResidency() + { + return m_physicalDeviceFeatures.shaderResourceResidency; + } + PhysicalDeviceFeatures& shaderResourceResidency( Bool32 shaderResourceResidency ) { m_physicalDeviceFeatures.shaderResourceResidency = shaderResourceResidency; @@ -3407,6 +3882,11 @@ namespace vk return m_physicalDeviceFeatures.shaderResourceMinLod; } + Bool32& shaderResourceMinLod() + { + return m_physicalDeviceFeatures.shaderResourceMinLod; + } + PhysicalDeviceFeatures& shaderResourceMinLod( Bool32 shaderResourceMinLod ) { m_physicalDeviceFeatures.shaderResourceMinLod = shaderResourceMinLod; @@ -3418,6 +3898,11 @@ namespace vk return m_physicalDeviceFeatures.sparseBinding; } + Bool32& sparseBinding() + { + return m_physicalDeviceFeatures.sparseBinding; + } + PhysicalDeviceFeatures& sparseBinding( Bool32 sparseBinding ) { m_physicalDeviceFeatures.sparseBinding = sparseBinding; @@ -3429,6 +3914,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidencyBuffer; } + Bool32& sparseResidencyBuffer() + { + return m_physicalDeviceFeatures.sparseResidencyBuffer; + } + PhysicalDeviceFeatures& sparseResidencyBuffer( Bool32 sparseResidencyBuffer ) { m_physicalDeviceFeatures.sparseResidencyBuffer = sparseResidencyBuffer; @@ -3440,6 +3930,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidencyImage2D; } + Bool32& sparseResidencyImage2D() + { + return m_physicalDeviceFeatures.sparseResidencyImage2D; + } + PhysicalDeviceFeatures& sparseResidencyImage2D( Bool32 sparseResidencyImage2D ) { m_physicalDeviceFeatures.sparseResidencyImage2D = sparseResidencyImage2D; @@ -3451,6 +3946,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidencyImage3D; } + Bool32& sparseResidencyImage3D() + { + return m_physicalDeviceFeatures.sparseResidencyImage3D; + } + PhysicalDeviceFeatures& sparseResidencyImage3D( Bool32 sparseResidencyImage3D ) { m_physicalDeviceFeatures.sparseResidencyImage3D = sparseResidencyImage3D; @@ -3462,6 +3962,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidency2Samples; } + Bool32& sparseResidency2Samples() + { + return m_physicalDeviceFeatures.sparseResidency2Samples; + } + PhysicalDeviceFeatures& sparseResidency2Samples( Bool32 sparseResidency2Samples ) { m_physicalDeviceFeatures.sparseResidency2Samples = sparseResidency2Samples; @@ -3473,6 +3978,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidency4Samples; } + Bool32& sparseResidency4Samples() + { + return m_physicalDeviceFeatures.sparseResidency4Samples; + } + PhysicalDeviceFeatures& sparseResidency4Samples( Bool32 sparseResidency4Samples ) { m_physicalDeviceFeatures.sparseResidency4Samples = sparseResidency4Samples; @@ -3484,6 +3994,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidency8Samples; } + Bool32& sparseResidency8Samples() + { + return m_physicalDeviceFeatures.sparseResidency8Samples; + } + PhysicalDeviceFeatures& sparseResidency8Samples( Bool32 sparseResidency8Samples ) { m_physicalDeviceFeatures.sparseResidency8Samples = sparseResidency8Samples; @@ -3495,6 +4010,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidency16Samples; } + Bool32& sparseResidency16Samples() + { + return m_physicalDeviceFeatures.sparseResidency16Samples; + } + PhysicalDeviceFeatures& sparseResidency16Samples( Bool32 sparseResidency16Samples ) { m_physicalDeviceFeatures.sparseResidency16Samples = sparseResidency16Samples; @@ -3506,6 +4026,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidencyAliased; } + Bool32& sparseResidencyAliased() + { + return m_physicalDeviceFeatures.sparseResidencyAliased; + } + PhysicalDeviceFeatures& sparseResidencyAliased( Bool32 sparseResidencyAliased ) { m_physicalDeviceFeatures.sparseResidencyAliased = sparseResidencyAliased; @@ -3517,6 +4042,11 @@ namespace vk return m_physicalDeviceFeatures.variableMultisampleRate; } + Bool32& variableMultisampleRate() + { + return m_physicalDeviceFeatures.variableMultisampleRate; + } + PhysicalDeviceFeatures& variableMultisampleRate( Bool32 variableMultisampleRate ) { m_physicalDeviceFeatures.variableMultisampleRate = variableMultisampleRate; @@ -3528,6 +4058,11 @@ namespace vk return m_physicalDeviceFeatures.inheritedQueries; } + Bool32& inheritedQueries() + { + return m_physicalDeviceFeatures.inheritedQueries; + } + PhysicalDeviceFeatures& inheritedQueries( Bool32 inheritedQueries ) { m_physicalDeviceFeatures.inheritedQueries = inheritedQueries; @@ -3613,6 +4148,11 @@ namespace vk return m_drawIndirectCommand.vertexCount; } + uint32_t& vertexCount() + { + return m_drawIndirectCommand.vertexCount; + } + DrawIndirectCommand& vertexCount( uint32_t vertexCount ) { m_drawIndirectCommand.vertexCount = vertexCount; @@ -3624,6 +4164,11 @@ namespace vk return m_drawIndirectCommand.instanceCount; } + uint32_t& instanceCount() + { + return m_drawIndirectCommand.instanceCount; + } + DrawIndirectCommand& instanceCount( uint32_t instanceCount ) { m_drawIndirectCommand.instanceCount = instanceCount; @@ -3635,6 +4180,11 @@ namespace vk return m_drawIndirectCommand.firstVertex; } + uint32_t& firstVertex() + { + return m_drawIndirectCommand.firstVertex; + } + DrawIndirectCommand& firstVertex( uint32_t firstVertex ) { m_drawIndirectCommand.firstVertex = firstVertex; @@ -3646,6 +4196,11 @@ namespace vk return m_drawIndirectCommand.firstInstance; } + uint32_t& firstInstance() + { + return m_drawIndirectCommand.firstInstance; + } + DrawIndirectCommand& firstInstance( uint32_t firstInstance ) { m_drawIndirectCommand.firstInstance = firstInstance; @@ -3694,6 +4249,11 @@ namespace vk return m_drawIndexedIndirectCommand.indexCount; } + uint32_t& indexCount() + { + return m_drawIndexedIndirectCommand.indexCount; + } + DrawIndexedIndirectCommand& indexCount( uint32_t indexCount ) { m_drawIndexedIndirectCommand.indexCount = indexCount; @@ -3705,6 +4265,11 @@ namespace vk return m_drawIndexedIndirectCommand.instanceCount; } + uint32_t& instanceCount() + { + return m_drawIndexedIndirectCommand.instanceCount; + } + DrawIndexedIndirectCommand& instanceCount( uint32_t instanceCount ) { m_drawIndexedIndirectCommand.instanceCount = instanceCount; @@ -3716,6 +4281,11 @@ namespace vk return m_drawIndexedIndirectCommand.firstIndex; } + uint32_t& firstIndex() + { + return m_drawIndexedIndirectCommand.firstIndex; + } + DrawIndexedIndirectCommand& firstIndex( uint32_t firstIndex ) { m_drawIndexedIndirectCommand.firstIndex = firstIndex; @@ -3727,6 +4297,11 @@ namespace vk return m_drawIndexedIndirectCommand.vertexOffset; } + int32_t& vertexOffset() + { + return m_drawIndexedIndirectCommand.vertexOffset; + } + DrawIndexedIndirectCommand& vertexOffset( int32_t vertexOffset ) { m_drawIndexedIndirectCommand.vertexOffset = vertexOffset; @@ -3738,6 +4313,11 @@ namespace vk return m_drawIndexedIndirectCommand.firstInstance; } + uint32_t& firstInstance() + { + return m_drawIndexedIndirectCommand.firstInstance; + } + DrawIndexedIndirectCommand& firstInstance( uint32_t firstInstance ) { m_drawIndexedIndirectCommand.firstInstance = firstInstance; @@ -3784,6 +4364,11 @@ namespace vk return m_dispatchIndirectCommand.x; } + uint32_t& x() + { + return m_dispatchIndirectCommand.x; + } + DispatchIndirectCommand& x( uint32_t x ) { m_dispatchIndirectCommand.x = x; @@ -3795,6 +4380,11 @@ namespace vk return m_dispatchIndirectCommand.y; } + uint32_t& y() + { + return m_dispatchIndirectCommand.y; + } + DispatchIndirectCommand& y( uint32_t y ) { m_dispatchIndirectCommand.y = y; @@ -3806,6 +4396,11 @@ namespace vk return m_dispatchIndirectCommand.z; } + uint32_t& z() + { + return m_dispatchIndirectCommand.z; + } + DispatchIndirectCommand& z( uint32_t z ) { m_dispatchIndirectCommand.z = z; @@ -3851,6 +4446,11 @@ namespace vk return reinterpret_cast( m_displayPlanePropertiesKHR.currentDisplay ); } + DisplayKHR& currentDisplay() + { + return reinterpret_cast( m_displayPlanePropertiesKHR.currentDisplay ); + } + DisplayPlanePropertiesKHR& currentDisplay( DisplayKHR currentDisplay ) { m_displayPlanePropertiesKHR.currentDisplay = static_cast( currentDisplay ); @@ -3862,6 +4462,11 @@ namespace vk return m_displayPlanePropertiesKHR.currentStackIndex; } + uint32_t& currentStackIndex() + { + return m_displayPlanePropertiesKHR.currentStackIndex; + } + DisplayPlanePropertiesKHR& currentStackIndex( uint32_t currentStackIndex ) { m_displayPlanePropertiesKHR.currentStackIndex = currentStackIndex; @@ -3907,6 +4512,11 @@ namespace vk return reinterpret_cast( m_displayModeParametersKHR.visibleRegion ); } + Extent2D& visibleRegion() + { + return reinterpret_cast( m_displayModeParametersKHR.visibleRegion ); + } + DisplayModeParametersKHR& visibleRegion( Extent2D visibleRegion ) { m_displayModeParametersKHR.visibleRegion = static_cast( visibleRegion ); @@ -3918,6 +4528,11 @@ namespace vk return m_displayModeParametersKHR.refreshRate; } + uint32_t& refreshRate() + { + return m_displayModeParametersKHR.refreshRate; + } + DisplayModeParametersKHR& refreshRate( uint32_t refreshRate ) { m_displayModeParametersKHR.refreshRate = refreshRate; @@ -3963,6 +4578,11 @@ namespace vk return reinterpret_cast( m_displayModePropertiesKHR.displayMode ); } + DisplayModeKHR& displayMode() + { + return reinterpret_cast( m_displayModePropertiesKHR.displayMode ); + } + DisplayModePropertiesKHR& displayMode( DisplayModeKHR displayMode ) { m_displayModePropertiesKHR.displayMode = static_cast( displayMode ); @@ -3974,6 +4594,11 @@ namespace vk return reinterpret_cast( m_displayModePropertiesKHR.parameters ); } + DisplayModeParametersKHR& parameters() + { + return reinterpret_cast( m_displayModePropertiesKHR.parameters ); + } + DisplayModePropertiesKHR& parameters( DisplayModeParametersKHR parameters ) { m_displayModePropertiesKHR.parameters = static_cast( parameters ); @@ -4034,6 +4659,11 @@ namespace vk return reinterpret_cast( m_descriptorImageInfo.sampler ); } + Sampler& sampler() + { + return reinterpret_cast( m_descriptorImageInfo.sampler ); + } + DescriptorImageInfo& sampler( Sampler sampler ) { m_descriptorImageInfo.sampler = static_cast( sampler ); @@ -4045,6 +4675,11 @@ namespace vk return reinterpret_cast( m_descriptorImageInfo.imageView ); } + ImageView& imageView() + { + return reinterpret_cast( m_descriptorImageInfo.imageView ); + } + DescriptorImageInfo& imageView( ImageView imageView ) { m_descriptorImageInfo.imageView = static_cast( imageView ); @@ -4056,6 +4691,11 @@ namespace vk return reinterpret_cast( m_descriptorImageInfo.imageLayout ); } + ImageLayout& imageLayout() + { + return reinterpret_cast( m_descriptorImageInfo.imageLayout ); + } + DescriptorImageInfo& imageLayout( ImageLayout imageLayout ) { m_descriptorImageInfo.imageLayout = static_cast( imageLayout ); @@ -4101,6 +4741,11 @@ namespace vk return m_attachmentReference.attachment; } + uint32_t& attachment() + { + return m_attachmentReference.attachment; + } + AttachmentReference& attachment( uint32_t attachment ) { m_attachmentReference.attachment = attachment; @@ -4112,6 +4757,11 @@ namespace vk return reinterpret_cast( m_attachmentReference.layout ); } + ImageLayout& layout() + { + return reinterpret_cast( m_attachmentReference.layout ); + } + AttachmentReference& layout( ImageLayout layout ) { m_attachmentReference.layout = static_cast( layout ); @@ -4213,6 +4863,11 @@ namespace vk return reinterpret_cast( m_componentMapping.r ); } + ComponentSwizzle& r() + { + return reinterpret_cast( m_componentMapping.r ); + } + ComponentMapping& r( ComponentSwizzle r ) { m_componentMapping.r = static_cast( r ); @@ -4224,6 +4879,11 @@ namespace vk return reinterpret_cast( m_componentMapping.g ); } + ComponentSwizzle& g() + { + return reinterpret_cast( m_componentMapping.g ); + } + ComponentMapping& g( ComponentSwizzle g ) { m_componentMapping.g = static_cast( g ); @@ -4235,6 +4895,11 @@ namespace vk return reinterpret_cast( m_componentMapping.b ); } + ComponentSwizzle& b() + { + return reinterpret_cast( m_componentMapping.b ); + } + ComponentMapping& b( ComponentSwizzle b ) { m_componentMapping.b = static_cast( b ); @@ -4246,6 +4911,11 @@ namespace vk return reinterpret_cast( m_componentMapping.a ); } + ComponentSwizzle& a() + { + return reinterpret_cast( m_componentMapping.a ); + } + ComponentMapping& a( ComponentSwizzle a ) { m_componentMapping.a = static_cast( a ); @@ -4306,6 +4976,11 @@ namespace vk return reinterpret_cast( m_descriptorPoolSize.type ); } + DescriptorType& type() + { + return reinterpret_cast( m_descriptorPoolSize.type ); + } + DescriptorPoolSize& type( DescriptorType type ) { m_descriptorPoolSize.type = static_cast( type ); @@ -4317,6 +4992,11 @@ namespace vk return m_descriptorPoolSize.descriptorCount; } + uint32_t& descriptorCount() + { + return m_descriptorPoolSize.descriptorCount; + } + DescriptorPoolSize& descriptorCount( uint32_t descriptorCount ) { m_descriptorPoolSize.descriptorCount = descriptorCount; @@ -4393,6 +5073,11 @@ namespace vk return reinterpret_cast( m_subpassDescription.flags ); } + SubpassDescriptionFlags& flags() + { + return reinterpret_cast( m_subpassDescription.flags ); + } + SubpassDescription& flags( SubpassDescriptionFlags flags ) { m_subpassDescription.flags = static_cast( flags ); @@ -4404,6 +5089,11 @@ namespace vk return reinterpret_cast( m_subpassDescription.pipelineBindPoint ); } + PipelineBindPoint& pipelineBindPoint() + { + return reinterpret_cast( m_subpassDescription.pipelineBindPoint ); + } + SubpassDescription& pipelineBindPoint( PipelineBindPoint pipelineBindPoint ) { m_subpassDescription.pipelineBindPoint = static_cast( pipelineBindPoint ); @@ -4415,6 +5105,11 @@ namespace vk return m_subpassDescription.inputAttachmentCount; } + uint32_t& inputAttachmentCount() + { + return m_subpassDescription.inputAttachmentCount; + } + SubpassDescription& inputAttachmentCount( uint32_t inputAttachmentCount ) { m_subpassDescription.inputAttachmentCount = inputAttachmentCount; @@ -4426,6 +5121,11 @@ namespace vk return reinterpret_cast( m_subpassDescription.pInputAttachments ); } + const AttachmentReference* pInputAttachments() + { + return reinterpret_cast( m_subpassDescription.pInputAttachments ); + } + SubpassDescription& pInputAttachments( const AttachmentReference* pInputAttachments ) { m_subpassDescription.pInputAttachments = reinterpret_cast( pInputAttachments ); @@ -4437,6 +5137,11 @@ namespace vk return m_subpassDescription.colorAttachmentCount; } + uint32_t& colorAttachmentCount() + { + return m_subpassDescription.colorAttachmentCount; + } + SubpassDescription& colorAttachmentCount( uint32_t colorAttachmentCount ) { m_subpassDescription.colorAttachmentCount = colorAttachmentCount; @@ -4448,6 +5153,11 @@ namespace vk return reinterpret_cast( m_subpassDescription.pColorAttachments ); } + const AttachmentReference* pColorAttachments() + { + return reinterpret_cast( m_subpassDescription.pColorAttachments ); + } + SubpassDescription& pColorAttachments( const AttachmentReference* pColorAttachments ) { m_subpassDescription.pColorAttachments = reinterpret_cast( pColorAttachments ); @@ -4459,6 +5169,11 @@ namespace vk return reinterpret_cast( m_subpassDescription.pResolveAttachments ); } + const AttachmentReference* pResolveAttachments() + { + return reinterpret_cast( m_subpassDescription.pResolveAttachments ); + } + SubpassDescription& pResolveAttachments( const AttachmentReference* pResolveAttachments ) { m_subpassDescription.pResolveAttachments = reinterpret_cast( pResolveAttachments ); @@ -4470,6 +5185,11 @@ namespace vk return reinterpret_cast( m_subpassDescription.pDepthStencilAttachment ); } + const AttachmentReference* pDepthStencilAttachment() + { + return reinterpret_cast( m_subpassDescription.pDepthStencilAttachment ); + } + SubpassDescription& pDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment ) { m_subpassDescription.pDepthStencilAttachment = reinterpret_cast( pDepthStencilAttachment ); @@ -4481,6 +5201,11 @@ namespace vk return m_subpassDescription.preserveAttachmentCount; } + uint32_t& preserveAttachmentCount() + { + return m_subpassDescription.preserveAttachmentCount; + } + SubpassDescription& preserveAttachmentCount( uint32_t preserveAttachmentCount ) { m_subpassDescription.preserveAttachmentCount = preserveAttachmentCount; @@ -4492,6 +5217,11 @@ namespace vk return reinterpret_cast( m_subpassDescription.pPreserveAttachments ); } + const uint32_t* pPreserveAttachments() + { + return reinterpret_cast( m_subpassDescription.pPreserveAttachments ); + } + SubpassDescription& pPreserveAttachments( const uint32_t* pPreserveAttachments ) { m_subpassDescription.pPreserveAttachments = pPreserveAttachments; @@ -4679,6 +5409,11 @@ namespace vk return reinterpret_cast( m_stencilOpState.failOp ); } + StencilOp& failOp() + { + return reinterpret_cast( m_stencilOpState.failOp ); + } + StencilOpState& failOp( StencilOp failOp ) { m_stencilOpState.failOp = static_cast( failOp ); @@ -4690,6 +5425,11 @@ namespace vk return reinterpret_cast( m_stencilOpState.passOp ); } + StencilOp& passOp() + { + return reinterpret_cast( m_stencilOpState.passOp ); + } + StencilOpState& passOp( StencilOp passOp ) { m_stencilOpState.passOp = static_cast( passOp ); @@ -4701,6 +5441,11 @@ namespace vk return reinterpret_cast( m_stencilOpState.depthFailOp ); } + StencilOp& depthFailOp() + { + return reinterpret_cast( m_stencilOpState.depthFailOp ); + } + StencilOpState& depthFailOp( StencilOp depthFailOp ) { m_stencilOpState.depthFailOp = static_cast( depthFailOp ); @@ -4712,6 +5457,11 @@ namespace vk return reinterpret_cast( m_stencilOpState.compareOp ); } + CompareOp& compareOp() + { + return reinterpret_cast( m_stencilOpState.compareOp ); + } + StencilOpState& compareOp( CompareOp compareOp ) { m_stencilOpState.compareOp = static_cast( compareOp ); @@ -4723,6 +5473,11 @@ namespace vk return m_stencilOpState.compareMask; } + uint32_t& compareMask() + { + return m_stencilOpState.compareMask; + } + StencilOpState& compareMask( uint32_t compareMask ) { m_stencilOpState.compareMask = compareMask; @@ -4734,6 +5489,11 @@ namespace vk return m_stencilOpState.writeMask; } + uint32_t& writeMask() + { + return m_stencilOpState.writeMask; + } + StencilOpState& writeMask( uint32_t writeMask ) { m_stencilOpState.writeMask = writeMask; @@ -4745,6 +5505,11 @@ namespace vk return m_stencilOpState.reference; } + uint32_t& reference() + { + return m_stencilOpState.reference; + } + StencilOpState& reference( uint32_t reference ) { m_stencilOpState.reference = reference; @@ -4840,6 +5605,11 @@ namespace vk return m_vertexInputBindingDescription.binding; } + uint32_t& binding() + { + return m_vertexInputBindingDescription.binding; + } + VertexInputBindingDescription& binding( uint32_t binding ) { m_vertexInputBindingDescription.binding = binding; @@ -4851,6 +5621,11 @@ namespace vk return m_vertexInputBindingDescription.stride; } + uint32_t& stride() + { + return m_vertexInputBindingDescription.stride; + } + VertexInputBindingDescription& stride( uint32_t stride ) { m_vertexInputBindingDescription.stride = stride; @@ -4862,6 +5637,11 @@ namespace vk return reinterpret_cast( m_vertexInputBindingDescription.inputRate ); } + VertexInputRate& inputRate() + { + return reinterpret_cast( m_vertexInputBindingDescription.inputRate ); + } + VertexInputBindingDescription& inputRate( VertexInputRate inputRate ) { m_vertexInputBindingDescription.inputRate = static_cast( inputRate ); @@ -5098,6 +5878,11 @@ namespace vk return m_vertexInputAttributeDescription.location; } + uint32_t& location() + { + return m_vertexInputAttributeDescription.location; + } + VertexInputAttributeDescription& location( uint32_t location ) { m_vertexInputAttributeDescription.location = location; @@ -5109,6 +5894,11 @@ namespace vk return m_vertexInputAttributeDescription.binding; } + uint32_t& binding() + { + return m_vertexInputAttributeDescription.binding; + } + VertexInputAttributeDescription& binding( uint32_t binding ) { m_vertexInputAttributeDescription.binding = binding; @@ -5120,6 +5910,11 @@ namespace vk return reinterpret_cast( m_vertexInputAttributeDescription.format ); } + Format& format() + { + return reinterpret_cast( m_vertexInputAttributeDescription.format ); + } + VertexInputAttributeDescription& format( Format format ) { m_vertexInputAttributeDescription.format = static_cast( format ); @@ -5131,6 +5926,11 @@ namespace vk return m_vertexInputAttributeDescription.offset; } + uint32_t& offset() + { + return m_vertexInputAttributeDescription.offset; + } + VertexInputAttributeDescription& offset( uint32_t offset ) { m_vertexInputAttributeDescription.offset = offset; @@ -5246,6 +6046,11 @@ namespace vk return reinterpret_cast( m_applicationInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_applicationInfo.sType ); + } + ApplicationInfo& sType( StructureType sType ) { m_applicationInfo.sType = static_cast( sType ); @@ -5257,6 +6062,11 @@ namespace vk return reinterpret_cast( m_applicationInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_applicationInfo.pNext ); + } + ApplicationInfo& pNext( const void* pNext ) { m_applicationInfo.pNext = pNext; @@ -5268,6 +6078,11 @@ namespace vk return reinterpret_cast( m_applicationInfo.pApplicationName ); } + const char* pApplicationName() + { + return reinterpret_cast( m_applicationInfo.pApplicationName ); + } + ApplicationInfo& pApplicationName( const char* pApplicationName ) { m_applicationInfo.pApplicationName = pApplicationName; @@ -5279,6 +6094,11 @@ namespace vk return m_applicationInfo.applicationVersion; } + uint32_t& applicationVersion() + { + return m_applicationInfo.applicationVersion; + } + ApplicationInfo& applicationVersion( uint32_t applicationVersion ) { m_applicationInfo.applicationVersion = applicationVersion; @@ -5290,6 +6110,11 @@ namespace vk return reinterpret_cast( m_applicationInfo.pEngineName ); } + const char* pEngineName() + { + return reinterpret_cast( m_applicationInfo.pEngineName ); + } + ApplicationInfo& pEngineName( const char* pEngineName ) { m_applicationInfo.pEngineName = pEngineName; @@ -5301,6 +6126,11 @@ namespace vk return m_applicationInfo.engineVersion; } + uint32_t& engineVersion() + { + return m_applicationInfo.engineVersion; + } + ApplicationInfo& engineVersion( uint32_t engineVersion ) { m_applicationInfo.engineVersion = engineVersion; @@ -5312,6 +6142,11 @@ namespace vk return m_applicationInfo.apiVersion; } + uint32_t& apiVersion() + { + return m_applicationInfo.apiVersion; + } + ApplicationInfo& apiVersion( uint32_t apiVersion ) { m_applicationInfo.apiVersion = apiVersion; @@ -5361,6 +6196,11 @@ namespace vk return reinterpret_cast( m_deviceQueueCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_deviceQueueCreateInfo.sType ); + } + DeviceQueueCreateInfo& sType( StructureType sType ) { m_deviceQueueCreateInfo.sType = static_cast( sType ); @@ -5372,6 +6212,11 @@ namespace vk return reinterpret_cast( m_deviceQueueCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_deviceQueueCreateInfo.pNext ); + } + DeviceQueueCreateInfo& pNext( const void* pNext ) { m_deviceQueueCreateInfo.pNext = pNext; @@ -5383,6 +6228,11 @@ namespace vk return reinterpret_cast( m_deviceQueueCreateInfo.flags ); } + DeviceQueueCreateFlags& flags() + { + return reinterpret_cast( m_deviceQueueCreateInfo.flags ); + } + DeviceQueueCreateInfo& flags( DeviceQueueCreateFlags flags ) { m_deviceQueueCreateInfo.flags = static_cast( flags ); @@ -5394,6 +6244,11 @@ namespace vk return m_deviceQueueCreateInfo.queueFamilyIndex; } + uint32_t& queueFamilyIndex() + { + return m_deviceQueueCreateInfo.queueFamilyIndex; + } + DeviceQueueCreateInfo& queueFamilyIndex( uint32_t queueFamilyIndex ) { m_deviceQueueCreateInfo.queueFamilyIndex = queueFamilyIndex; @@ -5405,6 +6260,11 @@ namespace vk return m_deviceQueueCreateInfo.queueCount; } + uint32_t& queueCount() + { + return m_deviceQueueCreateInfo.queueCount; + } + DeviceQueueCreateInfo& queueCount( uint32_t queueCount ) { m_deviceQueueCreateInfo.queueCount = queueCount; @@ -5416,6 +6276,11 @@ namespace vk return reinterpret_cast( m_deviceQueueCreateInfo.pQueuePriorities ); } + const float* pQueuePriorities() + { + return reinterpret_cast( m_deviceQueueCreateInfo.pQueuePriorities ); + } + DeviceQueueCreateInfo& pQueuePriorities( const float* pQueuePriorities ) { m_deviceQueueCreateInfo.pQueuePriorities = pQueuePriorities; @@ -5469,6 +6334,11 @@ namespace vk return reinterpret_cast( m_deviceCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_deviceCreateInfo.sType ); + } + DeviceCreateInfo& sType( StructureType sType ) { m_deviceCreateInfo.sType = static_cast( sType ); @@ -5480,6 +6350,11 @@ namespace vk return reinterpret_cast( m_deviceCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_deviceCreateInfo.pNext ); + } + DeviceCreateInfo& pNext( const void* pNext ) { m_deviceCreateInfo.pNext = pNext; @@ -5491,6 +6366,11 @@ namespace vk return reinterpret_cast( m_deviceCreateInfo.flags ); } + DeviceCreateFlags& flags() + { + return reinterpret_cast( m_deviceCreateInfo.flags ); + } + DeviceCreateInfo& flags( DeviceCreateFlags flags ) { m_deviceCreateInfo.flags = static_cast( flags ); @@ -5502,6 +6382,11 @@ namespace vk return m_deviceCreateInfo.queueCreateInfoCount; } + uint32_t& queueCreateInfoCount() + { + return m_deviceCreateInfo.queueCreateInfoCount; + } + DeviceCreateInfo& queueCreateInfoCount( uint32_t queueCreateInfoCount ) { m_deviceCreateInfo.queueCreateInfoCount = queueCreateInfoCount; @@ -5513,6 +6398,11 @@ namespace vk return reinterpret_cast( m_deviceCreateInfo.pQueueCreateInfos ); } + const DeviceQueueCreateInfo* pQueueCreateInfos() + { + return reinterpret_cast( m_deviceCreateInfo.pQueueCreateInfos ); + } + DeviceCreateInfo& pQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos ) { m_deviceCreateInfo.pQueueCreateInfos = reinterpret_cast( pQueueCreateInfos ); @@ -5524,6 +6414,11 @@ namespace vk return m_deviceCreateInfo.enabledLayerCount; } + uint32_t& enabledLayerCount() + { + return m_deviceCreateInfo.enabledLayerCount; + } + DeviceCreateInfo& enabledLayerCount( uint32_t enabledLayerCount ) { m_deviceCreateInfo.enabledLayerCount = enabledLayerCount; @@ -5535,6 +6430,11 @@ namespace vk return reinterpret_cast( m_deviceCreateInfo.ppEnabledLayerNames ); } + const char* const* ppEnabledLayerNames() + { + return reinterpret_cast( m_deviceCreateInfo.ppEnabledLayerNames ); + } + DeviceCreateInfo& ppEnabledLayerNames( const char* const* ppEnabledLayerNames ) { m_deviceCreateInfo.ppEnabledLayerNames = ppEnabledLayerNames; @@ -5546,6 +6446,11 @@ namespace vk return m_deviceCreateInfo.enabledExtensionCount; } + uint32_t& enabledExtensionCount() + { + return m_deviceCreateInfo.enabledExtensionCount; + } + DeviceCreateInfo& enabledExtensionCount( uint32_t enabledExtensionCount ) { m_deviceCreateInfo.enabledExtensionCount = enabledExtensionCount; @@ -5557,6 +6462,11 @@ namespace vk return reinterpret_cast( m_deviceCreateInfo.ppEnabledExtensionNames ); } + const char* const* ppEnabledExtensionNames() + { + return reinterpret_cast( m_deviceCreateInfo.ppEnabledExtensionNames ); + } + DeviceCreateInfo& ppEnabledExtensionNames( const char* const* ppEnabledExtensionNames ) { m_deviceCreateInfo.ppEnabledExtensionNames = ppEnabledExtensionNames; @@ -5568,6 +6478,11 @@ namespace vk return reinterpret_cast( m_deviceCreateInfo.pEnabledFeatures ); } + const PhysicalDeviceFeatures* pEnabledFeatures() + { + return reinterpret_cast( m_deviceCreateInfo.pEnabledFeatures ); + } + DeviceCreateInfo& pEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures ) { m_deviceCreateInfo.pEnabledFeatures = reinterpret_cast( pEnabledFeatures ); @@ -5619,6 +6534,11 @@ namespace vk return reinterpret_cast( m_instanceCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_instanceCreateInfo.sType ); + } + InstanceCreateInfo& sType( StructureType sType ) { m_instanceCreateInfo.sType = static_cast( sType ); @@ -5630,6 +6550,11 @@ namespace vk return reinterpret_cast( m_instanceCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_instanceCreateInfo.pNext ); + } + InstanceCreateInfo& pNext( const void* pNext ) { m_instanceCreateInfo.pNext = pNext; @@ -5641,6 +6566,11 @@ namespace vk return reinterpret_cast( m_instanceCreateInfo.flags ); } + InstanceCreateFlags& flags() + { + return reinterpret_cast( m_instanceCreateInfo.flags ); + } + InstanceCreateInfo& flags( InstanceCreateFlags flags ) { m_instanceCreateInfo.flags = static_cast( flags ); @@ -5652,6 +6582,11 @@ namespace vk return reinterpret_cast( m_instanceCreateInfo.pApplicationInfo ); } + const ApplicationInfo* pApplicationInfo() + { + return reinterpret_cast( m_instanceCreateInfo.pApplicationInfo ); + } + InstanceCreateInfo& pApplicationInfo( const ApplicationInfo* pApplicationInfo ) { m_instanceCreateInfo.pApplicationInfo = reinterpret_cast( pApplicationInfo ); @@ -5663,6 +6598,11 @@ namespace vk return m_instanceCreateInfo.enabledLayerCount; } + uint32_t& enabledLayerCount() + { + return m_instanceCreateInfo.enabledLayerCount; + } + InstanceCreateInfo& enabledLayerCount( uint32_t enabledLayerCount ) { m_instanceCreateInfo.enabledLayerCount = enabledLayerCount; @@ -5674,6 +6614,11 @@ namespace vk return reinterpret_cast( m_instanceCreateInfo.ppEnabledLayerNames ); } + const char* const* ppEnabledLayerNames() + { + return reinterpret_cast( m_instanceCreateInfo.ppEnabledLayerNames ); + } + InstanceCreateInfo& ppEnabledLayerNames( const char* const* ppEnabledLayerNames ) { m_instanceCreateInfo.ppEnabledLayerNames = ppEnabledLayerNames; @@ -5685,6 +6630,11 @@ namespace vk return m_instanceCreateInfo.enabledExtensionCount; } + uint32_t& enabledExtensionCount() + { + return m_instanceCreateInfo.enabledExtensionCount; + } + InstanceCreateInfo& enabledExtensionCount( uint32_t enabledExtensionCount ) { m_instanceCreateInfo.enabledExtensionCount = enabledExtensionCount; @@ -5696,6 +6646,11 @@ namespace vk return reinterpret_cast( m_instanceCreateInfo.ppEnabledExtensionNames ); } + const char* const* ppEnabledExtensionNames() + { + return reinterpret_cast( m_instanceCreateInfo.ppEnabledExtensionNames ); + } + InstanceCreateInfo& ppEnabledExtensionNames( const char* const* ppEnabledExtensionNames ) { m_instanceCreateInfo.ppEnabledExtensionNames = ppEnabledExtensionNames; @@ -5743,6 +6698,11 @@ namespace vk return reinterpret_cast( m_memoryAllocateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_memoryAllocateInfo.sType ); + } + MemoryAllocateInfo& sType( StructureType sType ) { m_memoryAllocateInfo.sType = static_cast( sType ); @@ -5754,6 +6714,11 @@ namespace vk return reinterpret_cast( m_memoryAllocateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_memoryAllocateInfo.pNext ); + } + MemoryAllocateInfo& pNext( const void* pNext ) { m_memoryAllocateInfo.pNext = pNext; @@ -5765,6 +6730,11 @@ namespace vk return m_memoryAllocateInfo.allocationSize; } + DeviceSize& allocationSize() + { + return m_memoryAllocateInfo.allocationSize; + } + MemoryAllocateInfo& allocationSize( DeviceSize allocationSize ) { m_memoryAllocateInfo.allocationSize = allocationSize; @@ -5776,6 +6746,11 @@ namespace vk return m_memoryAllocateInfo.memoryTypeIndex; } + uint32_t& memoryTypeIndex() + { + return m_memoryAllocateInfo.memoryTypeIndex; + } + MemoryAllocateInfo& memoryTypeIndex( uint32_t memoryTypeIndex ) { m_memoryAllocateInfo.memoryTypeIndex = memoryTypeIndex; @@ -5824,6 +6799,11 @@ namespace vk return reinterpret_cast( m_mappedMemoryRange.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_mappedMemoryRange.sType ); + } + MappedMemoryRange& sType( StructureType sType ) { m_mappedMemoryRange.sType = static_cast( sType ); @@ -5835,6 +6815,11 @@ namespace vk return reinterpret_cast( m_mappedMemoryRange.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_mappedMemoryRange.pNext ); + } + MappedMemoryRange& pNext( const void* pNext ) { m_mappedMemoryRange.pNext = pNext; @@ -5846,6 +6831,11 @@ namespace vk return reinterpret_cast( m_mappedMemoryRange.memory ); } + DeviceMemory& memory() + { + return reinterpret_cast( m_mappedMemoryRange.memory ); + } + MappedMemoryRange& memory( DeviceMemory memory ) { m_mappedMemoryRange.memory = static_cast( memory ); @@ -5857,6 +6847,11 @@ namespace vk return m_mappedMemoryRange.offset; } + DeviceSize& offset() + { + return m_mappedMemoryRange.offset; + } + MappedMemoryRange& offset( DeviceSize offset ) { m_mappedMemoryRange.offset = offset; @@ -5868,6 +6863,11 @@ namespace vk return m_mappedMemoryRange.size; } + DeviceSize& size() + { + return m_mappedMemoryRange.size; + } + MappedMemoryRange& size( DeviceSize size ) { m_mappedMemoryRange.size = size; @@ -5921,6 +6921,11 @@ namespace vk return reinterpret_cast( m_writeDescriptorSet.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_writeDescriptorSet.sType ); + } + WriteDescriptorSet& sType( StructureType sType ) { m_writeDescriptorSet.sType = static_cast( sType ); @@ -5932,6 +6937,11 @@ namespace vk return reinterpret_cast( m_writeDescriptorSet.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_writeDescriptorSet.pNext ); + } + WriteDescriptorSet& pNext( const void* pNext ) { m_writeDescriptorSet.pNext = pNext; @@ -5943,6 +6953,11 @@ namespace vk return reinterpret_cast( m_writeDescriptorSet.dstSet ); } + DescriptorSet& dstSet() + { + return reinterpret_cast( m_writeDescriptorSet.dstSet ); + } + WriteDescriptorSet& dstSet( DescriptorSet dstSet ) { m_writeDescriptorSet.dstSet = static_cast( dstSet ); @@ -5954,6 +6969,11 @@ namespace vk return m_writeDescriptorSet.dstBinding; } + uint32_t& dstBinding() + { + return m_writeDescriptorSet.dstBinding; + } + WriteDescriptorSet& dstBinding( uint32_t dstBinding ) { m_writeDescriptorSet.dstBinding = dstBinding; @@ -5965,6 +6985,11 @@ namespace vk return m_writeDescriptorSet.dstArrayElement; } + uint32_t& dstArrayElement() + { + return m_writeDescriptorSet.dstArrayElement; + } + WriteDescriptorSet& dstArrayElement( uint32_t dstArrayElement ) { m_writeDescriptorSet.dstArrayElement = dstArrayElement; @@ -5976,6 +7001,11 @@ namespace vk return m_writeDescriptorSet.descriptorCount; } + uint32_t& descriptorCount() + { + return m_writeDescriptorSet.descriptorCount; + } + WriteDescriptorSet& descriptorCount( uint32_t descriptorCount ) { m_writeDescriptorSet.descriptorCount = descriptorCount; @@ -5987,6 +7017,11 @@ namespace vk return reinterpret_cast( m_writeDescriptorSet.descriptorType ); } + DescriptorType& descriptorType() + { + return reinterpret_cast( m_writeDescriptorSet.descriptorType ); + } + WriteDescriptorSet& descriptorType( DescriptorType descriptorType ) { m_writeDescriptorSet.descriptorType = static_cast( descriptorType ); @@ -5998,6 +7033,11 @@ namespace vk return reinterpret_cast( m_writeDescriptorSet.pImageInfo ); } + const DescriptorImageInfo* pImageInfo() + { + return reinterpret_cast( m_writeDescriptorSet.pImageInfo ); + } + WriteDescriptorSet& pImageInfo( const DescriptorImageInfo* pImageInfo ) { m_writeDescriptorSet.pImageInfo = reinterpret_cast( pImageInfo ); @@ -6009,6 +7049,11 @@ namespace vk return reinterpret_cast( m_writeDescriptorSet.pBufferInfo ); } + const DescriptorBufferInfo* pBufferInfo() + { + return reinterpret_cast( m_writeDescriptorSet.pBufferInfo ); + } + WriteDescriptorSet& pBufferInfo( const DescriptorBufferInfo* pBufferInfo ) { m_writeDescriptorSet.pBufferInfo = reinterpret_cast( pBufferInfo ); @@ -6020,6 +7065,11 @@ namespace vk return reinterpret_cast( m_writeDescriptorSet.pTexelBufferView ); } + const BufferView* pTexelBufferView() + { + return reinterpret_cast( m_writeDescriptorSet.pTexelBufferView ); + } + WriteDescriptorSet& pTexelBufferView( const BufferView* pTexelBufferView ) { m_writeDescriptorSet.pTexelBufferView = reinterpret_cast( pTexelBufferView ); @@ -6072,6 +7122,11 @@ namespace vk return reinterpret_cast( m_copyDescriptorSet.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_copyDescriptorSet.sType ); + } + CopyDescriptorSet& sType( StructureType sType ) { m_copyDescriptorSet.sType = static_cast( sType ); @@ -6083,6 +7138,11 @@ namespace vk return reinterpret_cast( m_copyDescriptorSet.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_copyDescriptorSet.pNext ); + } + CopyDescriptorSet& pNext( const void* pNext ) { m_copyDescriptorSet.pNext = pNext; @@ -6094,6 +7154,11 @@ namespace vk return reinterpret_cast( m_copyDescriptorSet.srcSet ); } + DescriptorSet& srcSet() + { + return reinterpret_cast( m_copyDescriptorSet.srcSet ); + } + CopyDescriptorSet& srcSet( DescriptorSet srcSet ) { m_copyDescriptorSet.srcSet = static_cast( srcSet ); @@ -6105,6 +7170,11 @@ namespace vk return m_copyDescriptorSet.srcBinding; } + uint32_t& srcBinding() + { + return m_copyDescriptorSet.srcBinding; + } + CopyDescriptorSet& srcBinding( uint32_t srcBinding ) { m_copyDescriptorSet.srcBinding = srcBinding; @@ -6116,6 +7186,11 @@ namespace vk return m_copyDescriptorSet.srcArrayElement; } + uint32_t& srcArrayElement() + { + return m_copyDescriptorSet.srcArrayElement; + } + CopyDescriptorSet& srcArrayElement( uint32_t srcArrayElement ) { m_copyDescriptorSet.srcArrayElement = srcArrayElement; @@ -6127,6 +7202,11 @@ namespace vk return reinterpret_cast( m_copyDescriptorSet.dstSet ); } + DescriptorSet& dstSet() + { + return reinterpret_cast( m_copyDescriptorSet.dstSet ); + } + CopyDescriptorSet& dstSet( DescriptorSet dstSet ) { m_copyDescriptorSet.dstSet = static_cast( dstSet ); @@ -6138,6 +7218,11 @@ namespace vk return m_copyDescriptorSet.dstBinding; } + uint32_t& dstBinding() + { + return m_copyDescriptorSet.dstBinding; + } + CopyDescriptorSet& dstBinding( uint32_t dstBinding ) { m_copyDescriptorSet.dstBinding = dstBinding; @@ -6149,6 +7234,11 @@ namespace vk return m_copyDescriptorSet.dstArrayElement; } + uint32_t& dstArrayElement() + { + return m_copyDescriptorSet.dstArrayElement; + } + CopyDescriptorSet& dstArrayElement( uint32_t dstArrayElement ) { m_copyDescriptorSet.dstArrayElement = dstArrayElement; @@ -6160,6 +7250,11 @@ namespace vk return m_copyDescriptorSet.descriptorCount; } + uint32_t& descriptorCount() + { + return m_copyDescriptorSet.descriptorCount; + } + CopyDescriptorSet& descriptorCount( uint32_t descriptorCount ) { m_copyDescriptorSet.descriptorCount = descriptorCount; @@ -6210,6 +7305,11 @@ namespace vk return reinterpret_cast( m_bufferViewCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_bufferViewCreateInfo.sType ); + } + BufferViewCreateInfo& sType( StructureType sType ) { m_bufferViewCreateInfo.sType = static_cast( sType ); @@ -6221,6 +7321,11 @@ namespace vk return reinterpret_cast( m_bufferViewCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_bufferViewCreateInfo.pNext ); + } + BufferViewCreateInfo& pNext( const void* pNext ) { m_bufferViewCreateInfo.pNext = pNext; @@ -6232,6 +7337,11 @@ namespace vk return reinterpret_cast( m_bufferViewCreateInfo.flags ); } + BufferViewCreateFlags& flags() + { + return reinterpret_cast( m_bufferViewCreateInfo.flags ); + } + BufferViewCreateInfo& flags( BufferViewCreateFlags flags ) { m_bufferViewCreateInfo.flags = static_cast( flags ); @@ -6243,6 +7353,11 @@ namespace vk return reinterpret_cast( m_bufferViewCreateInfo.buffer ); } + Buffer& buffer() + { + return reinterpret_cast( m_bufferViewCreateInfo.buffer ); + } + BufferViewCreateInfo& buffer( Buffer buffer ) { m_bufferViewCreateInfo.buffer = static_cast( buffer ); @@ -6254,6 +7369,11 @@ namespace vk return reinterpret_cast( m_bufferViewCreateInfo.format ); } + Format& format() + { + return reinterpret_cast( m_bufferViewCreateInfo.format ); + } + BufferViewCreateInfo& format( Format format ) { m_bufferViewCreateInfo.format = static_cast( format ); @@ -6265,6 +7385,11 @@ namespace vk return m_bufferViewCreateInfo.offset; } + DeviceSize& offset() + { + return m_bufferViewCreateInfo.offset; + } + BufferViewCreateInfo& offset( DeviceSize offset ) { m_bufferViewCreateInfo.offset = offset; @@ -6276,6 +7401,11 @@ namespace vk return m_bufferViewCreateInfo.range; } + DeviceSize& range() + { + return m_bufferViewCreateInfo.range; + } + BufferViewCreateInfo& range( DeviceSize range ) { m_bufferViewCreateInfo.range = range; @@ -6324,6 +7454,11 @@ namespace vk return reinterpret_cast( m_shaderModuleCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_shaderModuleCreateInfo.sType ); + } + ShaderModuleCreateInfo& sType( StructureType sType ) { m_shaderModuleCreateInfo.sType = static_cast( sType ); @@ -6335,6 +7470,11 @@ namespace vk return reinterpret_cast( m_shaderModuleCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_shaderModuleCreateInfo.pNext ); + } + ShaderModuleCreateInfo& pNext( const void* pNext ) { m_shaderModuleCreateInfo.pNext = pNext; @@ -6346,6 +7486,11 @@ namespace vk return reinterpret_cast( m_shaderModuleCreateInfo.flags ); } + ShaderModuleCreateFlags& flags() + { + return reinterpret_cast( m_shaderModuleCreateInfo.flags ); + } + ShaderModuleCreateInfo& flags( ShaderModuleCreateFlags flags ) { m_shaderModuleCreateInfo.flags = static_cast( flags ); @@ -6357,6 +7502,11 @@ namespace vk return m_shaderModuleCreateInfo.codeSize; } + size_t& codeSize() + { + return m_shaderModuleCreateInfo.codeSize; + } + ShaderModuleCreateInfo& codeSize( size_t codeSize ) { m_shaderModuleCreateInfo.codeSize = codeSize; @@ -6368,6 +7518,11 @@ namespace vk return reinterpret_cast( m_shaderModuleCreateInfo.pCode ); } + const uint32_t* pCode() + { + return reinterpret_cast( m_shaderModuleCreateInfo.pCode ); + } + ShaderModuleCreateInfo& pCode( const uint32_t* pCode ) { m_shaderModuleCreateInfo.pCode = pCode; @@ -6416,6 +7571,11 @@ namespace vk return reinterpret_cast( m_descriptorSetAllocateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_descriptorSetAllocateInfo.sType ); + } + DescriptorSetAllocateInfo& sType( StructureType sType ) { m_descriptorSetAllocateInfo.sType = static_cast( sType ); @@ -6427,6 +7587,11 @@ namespace vk return reinterpret_cast( m_descriptorSetAllocateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_descriptorSetAllocateInfo.pNext ); + } + DescriptorSetAllocateInfo& pNext( const void* pNext ) { m_descriptorSetAllocateInfo.pNext = pNext; @@ -6438,6 +7603,11 @@ namespace vk return reinterpret_cast( m_descriptorSetAllocateInfo.descriptorPool ); } + DescriptorPool& descriptorPool() + { + return reinterpret_cast( m_descriptorSetAllocateInfo.descriptorPool ); + } + DescriptorSetAllocateInfo& descriptorPool( DescriptorPool descriptorPool ) { m_descriptorSetAllocateInfo.descriptorPool = static_cast( descriptorPool ); @@ -6449,6 +7619,11 @@ namespace vk return m_descriptorSetAllocateInfo.descriptorSetCount; } + uint32_t& descriptorSetCount() + { + return m_descriptorSetAllocateInfo.descriptorSetCount; + } + DescriptorSetAllocateInfo& descriptorSetCount( uint32_t descriptorSetCount ) { m_descriptorSetAllocateInfo.descriptorSetCount = descriptorSetCount; @@ -6460,6 +7635,11 @@ namespace vk return reinterpret_cast( m_descriptorSetAllocateInfo.pSetLayouts ); } + const DescriptorSetLayout* pSetLayouts() + { + return reinterpret_cast( m_descriptorSetAllocateInfo.pSetLayouts ); + } + DescriptorSetAllocateInfo& pSetLayouts( const DescriptorSetLayout* pSetLayouts ) { m_descriptorSetAllocateInfo.pSetLayouts = reinterpret_cast( pSetLayouts ); @@ -6510,6 +7690,11 @@ namespace vk return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.sType ); + } + PipelineVertexInputStateCreateInfo& sType( StructureType sType ) { m_pipelineVertexInputStateCreateInfo.sType = static_cast( sType ); @@ -6521,6 +7706,11 @@ namespace vk return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.pNext ); + } + PipelineVertexInputStateCreateInfo& pNext( const void* pNext ) { m_pipelineVertexInputStateCreateInfo.pNext = pNext; @@ -6532,6 +7722,11 @@ namespace vk return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.flags ); } + PipelineVertexInputStateCreateFlags& flags() + { + return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.flags ); + } + PipelineVertexInputStateCreateInfo& flags( PipelineVertexInputStateCreateFlags flags ) { m_pipelineVertexInputStateCreateInfo.flags = static_cast( flags ); @@ -6543,6 +7738,11 @@ namespace vk return m_pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount; } + uint32_t& vertexBindingDescriptionCount() + { + return m_pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount; + } + PipelineVertexInputStateCreateInfo& vertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount ) { m_pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount = vertexBindingDescriptionCount; @@ -6554,6 +7754,11 @@ namespace vk return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions ); } + const VertexInputBindingDescription* pVertexBindingDescriptions() + { + return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions ); + } + PipelineVertexInputStateCreateInfo& pVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions ) { m_pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions = reinterpret_cast( pVertexBindingDescriptions ); @@ -6565,6 +7770,11 @@ namespace vk return m_pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount; } + uint32_t& vertexAttributeDescriptionCount() + { + return m_pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount; + } + PipelineVertexInputStateCreateInfo& vertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount ) { m_pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount = vertexAttributeDescriptionCount; @@ -6576,6 +7786,11 @@ namespace vk return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions ); } + const VertexInputAttributeDescription* pVertexAttributeDescriptions() + { + return reinterpret_cast( m_pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions ); + } + PipelineVertexInputStateCreateInfo& pVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions ) { m_pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions = reinterpret_cast( pVertexAttributeDescriptions ); @@ -6624,6 +7839,11 @@ namespace vk return reinterpret_cast( m_pipelineInputAssemblyStateCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineInputAssemblyStateCreateInfo.sType ); + } + PipelineInputAssemblyStateCreateInfo& sType( StructureType sType ) { m_pipelineInputAssemblyStateCreateInfo.sType = static_cast( sType ); @@ -6635,6 +7855,11 @@ namespace vk return reinterpret_cast( m_pipelineInputAssemblyStateCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineInputAssemblyStateCreateInfo.pNext ); + } + PipelineInputAssemblyStateCreateInfo& pNext( const void* pNext ) { m_pipelineInputAssemblyStateCreateInfo.pNext = pNext; @@ -6646,6 +7871,11 @@ namespace vk return reinterpret_cast( m_pipelineInputAssemblyStateCreateInfo.flags ); } + PipelineInputAssemblyStateCreateFlags& flags() + { + return reinterpret_cast( m_pipelineInputAssemblyStateCreateInfo.flags ); + } + PipelineInputAssemblyStateCreateInfo& flags( PipelineInputAssemblyStateCreateFlags flags ) { m_pipelineInputAssemblyStateCreateInfo.flags = static_cast( flags ); @@ -6657,6 +7887,11 @@ namespace vk return reinterpret_cast( m_pipelineInputAssemblyStateCreateInfo.topology ); } + PrimitiveTopology& topology() + { + return reinterpret_cast( m_pipelineInputAssemblyStateCreateInfo.topology ); + } + PipelineInputAssemblyStateCreateInfo& topology( PrimitiveTopology topology ) { m_pipelineInputAssemblyStateCreateInfo.topology = static_cast( topology ); @@ -6668,6 +7903,11 @@ namespace vk return m_pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable; } + Bool32& primitiveRestartEnable() + { + return m_pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable; + } + PipelineInputAssemblyStateCreateInfo& primitiveRestartEnable( Bool32 primitiveRestartEnable ) { m_pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable = primitiveRestartEnable; @@ -6715,6 +7955,11 @@ namespace vk return reinterpret_cast( m_pipelineTessellationStateCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineTessellationStateCreateInfo.sType ); + } + PipelineTessellationStateCreateInfo& sType( StructureType sType ) { m_pipelineTessellationStateCreateInfo.sType = static_cast( sType ); @@ -6726,6 +7971,11 @@ namespace vk return reinterpret_cast( m_pipelineTessellationStateCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineTessellationStateCreateInfo.pNext ); + } + PipelineTessellationStateCreateInfo& pNext( const void* pNext ) { m_pipelineTessellationStateCreateInfo.pNext = pNext; @@ -6737,6 +7987,11 @@ namespace vk return reinterpret_cast( m_pipelineTessellationStateCreateInfo.flags ); } + PipelineTessellationStateCreateFlags& flags() + { + return reinterpret_cast( m_pipelineTessellationStateCreateInfo.flags ); + } + PipelineTessellationStateCreateInfo& flags( PipelineTessellationStateCreateFlags flags ) { m_pipelineTessellationStateCreateInfo.flags = static_cast( flags ); @@ -6748,6 +8003,11 @@ namespace vk return m_pipelineTessellationStateCreateInfo.patchControlPoints; } + uint32_t& patchControlPoints() + { + return m_pipelineTessellationStateCreateInfo.patchControlPoints; + } + PipelineTessellationStateCreateInfo& patchControlPoints( uint32_t patchControlPoints ) { m_pipelineTessellationStateCreateInfo.patchControlPoints = patchControlPoints; @@ -6798,6 +8058,11 @@ namespace vk return reinterpret_cast( m_pipelineViewportStateCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineViewportStateCreateInfo.sType ); + } + PipelineViewportStateCreateInfo& sType( StructureType sType ) { m_pipelineViewportStateCreateInfo.sType = static_cast( sType ); @@ -6809,6 +8074,11 @@ namespace vk return reinterpret_cast( m_pipelineViewportStateCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineViewportStateCreateInfo.pNext ); + } + PipelineViewportStateCreateInfo& pNext( const void* pNext ) { m_pipelineViewportStateCreateInfo.pNext = pNext; @@ -6820,6 +8090,11 @@ namespace vk return reinterpret_cast( m_pipelineViewportStateCreateInfo.flags ); } + PipelineViewportStateCreateFlags& flags() + { + return reinterpret_cast( m_pipelineViewportStateCreateInfo.flags ); + } + PipelineViewportStateCreateInfo& flags( PipelineViewportStateCreateFlags flags ) { m_pipelineViewportStateCreateInfo.flags = static_cast( flags ); @@ -6831,6 +8106,11 @@ namespace vk return m_pipelineViewportStateCreateInfo.viewportCount; } + uint32_t& viewportCount() + { + return m_pipelineViewportStateCreateInfo.viewportCount; + } + PipelineViewportStateCreateInfo& viewportCount( uint32_t viewportCount ) { m_pipelineViewportStateCreateInfo.viewportCount = viewportCount; @@ -6842,6 +8122,11 @@ namespace vk return reinterpret_cast( m_pipelineViewportStateCreateInfo.pViewports ); } + const Viewport* pViewports() + { + return reinterpret_cast( m_pipelineViewportStateCreateInfo.pViewports ); + } + PipelineViewportStateCreateInfo& pViewports( const Viewport* pViewports ) { m_pipelineViewportStateCreateInfo.pViewports = reinterpret_cast( pViewports ); @@ -6853,6 +8138,11 @@ namespace vk return m_pipelineViewportStateCreateInfo.scissorCount; } + uint32_t& scissorCount() + { + return m_pipelineViewportStateCreateInfo.scissorCount; + } + PipelineViewportStateCreateInfo& scissorCount( uint32_t scissorCount ) { m_pipelineViewportStateCreateInfo.scissorCount = scissorCount; @@ -6864,6 +8154,11 @@ namespace vk return reinterpret_cast( m_pipelineViewportStateCreateInfo.pScissors ); } + const Rect2D* pScissors() + { + return reinterpret_cast( m_pipelineViewportStateCreateInfo.pScissors ); + } + PipelineViewportStateCreateInfo& pScissors( const Rect2D* pScissors ) { m_pipelineViewportStateCreateInfo.pScissors = reinterpret_cast( pScissors ); @@ -6920,6 +8215,11 @@ namespace vk return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.sType ); + } + PipelineRasterizationStateCreateInfo& sType( StructureType sType ) { m_pipelineRasterizationStateCreateInfo.sType = static_cast( sType ); @@ -6931,6 +8231,11 @@ namespace vk return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.pNext ); + } + PipelineRasterizationStateCreateInfo& pNext( const void* pNext ) { m_pipelineRasterizationStateCreateInfo.pNext = pNext; @@ -6942,6 +8247,11 @@ namespace vk return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.flags ); } + PipelineRasterizationStateCreateFlags& flags() + { + return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.flags ); + } + PipelineRasterizationStateCreateInfo& flags( PipelineRasterizationStateCreateFlags flags ) { m_pipelineRasterizationStateCreateInfo.flags = static_cast( flags ); @@ -6953,6 +8263,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthClampEnable; } + Bool32& depthClampEnable() + { + return m_pipelineRasterizationStateCreateInfo.depthClampEnable; + } + PipelineRasterizationStateCreateInfo& depthClampEnable( Bool32 depthClampEnable ) { m_pipelineRasterizationStateCreateInfo.depthClampEnable = depthClampEnable; @@ -6964,6 +8279,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable; } + Bool32& rasterizerDiscardEnable() + { + return m_pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable; + } + PipelineRasterizationStateCreateInfo& rasterizerDiscardEnable( Bool32 rasterizerDiscardEnable ) { m_pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable = rasterizerDiscardEnable; @@ -6975,6 +8295,11 @@ namespace vk return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.polygonMode ); } + PolygonMode& polygonMode() + { + return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.polygonMode ); + } + PipelineRasterizationStateCreateInfo& polygonMode( PolygonMode polygonMode ) { m_pipelineRasterizationStateCreateInfo.polygonMode = static_cast( polygonMode ); @@ -6986,6 +8311,11 @@ namespace vk return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.cullMode ); } + CullModeFlags& cullMode() + { + return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.cullMode ); + } + PipelineRasterizationStateCreateInfo& cullMode( CullModeFlags cullMode ) { m_pipelineRasterizationStateCreateInfo.cullMode = static_cast( cullMode ); @@ -6997,6 +8327,11 @@ namespace vk return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.frontFace ); } + FrontFace& frontFace() + { + return reinterpret_cast( m_pipelineRasterizationStateCreateInfo.frontFace ); + } + PipelineRasterizationStateCreateInfo& frontFace( FrontFace frontFace ) { m_pipelineRasterizationStateCreateInfo.frontFace = static_cast( frontFace ); @@ -7008,6 +8343,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthBiasEnable; } + Bool32& depthBiasEnable() + { + return m_pipelineRasterizationStateCreateInfo.depthBiasEnable; + } + PipelineRasterizationStateCreateInfo& depthBiasEnable( Bool32 depthBiasEnable ) { m_pipelineRasterizationStateCreateInfo.depthBiasEnable = depthBiasEnable; @@ -7019,6 +8359,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthBiasConstantFactor; } + float& depthBiasConstantFactor() + { + return m_pipelineRasterizationStateCreateInfo.depthBiasConstantFactor; + } + PipelineRasterizationStateCreateInfo& depthBiasConstantFactor( float depthBiasConstantFactor ) { m_pipelineRasterizationStateCreateInfo.depthBiasConstantFactor = depthBiasConstantFactor; @@ -7030,6 +8375,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthBiasClamp; } + float& depthBiasClamp() + { + return m_pipelineRasterizationStateCreateInfo.depthBiasClamp; + } + PipelineRasterizationStateCreateInfo& depthBiasClamp( float depthBiasClamp ) { m_pipelineRasterizationStateCreateInfo.depthBiasClamp = depthBiasClamp; @@ -7041,6 +8391,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor; } + float& depthBiasSlopeFactor() + { + return m_pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor; + } + PipelineRasterizationStateCreateInfo& depthBiasSlopeFactor( float depthBiasSlopeFactor ) { m_pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor = depthBiasSlopeFactor; @@ -7052,6 +8407,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.lineWidth; } + float& lineWidth() + { + return m_pipelineRasterizationStateCreateInfo.lineWidth; + } + PipelineRasterizationStateCreateInfo& lineWidth( float lineWidth ) { m_pipelineRasterizationStateCreateInfo.lineWidth = lineWidth; @@ -7107,6 +8467,11 @@ namespace vk return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.sType ); + } + PipelineDepthStencilStateCreateInfo& sType( StructureType sType ) { m_pipelineDepthStencilStateCreateInfo.sType = static_cast( sType ); @@ -7118,6 +8483,11 @@ namespace vk return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.pNext ); + } + PipelineDepthStencilStateCreateInfo& pNext( const void* pNext ) { m_pipelineDepthStencilStateCreateInfo.pNext = pNext; @@ -7129,6 +8499,11 @@ namespace vk return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.flags ); } + PipelineDepthStencilStateCreateFlags& flags() + { + return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.flags ); + } + PipelineDepthStencilStateCreateInfo& flags( PipelineDepthStencilStateCreateFlags flags ) { m_pipelineDepthStencilStateCreateInfo.flags = static_cast( flags ); @@ -7140,6 +8515,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.depthTestEnable; } + Bool32& depthTestEnable() + { + return m_pipelineDepthStencilStateCreateInfo.depthTestEnable; + } + PipelineDepthStencilStateCreateInfo& depthTestEnable( Bool32 depthTestEnable ) { m_pipelineDepthStencilStateCreateInfo.depthTestEnable = depthTestEnable; @@ -7151,6 +8531,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.depthWriteEnable; } + Bool32& depthWriteEnable() + { + return m_pipelineDepthStencilStateCreateInfo.depthWriteEnable; + } + PipelineDepthStencilStateCreateInfo& depthWriteEnable( Bool32 depthWriteEnable ) { m_pipelineDepthStencilStateCreateInfo.depthWriteEnable = depthWriteEnable; @@ -7162,6 +8547,11 @@ namespace vk return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.depthCompareOp ); } + CompareOp& depthCompareOp() + { + return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.depthCompareOp ); + } + PipelineDepthStencilStateCreateInfo& depthCompareOp( CompareOp depthCompareOp ) { m_pipelineDepthStencilStateCreateInfo.depthCompareOp = static_cast( depthCompareOp ); @@ -7173,6 +8563,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable; } + Bool32& depthBoundsTestEnable() + { + return m_pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable; + } + PipelineDepthStencilStateCreateInfo& depthBoundsTestEnable( Bool32 depthBoundsTestEnable ) { m_pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable = depthBoundsTestEnable; @@ -7184,6 +8579,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.stencilTestEnable; } + Bool32& stencilTestEnable() + { + return m_pipelineDepthStencilStateCreateInfo.stencilTestEnable; + } + PipelineDepthStencilStateCreateInfo& stencilTestEnable( Bool32 stencilTestEnable ) { m_pipelineDepthStencilStateCreateInfo.stencilTestEnable = stencilTestEnable; @@ -7195,6 +8595,11 @@ namespace vk return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.front ); } + StencilOpState& front() + { + return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.front ); + } + PipelineDepthStencilStateCreateInfo& front( StencilOpState front ) { m_pipelineDepthStencilStateCreateInfo.front = static_cast( front ); @@ -7206,6 +8611,11 @@ namespace vk return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.back ); } + StencilOpState& back() + { + return reinterpret_cast( m_pipelineDepthStencilStateCreateInfo.back ); + } + PipelineDepthStencilStateCreateInfo& back( StencilOpState back ) { m_pipelineDepthStencilStateCreateInfo.back = static_cast( back ); @@ -7217,6 +8627,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.minDepthBounds; } + float& minDepthBounds() + { + return m_pipelineDepthStencilStateCreateInfo.minDepthBounds; + } + PipelineDepthStencilStateCreateInfo& minDepthBounds( float minDepthBounds ) { m_pipelineDepthStencilStateCreateInfo.minDepthBounds = minDepthBounds; @@ -7228,6 +8643,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.maxDepthBounds; } + float& maxDepthBounds() + { + return m_pipelineDepthStencilStateCreateInfo.maxDepthBounds; + } + PipelineDepthStencilStateCreateInfo& maxDepthBounds( float maxDepthBounds ) { m_pipelineDepthStencilStateCreateInfo.maxDepthBounds = maxDepthBounds; @@ -7276,6 +8696,11 @@ namespace vk return reinterpret_cast( m_pipelineCacheCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineCacheCreateInfo.sType ); + } + PipelineCacheCreateInfo& sType( StructureType sType ) { m_pipelineCacheCreateInfo.sType = static_cast( sType ); @@ -7287,6 +8712,11 @@ namespace vk return reinterpret_cast( m_pipelineCacheCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineCacheCreateInfo.pNext ); + } + PipelineCacheCreateInfo& pNext( const void* pNext ) { m_pipelineCacheCreateInfo.pNext = pNext; @@ -7298,6 +8728,11 @@ namespace vk return reinterpret_cast( m_pipelineCacheCreateInfo.flags ); } + PipelineCacheCreateFlags& flags() + { + return reinterpret_cast( m_pipelineCacheCreateInfo.flags ); + } + PipelineCacheCreateInfo& flags( PipelineCacheCreateFlags flags ) { m_pipelineCacheCreateInfo.flags = static_cast( flags ); @@ -7309,6 +8744,11 @@ namespace vk return m_pipelineCacheCreateInfo.initialDataSize; } + size_t& initialDataSize() + { + return m_pipelineCacheCreateInfo.initialDataSize; + } + PipelineCacheCreateInfo& initialDataSize( size_t initialDataSize ) { m_pipelineCacheCreateInfo.initialDataSize = initialDataSize; @@ -7320,6 +8760,11 @@ namespace vk return reinterpret_cast( m_pipelineCacheCreateInfo.pInitialData ); } + const void* pInitialData() + { + return reinterpret_cast( m_pipelineCacheCreateInfo.pInitialData ); + } + PipelineCacheCreateInfo& pInitialData( const void* pInitialData ) { m_pipelineCacheCreateInfo.pInitialData = pInitialData; @@ -7381,6 +8826,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_samplerCreateInfo.sType ); + } + SamplerCreateInfo& sType( StructureType sType ) { m_samplerCreateInfo.sType = static_cast( sType ); @@ -7392,6 +8842,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_samplerCreateInfo.pNext ); + } + SamplerCreateInfo& pNext( const void* pNext ) { m_samplerCreateInfo.pNext = pNext; @@ -7403,6 +8858,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.flags ); } + SamplerCreateFlags& flags() + { + return reinterpret_cast( m_samplerCreateInfo.flags ); + } + SamplerCreateInfo& flags( SamplerCreateFlags flags ) { m_samplerCreateInfo.flags = static_cast( flags ); @@ -7414,6 +8874,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.magFilter ); } + Filter& magFilter() + { + return reinterpret_cast( m_samplerCreateInfo.magFilter ); + } + SamplerCreateInfo& magFilter( Filter magFilter ) { m_samplerCreateInfo.magFilter = static_cast( magFilter ); @@ -7425,6 +8890,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.minFilter ); } + Filter& minFilter() + { + return reinterpret_cast( m_samplerCreateInfo.minFilter ); + } + SamplerCreateInfo& minFilter( Filter minFilter ) { m_samplerCreateInfo.minFilter = static_cast( minFilter ); @@ -7436,6 +8906,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.mipmapMode ); } + SamplerMipmapMode& mipmapMode() + { + return reinterpret_cast( m_samplerCreateInfo.mipmapMode ); + } + SamplerCreateInfo& mipmapMode( SamplerMipmapMode mipmapMode ) { m_samplerCreateInfo.mipmapMode = static_cast( mipmapMode ); @@ -7447,6 +8922,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.addressModeU ); } + SamplerAddressMode& addressModeU() + { + return reinterpret_cast( m_samplerCreateInfo.addressModeU ); + } + SamplerCreateInfo& addressModeU( SamplerAddressMode addressModeU ) { m_samplerCreateInfo.addressModeU = static_cast( addressModeU ); @@ -7458,6 +8938,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.addressModeV ); } + SamplerAddressMode& addressModeV() + { + return reinterpret_cast( m_samplerCreateInfo.addressModeV ); + } + SamplerCreateInfo& addressModeV( SamplerAddressMode addressModeV ) { m_samplerCreateInfo.addressModeV = static_cast( addressModeV ); @@ -7469,6 +8954,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.addressModeW ); } + SamplerAddressMode& addressModeW() + { + return reinterpret_cast( m_samplerCreateInfo.addressModeW ); + } + SamplerCreateInfo& addressModeW( SamplerAddressMode addressModeW ) { m_samplerCreateInfo.addressModeW = static_cast( addressModeW ); @@ -7480,6 +8970,11 @@ namespace vk return m_samplerCreateInfo.mipLodBias; } + float& mipLodBias() + { + return m_samplerCreateInfo.mipLodBias; + } + SamplerCreateInfo& mipLodBias( float mipLodBias ) { m_samplerCreateInfo.mipLodBias = mipLodBias; @@ -7491,6 +8986,11 @@ namespace vk return m_samplerCreateInfo.anisotropyEnable; } + Bool32& anisotropyEnable() + { + return m_samplerCreateInfo.anisotropyEnable; + } + SamplerCreateInfo& anisotropyEnable( Bool32 anisotropyEnable ) { m_samplerCreateInfo.anisotropyEnable = anisotropyEnable; @@ -7502,6 +9002,11 @@ namespace vk return m_samplerCreateInfo.maxAnisotropy; } + float& maxAnisotropy() + { + return m_samplerCreateInfo.maxAnisotropy; + } + SamplerCreateInfo& maxAnisotropy( float maxAnisotropy ) { m_samplerCreateInfo.maxAnisotropy = maxAnisotropy; @@ -7513,6 +9018,11 @@ namespace vk return m_samplerCreateInfo.compareEnable; } + Bool32& compareEnable() + { + return m_samplerCreateInfo.compareEnable; + } + SamplerCreateInfo& compareEnable( Bool32 compareEnable ) { m_samplerCreateInfo.compareEnable = compareEnable; @@ -7524,6 +9034,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.compareOp ); } + CompareOp& compareOp() + { + return reinterpret_cast( m_samplerCreateInfo.compareOp ); + } + SamplerCreateInfo& compareOp( CompareOp compareOp ) { m_samplerCreateInfo.compareOp = static_cast( compareOp ); @@ -7535,6 +9050,11 @@ namespace vk return m_samplerCreateInfo.minLod; } + float& minLod() + { + return m_samplerCreateInfo.minLod; + } + SamplerCreateInfo& minLod( float minLod ) { m_samplerCreateInfo.minLod = minLod; @@ -7546,6 +9066,11 @@ namespace vk return m_samplerCreateInfo.maxLod; } + float& maxLod() + { + return m_samplerCreateInfo.maxLod; + } + SamplerCreateInfo& maxLod( float maxLod ) { m_samplerCreateInfo.maxLod = maxLod; @@ -7557,6 +9082,11 @@ namespace vk return reinterpret_cast( m_samplerCreateInfo.borderColor ); } + BorderColor& borderColor() + { + return reinterpret_cast( m_samplerCreateInfo.borderColor ); + } + SamplerCreateInfo& borderColor( BorderColor borderColor ) { m_samplerCreateInfo.borderColor = static_cast( borderColor ); @@ -7568,6 +9098,11 @@ namespace vk return m_samplerCreateInfo.unnormalizedCoordinates; } + Bool32& unnormalizedCoordinates() + { + return m_samplerCreateInfo.unnormalizedCoordinates; + } + SamplerCreateInfo& unnormalizedCoordinates( Bool32 unnormalizedCoordinates ) { m_samplerCreateInfo.unnormalizedCoordinates = unnormalizedCoordinates; @@ -7616,6 +9151,11 @@ namespace vk return reinterpret_cast( m_commandBufferAllocateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_commandBufferAllocateInfo.sType ); + } + CommandBufferAllocateInfo& sType( StructureType sType ) { m_commandBufferAllocateInfo.sType = static_cast( sType ); @@ -7627,6 +9167,11 @@ namespace vk return reinterpret_cast( m_commandBufferAllocateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_commandBufferAllocateInfo.pNext ); + } + CommandBufferAllocateInfo& pNext( const void* pNext ) { m_commandBufferAllocateInfo.pNext = pNext; @@ -7638,6 +9183,11 @@ namespace vk return reinterpret_cast( m_commandBufferAllocateInfo.commandPool ); } + CommandPool& commandPool() + { + return reinterpret_cast( m_commandBufferAllocateInfo.commandPool ); + } + CommandBufferAllocateInfo& commandPool( CommandPool commandPool ) { m_commandBufferAllocateInfo.commandPool = static_cast( commandPool ); @@ -7649,6 +9199,11 @@ namespace vk return reinterpret_cast( m_commandBufferAllocateInfo.level ); } + CommandBufferLevel& level() + { + return reinterpret_cast( m_commandBufferAllocateInfo.level ); + } + CommandBufferAllocateInfo& level( CommandBufferLevel level ) { m_commandBufferAllocateInfo.level = static_cast( level ); @@ -7660,6 +9215,11 @@ namespace vk return m_commandBufferAllocateInfo.commandBufferCount; } + uint32_t& commandBufferCount() + { + return m_commandBufferAllocateInfo.commandBufferCount; + } + CommandBufferAllocateInfo& commandBufferCount( uint32_t commandBufferCount ) { m_commandBufferAllocateInfo.commandBufferCount = commandBufferCount; @@ -7710,6 +9270,11 @@ namespace vk return reinterpret_cast( m_renderPassBeginInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_renderPassBeginInfo.sType ); + } + RenderPassBeginInfo& sType( StructureType sType ) { m_renderPassBeginInfo.sType = static_cast( sType ); @@ -7721,6 +9286,11 @@ namespace vk return reinterpret_cast( m_renderPassBeginInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_renderPassBeginInfo.pNext ); + } + RenderPassBeginInfo& pNext( const void* pNext ) { m_renderPassBeginInfo.pNext = pNext; @@ -7732,6 +9302,11 @@ namespace vk return reinterpret_cast( m_renderPassBeginInfo.renderPass ); } + RenderPass& renderPass() + { + return reinterpret_cast( m_renderPassBeginInfo.renderPass ); + } + RenderPassBeginInfo& renderPass( RenderPass renderPass ) { m_renderPassBeginInfo.renderPass = static_cast( renderPass ); @@ -7743,6 +9318,11 @@ namespace vk return reinterpret_cast( m_renderPassBeginInfo.framebuffer ); } + Framebuffer& framebuffer() + { + return reinterpret_cast( m_renderPassBeginInfo.framebuffer ); + } + RenderPassBeginInfo& framebuffer( Framebuffer framebuffer ) { m_renderPassBeginInfo.framebuffer = static_cast( framebuffer ); @@ -7754,6 +9334,11 @@ namespace vk return reinterpret_cast( m_renderPassBeginInfo.renderArea ); } + Rect2D& renderArea() + { + return reinterpret_cast( m_renderPassBeginInfo.renderArea ); + } + RenderPassBeginInfo& renderArea( Rect2D renderArea ) { m_renderPassBeginInfo.renderArea = static_cast( renderArea ); @@ -7765,6 +9350,11 @@ namespace vk return m_renderPassBeginInfo.clearValueCount; } + uint32_t& clearValueCount() + { + return m_renderPassBeginInfo.clearValueCount; + } + RenderPassBeginInfo& clearValueCount( uint32_t clearValueCount ) { m_renderPassBeginInfo.clearValueCount = clearValueCount; @@ -7776,6 +9366,11 @@ namespace vk return reinterpret_cast( m_renderPassBeginInfo.pClearValues ); } + const ClearValue* pClearValues() + { + return reinterpret_cast( m_renderPassBeginInfo.pClearValues ); + } + RenderPassBeginInfo& pClearValues( const ClearValue* pClearValues ) { m_renderPassBeginInfo.pClearValues = reinterpret_cast( pClearValues ); @@ -7822,6 +9417,11 @@ namespace vk return reinterpret_cast( m_eventCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_eventCreateInfo.sType ); + } + EventCreateInfo& sType( StructureType sType ) { m_eventCreateInfo.sType = static_cast( sType ); @@ -7833,6 +9433,11 @@ namespace vk return reinterpret_cast( m_eventCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_eventCreateInfo.pNext ); + } + EventCreateInfo& pNext( const void* pNext ) { m_eventCreateInfo.pNext = pNext; @@ -7844,6 +9449,11 @@ namespace vk return reinterpret_cast( m_eventCreateInfo.flags ); } + EventCreateFlags& flags() + { + return reinterpret_cast( m_eventCreateInfo.flags ); + } + EventCreateInfo& flags( EventCreateFlags flags ) { m_eventCreateInfo.flags = static_cast( flags ); @@ -7890,6 +9500,11 @@ namespace vk return reinterpret_cast( m_semaphoreCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_semaphoreCreateInfo.sType ); + } + SemaphoreCreateInfo& sType( StructureType sType ) { m_semaphoreCreateInfo.sType = static_cast( sType ); @@ -7901,6 +9516,11 @@ namespace vk return reinterpret_cast( m_semaphoreCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_semaphoreCreateInfo.pNext ); + } + SemaphoreCreateInfo& pNext( const void* pNext ) { m_semaphoreCreateInfo.pNext = pNext; @@ -7912,6 +9532,11 @@ namespace vk return reinterpret_cast( m_semaphoreCreateInfo.flags ); } + SemaphoreCreateFlags& flags() + { + return reinterpret_cast( m_semaphoreCreateInfo.flags ); + } + SemaphoreCreateInfo& flags( SemaphoreCreateFlags flags ) { m_semaphoreCreateInfo.flags = static_cast( flags ); @@ -7964,6 +9589,11 @@ namespace vk return reinterpret_cast( m_framebufferCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_framebufferCreateInfo.sType ); + } + FramebufferCreateInfo& sType( StructureType sType ) { m_framebufferCreateInfo.sType = static_cast( sType ); @@ -7975,6 +9605,11 @@ namespace vk return reinterpret_cast( m_framebufferCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_framebufferCreateInfo.pNext ); + } + FramebufferCreateInfo& pNext( const void* pNext ) { m_framebufferCreateInfo.pNext = pNext; @@ -7986,6 +9621,11 @@ namespace vk return reinterpret_cast( m_framebufferCreateInfo.flags ); } + FramebufferCreateFlags& flags() + { + return reinterpret_cast( m_framebufferCreateInfo.flags ); + } + FramebufferCreateInfo& flags( FramebufferCreateFlags flags ) { m_framebufferCreateInfo.flags = static_cast( flags ); @@ -7997,6 +9637,11 @@ namespace vk return reinterpret_cast( m_framebufferCreateInfo.renderPass ); } + RenderPass& renderPass() + { + return reinterpret_cast( m_framebufferCreateInfo.renderPass ); + } + FramebufferCreateInfo& renderPass( RenderPass renderPass ) { m_framebufferCreateInfo.renderPass = static_cast( renderPass ); @@ -8008,6 +9653,11 @@ namespace vk return m_framebufferCreateInfo.attachmentCount; } + uint32_t& attachmentCount() + { + return m_framebufferCreateInfo.attachmentCount; + } + FramebufferCreateInfo& attachmentCount( uint32_t attachmentCount ) { m_framebufferCreateInfo.attachmentCount = attachmentCount; @@ -8019,6 +9669,11 @@ namespace vk return reinterpret_cast( m_framebufferCreateInfo.pAttachments ); } + const ImageView* pAttachments() + { + return reinterpret_cast( m_framebufferCreateInfo.pAttachments ); + } + FramebufferCreateInfo& pAttachments( const ImageView* pAttachments ) { m_framebufferCreateInfo.pAttachments = reinterpret_cast( pAttachments ); @@ -8030,6 +9685,11 @@ namespace vk return m_framebufferCreateInfo.width; } + uint32_t& width() + { + return m_framebufferCreateInfo.width; + } + FramebufferCreateInfo& width( uint32_t width ) { m_framebufferCreateInfo.width = width; @@ -8041,6 +9701,11 @@ namespace vk return m_framebufferCreateInfo.height; } + uint32_t& height() + { + return m_framebufferCreateInfo.height; + } + FramebufferCreateInfo& height( uint32_t height ) { m_framebufferCreateInfo.height = height; @@ -8052,6 +9717,11 @@ namespace vk return m_framebufferCreateInfo.layers; } + uint32_t& layers() + { + return m_framebufferCreateInfo.layers; + } + FramebufferCreateInfo& layers( uint32_t layers ) { m_framebufferCreateInfo.layers = layers; @@ -8099,6 +9769,11 @@ namespace vk return reinterpret_cast( m_displayModeCreateInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_displayModeCreateInfoKHR.sType ); + } + DisplayModeCreateInfoKHR& sType( StructureType sType ) { m_displayModeCreateInfoKHR.sType = static_cast( sType ); @@ -8110,6 +9785,11 @@ namespace vk return reinterpret_cast( m_displayModeCreateInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_displayModeCreateInfoKHR.pNext ); + } + DisplayModeCreateInfoKHR& pNext( const void* pNext ) { m_displayModeCreateInfoKHR.pNext = pNext; @@ -8121,6 +9801,11 @@ namespace vk return reinterpret_cast( m_displayModeCreateInfoKHR.flags ); } + DisplayModeCreateFlagsKHR& flags() + { + return reinterpret_cast( m_displayModeCreateInfoKHR.flags ); + } + DisplayModeCreateInfoKHR& flags( DisplayModeCreateFlagsKHR flags ) { m_displayModeCreateInfoKHR.flags = static_cast( flags ); @@ -8132,6 +9817,11 @@ namespace vk return reinterpret_cast( m_displayModeCreateInfoKHR.parameters ); } + DisplayModeParametersKHR& parameters() + { + return reinterpret_cast( m_displayModeCreateInfoKHR.parameters ); + } + DisplayModeCreateInfoKHR& parameters( DisplayModeParametersKHR parameters ) { m_displayModeCreateInfoKHR.parameters = static_cast( parameters ); @@ -8180,6 +9870,11 @@ namespace vk return reinterpret_cast( m_displayPresentInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_displayPresentInfoKHR.sType ); + } + DisplayPresentInfoKHR& sType( StructureType sType ) { m_displayPresentInfoKHR.sType = static_cast( sType ); @@ -8191,6 +9886,11 @@ namespace vk return reinterpret_cast( m_displayPresentInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_displayPresentInfoKHR.pNext ); + } + DisplayPresentInfoKHR& pNext( const void* pNext ) { m_displayPresentInfoKHR.pNext = pNext; @@ -8202,6 +9902,11 @@ namespace vk return reinterpret_cast( m_displayPresentInfoKHR.srcRect ); } + Rect2D& srcRect() + { + return reinterpret_cast( m_displayPresentInfoKHR.srcRect ); + } + DisplayPresentInfoKHR& srcRect( Rect2D srcRect ) { m_displayPresentInfoKHR.srcRect = static_cast( srcRect ); @@ -8213,6 +9918,11 @@ namespace vk return reinterpret_cast( m_displayPresentInfoKHR.dstRect ); } + Rect2D& dstRect() + { + return reinterpret_cast( m_displayPresentInfoKHR.dstRect ); + } + DisplayPresentInfoKHR& dstRect( Rect2D dstRect ) { m_displayPresentInfoKHR.dstRect = static_cast( dstRect ); @@ -8224,6 +9934,11 @@ namespace vk return m_displayPresentInfoKHR.persistent; } + Bool32& persistent() + { + return m_displayPresentInfoKHR.persistent; + } + DisplayPresentInfoKHR& persistent( Bool32 persistent ) { m_displayPresentInfoKHR.persistent = persistent; @@ -8272,6 +9987,11 @@ namespace vk return reinterpret_cast( m_androidSurfaceCreateInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_androidSurfaceCreateInfoKHR.sType ); + } + AndroidSurfaceCreateInfoKHR& sType( StructureType sType ) { m_androidSurfaceCreateInfoKHR.sType = static_cast( sType ); @@ -8283,6 +10003,11 @@ namespace vk return reinterpret_cast( m_androidSurfaceCreateInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_androidSurfaceCreateInfoKHR.pNext ); + } + AndroidSurfaceCreateInfoKHR& pNext( const void* pNext ) { m_androidSurfaceCreateInfoKHR.pNext = pNext; @@ -8294,6 +10019,11 @@ namespace vk return reinterpret_cast( m_androidSurfaceCreateInfoKHR.flags ); } + AndroidSurfaceCreateFlagsKHR& flags() + { + return reinterpret_cast( m_androidSurfaceCreateInfoKHR.flags ); + } + AndroidSurfaceCreateInfoKHR& flags( AndroidSurfaceCreateFlagsKHR flags ) { m_androidSurfaceCreateInfoKHR.flags = static_cast( flags ); @@ -8301,6 +10031,11 @@ namespace vk } const ANativeWindow* window() const + { + return reinterpret_cast( m_androidSurfaceCreateInfoKHR.window ); + } + + ANativeWindow* window() { return reinterpret_cast( m_androidSurfaceCreateInfoKHR.window ); } @@ -8355,6 +10090,11 @@ namespace vk return reinterpret_cast( m_mirSurfaceCreateInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_mirSurfaceCreateInfoKHR.sType ); + } + MirSurfaceCreateInfoKHR& sType( StructureType sType ) { m_mirSurfaceCreateInfoKHR.sType = static_cast( sType ); @@ -8366,6 +10106,11 @@ namespace vk return reinterpret_cast( m_mirSurfaceCreateInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_mirSurfaceCreateInfoKHR.pNext ); + } + MirSurfaceCreateInfoKHR& pNext( const void* pNext ) { m_mirSurfaceCreateInfoKHR.pNext = pNext; @@ -8377,6 +10122,11 @@ namespace vk return reinterpret_cast( m_mirSurfaceCreateInfoKHR.flags ); } + MirSurfaceCreateFlagsKHR& flags() + { + return reinterpret_cast( m_mirSurfaceCreateInfoKHR.flags ); + } + MirSurfaceCreateInfoKHR& flags( MirSurfaceCreateFlagsKHR flags ) { m_mirSurfaceCreateInfoKHR.flags = static_cast( flags ); @@ -8384,6 +10134,11 @@ namespace vk } const MirConnection* connection() const + { + return reinterpret_cast( m_mirSurfaceCreateInfoKHR.connection ); + } + + MirConnection* connection() { return reinterpret_cast( m_mirSurfaceCreateInfoKHR.connection ); } @@ -8395,6 +10150,11 @@ namespace vk } const MirSurface* mirSurface() const + { + return reinterpret_cast( m_mirSurfaceCreateInfoKHR.mirSurface ); + } + + MirSurface* mirSurface() { return reinterpret_cast( m_mirSurfaceCreateInfoKHR.mirSurface ); } @@ -8449,6 +10209,11 @@ namespace vk return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.sType ); + } + WaylandSurfaceCreateInfoKHR& sType( StructureType sType ) { m_waylandSurfaceCreateInfoKHR.sType = static_cast( sType ); @@ -8460,6 +10225,11 @@ namespace vk return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.pNext ); + } + WaylandSurfaceCreateInfoKHR& pNext( const void* pNext ) { m_waylandSurfaceCreateInfoKHR.pNext = pNext; @@ -8471,6 +10241,11 @@ namespace vk return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.flags ); } + WaylandSurfaceCreateFlagsKHR& flags() + { + return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.flags ); + } + WaylandSurfaceCreateInfoKHR& flags( WaylandSurfaceCreateFlagsKHR flags ) { m_waylandSurfaceCreateInfoKHR.flags = static_cast( flags ); @@ -8478,6 +10253,11 @@ namespace vk } const struct wl_display* display() const + { + return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.display ); + } + + struct wl_display* display() { return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.display ); } @@ -8489,6 +10269,11 @@ namespace vk } const struct wl_surface* surface() const + { + return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.surface ); + } + + struct wl_surface* surface() { return reinterpret_cast( m_waylandSurfaceCreateInfoKHR.surface ); } @@ -8543,6 +10328,11 @@ namespace vk return reinterpret_cast( m_win32SurfaceCreateInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_win32SurfaceCreateInfoKHR.sType ); + } + Win32SurfaceCreateInfoKHR& sType( StructureType sType ) { m_win32SurfaceCreateInfoKHR.sType = static_cast( sType ); @@ -8554,6 +10344,11 @@ namespace vk return reinterpret_cast( m_win32SurfaceCreateInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_win32SurfaceCreateInfoKHR.pNext ); + } + Win32SurfaceCreateInfoKHR& pNext( const void* pNext ) { m_win32SurfaceCreateInfoKHR.pNext = pNext; @@ -8565,6 +10360,11 @@ namespace vk return reinterpret_cast( m_win32SurfaceCreateInfoKHR.flags ); } + Win32SurfaceCreateFlagsKHR& flags() + { + return reinterpret_cast( m_win32SurfaceCreateInfoKHR.flags ); + } + Win32SurfaceCreateInfoKHR& flags( Win32SurfaceCreateFlagsKHR flags ) { m_win32SurfaceCreateInfoKHR.flags = static_cast( flags ); @@ -8576,6 +10376,11 @@ namespace vk return m_win32SurfaceCreateInfoKHR.hinstance; } + HINSTANCE& hinstance() + { + return m_win32SurfaceCreateInfoKHR.hinstance; + } + Win32SurfaceCreateInfoKHR& hinstance( HINSTANCE hinstance ) { m_win32SurfaceCreateInfoKHR.hinstance = hinstance; @@ -8587,6 +10392,11 @@ namespace vk return m_win32SurfaceCreateInfoKHR.hwnd; } + HWND& hwnd() + { + return m_win32SurfaceCreateInfoKHR.hwnd; + } + Win32SurfaceCreateInfoKHR& hwnd( HWND hwnd ) { m_win32SurfaceCreateInfoKHR.hwnd = hwnd; @@ -8637,6 +10447,11 @@ namespace vk return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.sType ); + } + XlibSurfaceCreateInfoKHR& sType( StructureType sType ) { m_xlibSurfaceCreateInfoKHR.sType = static_cast( sType ); @@ -8648,6 +10463,11 @@ namespace vk return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.pNext ); + } + XlibSurfaceCreateInfoKHR& pNext( const void* pNext ) { m_xlibSurfaceCreateInfoKHR.pNext = pNext; @@ -8659,6 +10479,11 @@ namespace vk return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.flags ); } + XlibSurfaceCreateFlagsKHR& flags() + { + return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.flags ); + } + XlibSurfaceCreateInfoKHR& flags( XlibSurfaceCreateFlagsKHR flags ) { m_xlibSurfaceCreateInfoKHR.flags = static_cast( flags ); @@ -8666,6 +10491,11 @@ namespace vk } const Display* dpy() const + { + return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.dpy ); + } + + Display* dpy() { return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.dpy ); } @@ -8681,6 +10511,11 @@ namespace vk return m_xlibSurfaceCreateInfoKHR.window; } + Window& window() + { + return m_xlibSurfaceCreateInfoKHR.window; + } + XlibSurfaceCreateInfoKHR& window( Window window ) { m_xlibSurfaceCreateInfoKHR.window = window; @@ -8731,6 +10566,11 @@ namespace vk return reinterpret_cast( m_xcbSurfaceCreateInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_xcbSurfaceCreateInfoKHR.sType ); + } + XcbSurfaceCreateInfoKHR& sType( StructureType sType ) { m_xcbSurfaceCreateInfoKHR.sType = static_cast( sType ); @@ -8742,6 +10582,11 @@ namespace vk return reinterpret_cast( m_xcbSurfaceCreateInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_xcbSurfaceCreateInfoKHR.pNext ); + } + XcbSurfaceCreateInfoKHR& pNext( const void* pNext ) { m_xcbSurfaceCreateInfoKHR.pNext = pNext; @@ -8753,6 +10598,11 @@ namespace vk return reinterpret_cast( m_xcbSurfaceCreateInfoKHR.flags ); } + XcbSurfaceCreateFlagsKHR& flags() + { + return reinterpret_cast( m_xcbSurfaceCreateInfoKHR.flags ); + } + XcbSurfaceCreateInfoKHR& flags( XcbSurfaceCreateFlagsKHR flags ) { m_xcbSurfaceCreateInfoKHR.flags = static_cast( flags ); @@ -8760,6 +10610,11 @@ namespace vk } const xcb_connection_t* connection() const + { + return reinterpret_cast( m_xcbSurfaceCreateInfoKHR.connection ); + } + + xcb_connection_t* connection() { return reinterpret_cast( m_xcbSurfaceCreateInfoKHR.connection ); } @@ -8775,6 +10630,11 @@ namespace vk return m_xcbSurfaceCreateInfoKHR.window; } + xcb_window_t& window() + { + return m_xcbSurfaceCreateInfoKHR.window; + } + XcbSurfaceCreateInfoKHR& window( xcb_window_t window ) { m_xcbSurfaceCreateInfoKHR.window = window; @@ -8860,6 +10720,11 @@ namespace vk return reinterpret_cast( m_presentInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_presentInfoKHR.sType ); + } + PresentInfoKHR& sType( StructureType sType ) { m_presentInfoKHR.sType = static_cast( sType ); @@ -8871,6 +10736,11 @@ namespace vk return reinterpret_cast( m_presentInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_presentInfoKHR.pNext ); + } + PresentInfoKHR& pNext( const void* pNext ) { m_presentInfoKHR.pNext = pNext; @@ -8882,6 +10752,11 @@ namespace vk return m_presentInfoKHR.waitSemaphoreCount; } + uint32_t& waitSemaphoreCount() + { + return m_presentInfoKHR.waitSemaphoreCount; + } + PresentInfoKHR& waitSemaphoreCount( uint32_t waitSemaphoreCount ) { m_presentInfoKHR.waitSemaphoreCount = waitSemaphoreCount; @@ -8893,6 +10768,11 @@ namespace vk return reinterpret_cast( m_presentInfoKHR.pWaitSemaphores ); } + const Semaphore* pWaitSemaphores() + { + return reinterpret_cast( m_presentInfoKHR.pWaitSemaphores ); + } + PresentInfoKHR& pWaitSemaphores( const Semaphore* pWaitSemaphores ) { m_presentInfoKHR.pWaitSemaphores = reinterpret_cast( pWaitSemaphores ); @@ -8904,6 +10784,11 @@ namespace vk return m_presentInfoKHR.swapchainCount; } + uint32_t& swapchainCount() + { + return m_presentInfoKHR.swapchainCount; + } + PresentInfoKHR& swapchainCount( uint32_t swapchainCount ) { m_presentInfoKHR.swapchainCount = swapchainCount; @@ -8915,6 +10800,11 @@ namespace vk return reinterpret_cast( m_presentInfoKHR.pSwapchains ); } + const SwapchainKHR* pSwapchains() + { + return reinterpret_cast( m_presentInfoKHR.pSwapchains ); + } + PresentInfoKHR& pSwapchains( const SwapchainKHR* pSwapchains ) { m_presentInfoKHR.pSwapchains = reinterpret_cast( pSwapchains ); @@ -8926,6 +10816,11 @@ namespace vk return reinterpret_cast( m_presentInfoKHR.pImageIndices ); } + const uint32_t* pImageIndices() + { + return reinterpret_cast( m_presentInfoKHR.pImageIndices ); + } + PresentInfoKHR& pImageIndices( const uint32_t* pImageIndices ) { m_presentInfoKHR.pImageIndices = pImageIndices; @@ -8933,6 +10828,11 @@ namespace vk } const Result* pResults() const + { + return reinterpret_cast( m_presentInfoKHR.pResults ); + } + + Result* pResults() { return reinterpret_cast( m_presentInfoKHR.pResults ); } @@ -8998,6 +10898,11 @@ namespace vk return reinterpret_cast( m_pipelineDynamicStateCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineDynamicStateCreateInfo.sType ); + } + PipelineDynamicStateCreateInfo& sType( StructureType sType ) { m_pipelineDynamicStateCreateInfo.sType = static_cast( sType ); @@ -9009,6 +10914,11 @@ namespace vk return reinterpret_cast( m_pipelineDynamicStateCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineDynamicStateCreateInfo.pNext ); + } + PipelineDynamicStateCreateInfo& pNext( const void* pNext ) { m_pipelineDynamicStateCreateInfo.pNext = pNext; @@ -9020,6 +10930,11 @@ namespace vk return reinterpret_cast( m_pipelineDynamicStateCreateInfo.flags ); } + PipelineDynamicStateCreateFlags& flags() + { + return reinterpret_cast( m_pipelineDynamicStateCreateInfo.flags ); + } + PipelineDynamicStateCreateInfo& flags( PipelineDynamicStateCreateFlags flags ) { m_pipelineDynamicStateCreateInfo.flags = static_cast( flags ); @@ -9031,6 +10946,11 @@ namespace vk return m_pipelineDynamicStateCreateInfo.dynamicStateCount; } + uint32_t& dynamicStateCount() + { + return m_pipelineDynamicStateCreateInfo.dynamicStateCount; + } + PipelineDynamicStateCreateInfo& dynamicStateCount( uint32_t dynamicStateCount ) { m_pipelineDynamicStateCreateInfo.dynamicStateCount = dynamicStateCount; @@ -9042,6 +10962,11 @@ namespace vk return reinterpret_cast( m_pipelineDynamicStateCreateInfo.pDynamicStates ); } + const DynamicState* pDynamicStates() + { + return reinterpret_cast( m_pipelineDynamicStateCreateInfo.pDynamicStates ); + } + PipelineDynamicStateCreateInfo& pDynamicStates( const DynamicState* pDynamicStates ) { m_pipelineDynamicStateCreateInfo.pDynamicStates = reinterpret_cast( pDynamicStates ); @@ -9272,6 +11197,11 @@ namespace vk return reinterpret_cast( m_memoryBarrier.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_memoryBarrier.sType ); + } + MemoryBarrier& sType( StructureType sType ) { m_memoryBarrier.sType = static_cast( sType ); @@ -9283,6 +11213,11 @@ namespace vk return reinterpret_cast( m_memoryBarrier.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_memoryBarrier.pNext ); + } + MemoryBarrier& pNext( const void* pNext ) { m_memoryBarrier.pNext = pNext; @@ -9294,6 +11229,11 @@ namespace vk return reinterpret_cast( m_memoryBarrier.srcAccessMask ); } + AccessFlags& srcAccessMask() + { + return reinterpret_cast( m_memoryBarrier.srcAccessMask ); + } + MemoryBarrier& srcAccessMask( AccessFlags srcAccessMask ) { m_memoryBarrier.srcAccessMask = static_cast( srcAccessMask ); @@ -9305,6 +11245,11 @@ namespace vk return reinterpret_cast( m_memoryBarrier.dstAccessMask ); } + AccessFlags& dstAccessMask() + { + return reinterpret_cast( m_memoryBarrier.dstAccessMask ); + } + MemoryBarrier& dstAccessMask( AccessFlags dstAccessMask ) { m_memoryBarrier.dstAccessMask = static_cast( dstAccessMask ); @@ -9357,6 +11302,11 @@ namespace vk return reinterpret_cast( m_bufferMemoryBarrier.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_bufferMemoryBarrier.sType ); + } + BufferMemoryBarrier& sType( StructureType sType ) { m_bufferMemoryBarrier.sType = static_cast( sType ); @@ -9368,6 +11318,11 @@ namespace vk return reinterpret_cast( m_bufferMemoryBarrier.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_bufferMemoryBarrier.pNext ); + } + BufferMemoryBarrier& pNext( const void* pNext ) { m_bufferMemoryBarrier.pNext = pNext; @@ -9379,6 +11334,11 @@ namespace vk return reinterpret_cast( m_bufferMemoryBarrier.srcAccessMask ); } + AccessFlags& srcAccessMask() + { + return reinterpret_cast( m_bufferMemoryBarrier.srcAccessMask ); + } + BufferMemoryBarrier& srcAccessMask( AccessFlags srcAccessMask ) { m_bufferMemoryBarrier.srcAccessMask = static_cast( srcAccessMask ); @@ -9390,6 +11350,11 @@ namespace vk return reinterpret_cast( m_bufferMemoryBarrier.dstAccessMask ); } + AccessFlags& dstAccessMask() + { + return reinterpret_cast( m_bufferMemoryBarrier.dstAccessMask ); + } + BufferMemoryBarrier& dstAccessMask( AccessFlags dstAccessMask ) { m_bufferMemoryBarrier.dstAccessMask = static_cast( dstAccessMask ); @@ -9401,6 +11366,11 @@ namespace vk return m_bufferMemoryBarrier.srcQueueFamilyIndex; } + uint32_t& srcQueueFamilyIndex() + { + return m_bufferMemoryBarrier.srcQueueFamilyIndex; + } + BufferMemoryBarrier& srcQueueFamilyIndex( uint32_t srcQueueFamilyIndex ) { m_bufferMemoryBarrier.srcQueueFamilyIndex = srcQueueFamilyIndex; @@ -9412,6 +11382,11 @@ namespace vk return m_bufferMemoryBarrier.dstQueueFamilyIndex; } + uint32_t& dstQueueFamilyIndex() + { + return m_bufferMemoryBarrier.dstQueueFamilyIndex; + } + BufferMemoryBarrier& dstQueueFamilyIndex( uint32_t dstQueueFamilyIndex ) { m_bufferMemoryBarrier.dstQueueFamilyIndex = dstQueueFamilyIndex; @@ -9423,6 +11398,11 @@ namespace vk return reinterpret_cast( m_bufferMemoryBarrier.buffer ); } + Buffer& buffer() + { + return reinterpret_cast( m_bufferMemoryBarrier.buffer ); + } + BufferMemoryBarrier& buffer( Buffer buffer ) { m_bufferMemoryBarrier.buffer = static_cast( buffer ); @@ -9434,6 +11414,11 @@ namespace vk return m_bufferMemoryBarrier.offset; } + DeviceSize& offset() + { + return m_bufferMemoryBarrier.offset; + } + BufferMemoryBarrier& offset( DeviceSize offset ) { m_bufferMemoryBarrier.offset = offset; @@ -9445,6 +11430,11 @@ namespace vk return m_bufferMemoryBarrier.size; } + DeviceSize& size() + { + return m_bufferMemoryBarrier.size; + } + BufferMemoryBarrier& size( DeviceSize size ) { m_bufferMemoryBarrier.size = size; @@ -9530,6 +11520,11 @@ namespace vk return reinterpret_cast( m_bufferCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_bufferCreateInfo.sType ); + } + BufferCreateInfo& sType( StructureType sType ) { m_bufferCreateInfo.sType = static_cast( sType ); @@ -9541,6 +11536,11 @@ namespace vk return reinterpret_cast( m_bufferCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_bufferCreateInfo.pNext ); + } + BufferCreateInfo& pNext( const void* pNext ) { m_bufferCreateInfo.pNext = pNext; @@ -9552,6 +11552,11 @@ namespace vk return reinterpret_cast( m_bufferCreateInfo.flags ); } + BufferCreateFlags& flags() + { + return reinterpret_cast( m_bufferCreateInfo.flags ); + } + BufferCreateInfo& flags( BufferCreateFlags flags ) { m_bufferCreateInfo.flags = static_cast( flags ); @@ -9563,6 +11568,11 @@ namespace vk return m_bufferCreateInfo.size; } + DeviceSize& size() + { + return m_bufferCreateInfo.size; + } + BufferCreateInfo& size( DeviceSize size ) { m_bufferCreateInfo.size = size; @@ -9574,6 +11584,11 @@ namespace vk return reinterpret_cast( m_bufferCreateInfo.usage ); } + BufferUsageFlags& usage() + { + return reinterpret_cast( m_bufferCreateInfo.usage ); + } + BufferCreateInfo& usage( BufferUsageFlags usage ) { m_bufferCreateInfo.usage = static_cast( usage ); @@ -9585,6 +11600,11 @@ namespace vk return reinterpret_cast( m_bufferCreateInfo.sharingMode ); } + SharingMode& sharingMode() + { + return reinterpret_cast( m_bufferCreateInfo.sharingMode ); + } + BufferCreateInfo& sharingMode( SharingMode sharingMode ) { m_bufferCreateInfo.sharingMode = static_cast( sharingMode ); @@ -9596,6 +11616,11 @@ namespace vk return m_bufferCreateInfo.queueFamilyIndexCount; } + uint32_t& queueFamilyIndexCount() + { + return m_bufferCreateInfo.queueFamilyIndexCount; + } + BufferCreateInfo& queueFamilyIndexCount( uint32_t queueFamilyIndexCount ) { m_bufferCreateInfo.queueFamilyIndexCount = queueFamilyIndexCount; @@ -9607,6 +11632,11 @@ namespace vk return reinterpret_cast( m_bufferCreateInfo.pQueueFamilyIndices ); } + const uint32_t* pQueueFamilyIndices() + { + return reinterpret_cast( m_bufferCreateInfo.pQueueFamilyIndices ); + } + BufferCreateInfo& pQueueFamilyIndices( const uint32_t* pQueueFamilyIndices ) { m_bufferCreateInfo.pQueueFamilyIndices = pQueueFamilyIndices; @@ -9674,6 +11704,11 @@ namespace vk return m_descriptorSetLayoutBinding.binding; } + uint32_t& binding() + { + return m_descriptorSetLayoutBinding.binding; + } + DescriptorSetLayoutBinding& binding( uint32_t binding ) { m_descriptorSetLayoutBinding.binding = binding; @@ -9685,6 +11720,11 @@ namespace vk return reinterpret_cast( m_descriptorSetLayoutBinding.descriptorType ); } + DescriptorType& descriptorType() + { + return reinterpret_cast( m_descriptorSetLayoutBinding.descriptorType ); + } + DescriptorSetLayoutBinding& descriptorType( DescriptorType descriptorType ) { m_descriptorSetLayoutBinding.descriptorType = static_cast( descriptorType ); @@ -9696,6 +11736,11 @@ namespace vk return m_descriptorSetLayoutBinding.descriptorCount; } + uint32_t& descriptorCount() + { + return m_descriptorSetLayoutBinding.descriptorCount; + } + DescriptorSetLayoutBinding& descriptorCount( uint32_t descriptorCount ) { m_descriptorSetLayoutBinding.descriptorCount = descriptorCount; @@ -9707,6 +11752,11 @@ namespace vk return reinterpret_cast( m_descriptorSetLayoutBinding.stageFlags ); } + ShaderStageFlags& stageFlags() + { + return reinterpret_cast( m_descriptorSetLayoutBinding.stageFlags ); + } + DescriptorSetLayoutBinding& stageFlags( ShaderStageFlags stageFlags ) { m_descriptorSetLayoutBinding.stageFlags = static_cast( stageFlags ); @@ -9718,6 +11768,11 @@ namespace vk return reinterpret_cast( m_descriptorSetLayoutBinding.pImmutableSamplers ); } + const Sampler* pImmutableSamplers() + { + return reinterpret_cast( m_descriptorSetLayoutBinding.pImmutableSamplers ); + } + DescriptorSetLayoutBinding& pImmutableSamplers( const Sampler* pImmutableSamplers ) { m_descriptorSetLayoutBinding.pImmutableSamplers = reinterpret_cast( pImmutableSamplers ); @@ -9766,6 +11821,11 @@ namespace vk return reinterpret_cast( m_descriptorSetLayoutCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_descriptorSetLayoutCreateInfo.sType ); + } + DescriptorSetLayoutCreateInfo& sType( StructureType sType ) { m_descriptorSetLayoutCreateInfo.sType = static_cast( sType ); @@ -9777,6 +11837,11 @@ namespace vk return reinterpret_cast( m_descriptorSetLayoutCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_descriptorSetLayoutCreateInfo.pNext ); + } + DescriptorSetLayoutCreateInfo& pNext( const void* pNext ) { m_descriptorSetLayoutCreateInfo.pNext = pNext; @@ -9788,6 +11853,11 @@ namespace vk return reinterpret_cast( m_descriptorSetLayoutCreateInfo.flags ); } + DescriptorSetLayoutCreateFlags& flags() + { + return reinterpret_cast( m_descriptorSetLayoutCreateInfo.flags ); + } + DescriptorSetLayoutCreateInfo& flags( DescriptorSetLayoutCreateFlags flags ) { m_descriptorSetLayoutCreateInfo.flags = static_cast( flags ); @@ -9799,6 +11869,11 @@ namespace vk return m_descriptorSetLayoutCreateInfo.bindingCount; } + uint32_t& bindingCount() + { + return m_descriptorSetLayoutCreateInfo.bindingCount; + } + DescriptorSetLayoutCreateInfo& bindingCount( uint32_t bindingCount ) { m_descriptorSetLayoutCreateInfo.bindingCount = bindingCount; @@ -9810,6 +11885,11 @@ namespace vk return reinterpret_cast( m_descriptorSetLayoutCreateInfo.pBindings ); } + const DescriptorSetLayoutBinding* pBindings() + { + return reinterpret_cast( m_descriptorSetLayoutCreateInfo.pBindings ); + } + DescriptorSetLayoutCreateInfo& pBindings( const DescriptorSetLayoutBinding* pBindings ) { m_descriptorSetLayoutCreateInfo.pBindings = reinterpret_cast( pBindings ); @@ -9860,6 +11940,11 @@ namespace vk return reinterpret_cast( m_pipelineShaderStageCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineShaderStageCreateInfo.sType ); + } + PipelineShaderStageCreateInfo& sType( StructureType sType ) { m_pipelineShaderStageCreateInfo.sType = static_cast( sType ); @@ -9871,6 +11956,11 @@ namespace vk return reinterpret_cast( m_pipelineShaderStageCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineShaderStageCreateInfo.pNext ); + } + PipelineShaderStageCreateInfo& pNext( const void* pNext ) { m_pipelineShaderStageCreateInfo.pNext = pNext; @@ -9882,6 +11972,11 @@ namespace vk return reinterpret_cast( m_pipelineShaderStageCreateInfo.flags ); } + PipelineShaderStageCreateFlags& flags() + { + return reinterpret_cast( m_pipelineShaderStageCreateInfo.flags ); + } + PipelineShaderStageCreateInfo& flags( PipelineShaderStageCreateFlags flags ) { m_pipelineShaderStageCreateInfo.flags = static_cast( flags ); @@ -9893,6 +11988,11 @@ namespace vk return reinterpret_cast( m_pipelineShaderStageCreateInfo.stage ); } + ShaderStageFlagBits& stage() + { + return reinterpret_cast( m_pipelineShaderStageCreateInfo.stage ); + } + PipelineShaderStageCreateInfo& stage( ShaderStageFlagBits stage ) { m_pipelineShaderStageCreateInfo.stage = static_cast( stage ); @@ -9904,6 +12004,11 @@ namespace vk return reinterpret_cast( m_pipelineShaderStageCreateInfo.module ); } + ShaderModule& module() + { + return reinterpret_cast( m_pipelineShaderStageCreateInfo.module ); + } + PipelineShaderStageCreateInfo& module( ShaderModule module ) { m_pipelineShaderStageCreateInfo.module = static_cast( module ); @@ -9915,6 +12020,11 @@ namespace vk return reinterpret_cast( m_pipelineShaderStageCreateInfo.pName ); } + const char* pName() + { + return reinterpret_cast( m_pipelineShaderStageCreateInfo.pName ); + } + PipelineShaderStageCreateInfo& pName( const char* pName ) { m_pipelineShaderStageCreateInfo.pName = pName; @@ -9926,6 +12036,11 @@ namespace vk return reinterpret_cast( m_pipelineShaderStageCreateInfo.pSpecializationInfo ); } + const SpecializationInfo* pSpecializationInfo() + { + return reinterpret_cast( m_pipelineShaderStageCreateInfo.pSpecializationInfo ); + } + PipelineShaderStageCreateInfo& pSpecializationInfo( const SpecializationInfo* pSpecializationInfo ) { m_pipelineShaderStageCreateInfo.pSpecializationInfo = reinterpret_cast( pSpecializationInfo ); @@ -9972,6 +12087,11 @@ namespace vk return reinterpret_cast( m_pushConstantRange.stageFlags ); } + ShaderStageFlags& stageFlags() + { + return reinterpret_cast( m_pushConstantRange.stageFlags ); + } + PushConstantRange& stageFlags( ShaderStageFlags stageFlags ) { m_pushConstantRange.stageFlags = static_cast( stageFlags ); @@ -9983,6 +12103,11 @@ namespace vk return m_pushConstantRange.offset; } + uint32_t& offset() + { + return m_pushConstantRange.offset; + } + PushConstantRange& offset( uint32_t offset ) { m_pushConstantRange.offset = offset; @@ -9994,6 +12119,11 @@ namespace vk return m_pushConstantRange.size; } + uint32_t& size() + { + return m_pushConstantRange.size; + } + PushConstantRange& size( uint32_t size ) { m_pushConstantRange.size = size; @@ -10044,6 +12174,11 @@ namespace vk return reinterpret_cast( m_pipelineLayoutCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineLayoutCreateInfo.sType ); + } + PipelineLayoutCreateInfo& sType( StructureType sType ) { m_pipelineLayoutCreateInfo.sType = static_cast( sType ); @@ -10055,6 +12190,11 @@ namespace vk return reinterpret_cast( m_pipelineLayoutCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineLayoutCreateInfo.pNext ); + } + PipelineLayoutCreateInfo& pNext( const void* pNext ) { m_pipelineLayoutCreateInfo.pNext = pNext; @@ -10066,6 +12206,11 @@ namespace vk return reinterpret_cast( m_pipelineLayoutCreateInfo.flags ); } + PipelineLayoutCreateFlags& flags() + { + return reinterpret_cast( m_pipelineLayoutCreateInfo.flags ); + } + PipelineLayoutCreateInfo& flags( PipelineLayoutCreateFlags flags ) { m_pipelineLayoutCreateInfo.flags = static_cast( flags ); @@ -10077,6 +12222,11 @@ namespace vk return m_pipelineLayoutCreateInfo.setLayoutCount; } + uint32_t& setLayoutCount() + { + return m_pipelineLayoutCreateInfo.setLayoutCount; + } + PipelineLayoutCreateInfo& setLayoutCount( uint32_t setLayoutCount ) { m_pipelineLayoutCreateInfo.setLayoutCount = setLayoutCount; @@ -10088,6 +12238,11 @@ namespace vk return reinterpret_cast( m_pipelineLayoutCreateInfo.pSetLayouts ); } + const DescriptorSetLayout* pSetLayouts() + { + return reinterpret_cast( m_pipelineLayoutCreateInfo.pSetLayouts ); + } + PipelineLayoutCreateInfo& pSetLayouts( const DescriptorSetLayout* pSetLayouts ) { m_pipelineLayoutCreateInfo.pSetLayouts = reinterpret_cast( pSetLayouts ); @@ -10099,6 +12254,11 @@ namespace vk return m_pipelineLayoutCreateInfo.pushConstantRangeCount; } + uint32_t& pushConstantRangeCount() + { + return m_pipelineLayoutCreateInfo.pushConstantRangeCount; + } + PipelineLayoutCreateInfo& pushConstantRangeCount( uint32_t pushConstantRangeCount ) { m_pipelineLayoutCreateInfo.pushConstantRangeCount = pushConstantRangeCount; @@ -10110,6 +12270,11 @@ namespace vk return reinterpret_cast( m_pipelineLayoutCreateInfo.pPushConstantRanges ); } + const PushConstantRange* pPushConstantRanges() + { + return reinterpret_cast( m_pipelineLayoutCreateInfo.pPushConstantRanges ); + } + PipelineLayoutCreateInfo& pPushConstantRanges( const PushConstantRange* pPushConstantRanges ) { m_pipelineLayoutCreateInfo.pPushConstantRanges = reinterpret_cast( pPushConstantRanges ); @@ -10209,6 +12374,11 @@ namespace vk return reinterpret_cast( m_computePipelineCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_computePipelineCreateInfo.sType ); + } + ComputePipelineCreateInfo& sType( StructureType sType ) { m_computePipelineCreateInfo.sType = static_cast( sType ); @@ -10220,6 +12390,11 @@ namespace vk return reinterpret_cast( m_computePipelineCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_computePipelineCreateInfo.pNext ); + } + ComputePipelineCreateInfo& pNext( const void* pNext ) { m_computePipelineCreateInfo.pNext = pNext; @@ -10231,6 +12406,11 @@ namespace vk return reinterpret_cast( m_computePipelineCreateInfo.flags ); } + PipelineCreateFlags& flags() + { + return reinterpret_cast( m_computePipelineCreateInfo.flags ); + } + ComputePipelineCreateInfo& flags( PipelineCreateFlags flags ) { m_computePipelineCreateInfo.flags = static_cast( flags ); @@ -10242,6 +12422,11 @@ namespace vk return reinterpret_cast( m_computePipelineCreateInfo.stage ); } + PipelineShaderStageCreateInfo& stage() + { + return reinterpret_cast( m_computePipelineCreateInfo.stage ); + } + ComputePipelineCreateInfo& stage( PipelineShaderStageCreateInfo stage ) { m_computePipelineCreateInfo.stage = static_cast( stage ); @@ -10253,6 +12438,11 @@ namespace vk return reinterpret_cast( m_computePipelineCreateInfo.layout ); } + PipelineLayout& layout() + { + return reinterpret_cast( m_computePipelineCreateInfo.layout ); + } + ComputePipelineCreateInfo& layout( PipelineLayout layout ) { m_computePipelineCreateInfo.layout = static_cast( layout ); @@ -10264,6 +12454,11 @@ namespace vk return reinterpret_cast( m_computePipelineCreateInfo.basePipelineHandle ); } + Pipeline& basePipelineHandle() + { + return reinterpret_cast( m_computePipelineCreateInfo.basePipelineHandle ); + } + ComputePipelineCreateInfo& basePipelineHandle( Pipeline basePipelineHandle ) { m_computePipelineCreateInfo.basePipelineHandle = static_cast( basePipelineHandle ); @@ -10275,6 +12470,11 @@ namespace vk return m_computePipelineCreateInfo.basePipelineIndex; } + int32_t& basePipelineIndex() + { + return m_computePipelineCreateInfo.basePipelineIndex; + } + ComputePipelineCreateInfo& basePipelineIndex( int32_t basePipelineIndex ) { m_computePipelineCreateInfo.basePipelineIndex = basePipelineIndex; @@ -10341,6 +12541,11 @@ namespace vk return m_pipelineColorBlendAttachmentState.blendEnable; } + Bool32& blendEnable() + { + return m_pipelineColorBlendAttachmentState.blendEnable; + } + PipelineColorBlendAttachmentState& blendEnable( Bool32 blendEnable ) { m_pipelineColorBlendAttachmentState.blendEnable = blendEnable; @@ -10352,6 +12557,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendAttachmentState.srcColorBlendFactor ); } + BlendFactor& srcColorBlendFactor() + { + return reinterpret_cast( m_pipelineColorBlendAttachmentState.srcColorBlendFactor ); + } + PipelineColorBlendAttachmentState& srcColorBlendFactor( BlendFactor srcColorBlendFactor ) { m_pipelineColorBlendAttachmentState.srcColorBlendFactor = static_cast( srcColorBlendFactor ); @@ -10363,6 +12573,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendAttachmentState.dstColorBlendFactor ); } + BlendFactor& dstColorBlendFactor() + { + return reinterpret_cast( m_pipelineColorBlendAttachmentState.dstColorBlendFactor ); + } + PipelineColorBlendAttachmentState& dstColorBlendFactor( BlendFactor dstColorBlendFactor ) { m_pipelineColorBlendAttachmentState.dstColorBlendFactor = static_cast( dstColorBlendFactor ); @@ -10374,6 +12589,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendAttachmentState.colorBlendOp ); } + BlendOp& colorBlendOp() + { + return reinterpret_cast( m_pipelineColorBlendAttachmentState.colorBlendOp ); + } + PipelineColorBlendAttachmentState& colorBlendOp( BlendOp colorBlendOp ) { m_pipelineColorBlendAttachmentState.colorBlendOp = static_cast( colorBlendOp ); @@ -10385,6 +12605,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendAttachmentState.srcAlphaBlendFactor ); } + BlendFactor& srcAlphaBlendFactor() + { + return reinterpret_cast( m_pipelineColorBlendAttachmentState.srcAlphaBlendFactor ); + } + PipelineColorBlendAttachmentState& srcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor ) { m_pipelineColorBlendAttachmentState.srcAlphaBlendFactor = static_cast( srcAlphaBlendFactor ); @@ -10396,6 +12621,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendAttachmentState.dstAlphaBlendFactor ); } + BlendFactor& dstAlphaBlendFactor() + { + return reinterpret_cast( m_pipelineColorBlendAttachmentState.dstAlphaBlendFactor ); + } + PipelineColorBlendAttachmentState& dstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor ) { m_pipelineColorBlendAttachmentState.dstAlphaBlendFactor = static_cast( dstAlphaBlendFactor ); @@ -10407,6 +12637,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendAttachmentState.alphaBlendOp ); } + BlendOp& alphaBlendOp() + { + return reinterpret_cast( m_pipelineColorBlendAttachmentState.alphaBlendOp ); + } + PipelineColorBlendAttachmentState& alphaBlendOp( BlendOp alphaBlendOp ) { m_pipelineColorBlendAttachmentState.alphaBlendOp = static_cast( alphaBlendOp ); @@ -10418,6 +12653,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendAttachmentState.colorWriteMask ); } + ColorComponentFlags& colorWriteMask() + { + return reinterpret_cast( m_pipelineColorBlendAttachmentState.colorWriteMask ); + } + PipelineColorBlendAttachmentState& colorWriteMask( ColorComponentFlags colorWriteMask ) { m_pipelineColorBlendAttachmentState.colorWriteMask = static_cast( colorWriteMask ); @@ -10469,6 +12709,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.sType ); + } + PipelineColorBlendStateCreateInfo& sType( StructureType sType ) { m_pipelineColorBlendStateCreateInfo.sType = static_cast( sType ); @@ -10480,6 +12725,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.pNext ); + } + PipelineColorBlendStateCreateInfo& pNext( const void* pNext ) { m_pipelineColorBlendStateCreateInfo.pNext = pNext; @@ -10491,6 +12741,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.flags ); } + PipelineColorBlendStateCreateFlags& flags() + { + return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.flags ); + } + PipelineColorBlendStateCreateInfo& flags( PipelineColorBlendStateCreateFlags flags ) { m_pipelineColorBlendStateCreateInfo.flags = static_cast( flags ); @@ -10502,6 +12757,11 @@ namespace vk return m_pipelineColorBlendStateCreateInfo.logicOpEnable; } + Bool32& logicOpEnable() + { + return m_pipelineColorBlendStateCreateInfo.logicOpEnable; + } + PipelineColorBlendStateCreateInfo& logicOpEnable( Bool32 logicOpEnable ) { m_pipelineColorBlendStateCreateInfo.logicOpEnable = logicOpEnable; @@ -10513,6 +12773,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.logicOp ); } + LogicOp& logicOp() + { + return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.logicOp ); + } + PipelineColorBlendStateCreateInfo& logicOp( LogicOp logicOp ) { m_pipelineColorBlendStateCreateInfo.logicOp = static_cast( logicOp ); @@ -10524,6 +12789,11 @@ namespace vk return m_pipelineColorBlendStateCreateInfo.attachmentCount; } + uint32_t& attachmentCount() + { + return m_pipelineColorBlendStateCreateInfo.attachmentCount; + } + PipelineColorBlendStateCreateInfo& attachmentCount( uint32_t attachmentCount ) { m_pipelineColorBlendStateCreateInfo.attachmentCount = attachmentCount; @@ -10535,6 +12805,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.pAttachments ); } + const PipelineColorBlendAttachmentState* pAttachments() + { + return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.pAttachments ); + } + PipelineColorBlendStateCreateInfo& pAttachments( const PipelineColorBlendAttachmentState* pAttachments ) { m_pipelineColorBlendStateCreateInfo.pAttachments = reinterpret_cast( pAttachments ); @@ -10546,6 +12821,11 @@ namespace vk return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.blendConstants ); } + float* blendConstants() + { + return reinterpret_cast( m_pipelineColorBlendStateCreateInfo.blendConstants ); + } + PipelineColorBlendStateCreateInfo& blendConstants( std::array blendConstants ) { memcpy( &m_pipelineColorBlendStateCreateInfo.blendConstants, blendConstants.data(), 4 * sizeof( float ) ); @@ -10604,6 +12884,11 @@ namespace vk return reinterpret_cast( m_fenceCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_fenceCreateInfo.sType ); + } + FenceCreateInfo& sType( StructureType sType ) { m_fenceCreateInfo.sType = static_cast( sType ); @@ -10615,6 +12900,11 @@ namespace vk return reinterpret_cast( m_fenceCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_fenceCreateInfo.pNext ); + } + FenceCreateInfo& pNext( const void* pNext ) { m_fenceCreateInfo.pNext = pNext; @@ -10626,6 +12916,11 @@ namespace vk return reinterpret_cast( m_fenceCreateInfo.flags ); } + FenceCreateFlags& flags() + { + return reinterpret_cast( m_fenceCreateInfo.flags ); + } + FenceCreateInfo& flags( FenceCreateFlags flags ) { m_fenceCreateInfo.flags = static_cast( flags ); @@ -10792,6 +13087,11 @@ namespace vk return reinterpret_cast( m_commandBufferInheritanceInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_commandBufferInheritanceInfo.sType ); + } + CommandBufferInheritanceInfo& sType( StructureType sType ) { m_commandBufferInheritanceInfo.sType = static_cast( sType ); @@ -10803,6 +13103,11 @@ namespace vk return reinterpret_cast( m_commandBufferInheritanceInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_commandBufferInheritanceInfo.pNext ); + } + CommandBufferInheritanceInfo& pNext( const void* pNext ) { m_commandBufferInheritanceInfo.pNext = pNext; @@ -10814,6 +13119,11 @@ namespace vk return reinterpret_cast( m_commandBufferInheritanceInfo.renderPass ); } + RenderPass& renderPass() + { + return reinterpret_cast( m_commandBufferInheritanceInfo.renderPass ); + } + CommandBufferInheritanceInfo& renderPass( RenderPass renderPass ) { m_commandBufferInheritanceInfo.renderPass = static_cast( renderPass ); @@ -10825,6 +13135,11 @@ namespace vk return m_commandBufferInheritanceInfo.subpass; } + uint32_t& subpass() + { + return m_commandBufferInheritanceInfo.subpass; + } + CommandBufferInheritanceInfo& subpass( uint32_t subpass ) { m_commandBufferInheritanceInfo.subpass = subpass; @@ -10836,6 +13151,11 @@ namespace vk return reinterpret_cast( m_commandBufferInheritanceInfo.framebuffer ); } + Framebuffer& framebuffer() + { + return reinterpret_cast( m_commandBufferInheritanceInfo.framebuffer ); + } + CommandBufferInheritanceInfo& framebuffer( Framebuffer framebuffer ) { m_commandBufferInheritanceInfo.framebuffer = static_cast( framebuffer ); @@ -10847,6 +13167,11 @@ namespace vk return m_commandBufferInheritanceInfo.occlusionQueryEnable; } + Bool32& occlusionQueryEnable() + { + return m_commandBufferInheritanceInfo.occlusionQueryEnable; + } + CommandBufferInheritanceInfo& occlusionQueryEnable( Bool32 occlusionQueryEnable ) { m_commandBufferInheritanceInfo.occlusionQueryEnable = occlusionQueryEnable; @@ -10858,6 +13183,11 @@ namespace vk return reinterpret_cast( m_commandBufferInheritanceInfo.queryFlags ); } + QueryControlFlags& queryFlags() + { + return reinterpret_cast( m_commandBufferInheritanceInfo.queryFlags ); + } + CommandBufferInheritanceInfo& queryFlags( QueryControlFlags queryFlags ) { m_commandBufferInheritanceInfo.queryFlags = static_cast( queryFlags ); @@ -10869,6 +13199,11 @@ namespace vk return reinterpret_cast( m_commandBufferInheritanceInfo.pipelineStatistics ); } + QueryPipelineStatisticFlags& pipelineStatistics() + { + return reinterpret_cast( m_commandBufferInheritanceInfo.pipelineStatistics ); + } + CommandBufferInheritanceInfo& pipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics ) { m_commandBufferInheritanceInfo.pipelineStatistics = static_cast( pipelineStatistics ); @@ -10916,6 +13251,11 @@ namespace vk return reinterpret_cast( m_commandBufferBeginInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_commandBufferBeginInfo.sType ); + } + CommandBufferBeginInfo& sType( StructureType sType ) { m_commandBufferBeginInfo.sType = static_cast( sType ); @@ -10927,6 +13267,11 @@ namespace vk return reinterpret_cast( m_commandBufferBeginInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_commandBufferBeginInfo.pNext ); + } + CommandBufferBeginInfo& pNext( const void* pNext ) { m_commandBufferBeginInfo.pNext = pNext; @@ -10938,6 +13283,11 @@ namespace vk return reinterpret_cast( m_commandBufferBeginInfo.flags ); } + CommandBufferUsageFlags& flags() + { + return reinterpret_cast( m_commandBufferBeginInfo.flags ); + } + CommandBufferBeginInfo& flags( CommandBufferUsageFlags flags ) { m_commandBufferBeginInfo.flags = static_cast( flags ); @@ -10949,6 +13299,11 @@ namespace vk return reinterpret_cast( m_commandBufferBeginInfo.pInheritanceInfo ); } + const CommandBufferInheritanceInfo* pInheritanceInfo() + { + return reinterpret_cast( m_commandBufferBeginInfo.pInheritanceInfo ); + } + CommandBufferBeginInfo& pInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo ) { m_commandBufferBeginInfo.pInheritanceInfo = reinterpret_cast( pInheritanceInfo ); @@ -10998,6 +13353,11 @@ namespace vk return reinterpret_cast( m_queryPoolCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_queryPoolCreateInfo.sType ); + } + QueryPoolCreateInfo& sType( StructureType sType ) { m_queryPoolCreateInfo.sType = static_cast( sType ); @@ -11009,6 +13369,11 @@ namespace vk return reinterpret_cast( m_queryPoolCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_queryPoolCreateInfo.pNext ); + } + QueryPoolCreateInfo& pNext( const void* pNext ) { m_queryPoolCreateInfo.pNext = pNext; @@ -11020,6 +13385,11 @@ namespace vk return reinterpret_cast( m_queryPoolCreateInfo.flags ); } + QueryPoolCreateFlags& flags() + { + return reinterpret_cast( m_queryPoolCreateInfo.flags ); + } + QueryPoolCreateInfo& flags( QueryPoolCreateFlags flags ) { m_queryPoolCreateInfo.flags = static_cast( flags ); @@ -11031,6 +13401,11 @@ namespace vk return reinterpret_cast( m_queryPoolCreateInfo.queryType ); } + QueryType& queryType() + { + return reinterpret_cast( m_queryPoolCreateInfo.queryType ); + } + QueryPoolCreateInfo& queryType( QueryType queryType ) { m_queryPoolCreateInfo.queryType = static_cast( queryType ); @@ -11042,6 +13417,11 @@ namespace vk return m_queryPoolCreateInfo.queryCount; } + uint32_t& queryCount() + { + return m_queryPoolCreateInfo.queryCount; + } + QueryPoolCreateInfo& queryCount( uint32_t queryCount ) { m_queryPoolCreateInfo.queryCount = queryCount; @@ -11053,6 +13433,11 @@ namespace vk return reinterpret_cast( m_queryPoolCreateInfo.pipelineStatistics ); } + QueryPipelineStatisticFlags& pipelineStatistics() + { + return reinterpret_cast( m_queryPoolCreateInfo.pipelineStatistics ); + } + QueryPoolCreateInfo& pipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics ) { m_queryPoolCreateInfo.pipelineStatistics = static_cast( pipelineStatistics ); @@ -11114,6 +13499,11 @@ namespace vk return reinterpret_cast( m_imageSubresource.aspectMask ); } + ImageAspectFlags& aspectMask() + { + return reinterpret_cast( m_imageSubresource.aspectMask ); + } + ImageSubresource& aspectMask( ImageAspectFlags aspectMask ) { m_imageSubresource.aspectMask = static_cast( aspectMask ); @@ -11125,6 +13515,11 @@ namespace vk return m_imageSubresource.mipLevel; } + uint32_t& mipLevel() + { + return m_imageSubresource.mipLevel; + } + ImageSubresource& mipLevel( uint32_t mipLevel ) { m_imageSubresource.mipLevel = mipLevel; @@ -11136,6 +13531,11 @@ namespace vk return m_imageSubresource.arrayLayer; } + uint32_t& arrayLayer() + { + return m_imageSubresource.arrayLayer; + } + ImageSubresource& arrayLayer( uint32_t arrayLayer ) { m_imageSubresource.arrayLayer = arrayLayer; @@ -11183,6 +13583,11 @@ namespace vk return reinterpret_cast( m_imageSubresourceLayers.aspectMask ); } + ImageAspectFlags& aspectMask() + { + return reinterpret_cast( m_imageSubresourceLayers.aspectMask ); + } + ImageSubresourceLayers& aspectMask( ImageAspectFlags aspectMask ) { m_imageSubresourceLayers.aspectMask = static_cast( aspectMask ); @@ -11194,6 +13599,11 @@ namespace vk return m_imageSubresourceLayers.mipLevel; } + uint32_t& mipLevel() + { + return m_imageSubresourceLayers.mipLevel; + } + ImageSubresourceLayers& mipLevel( uint32_t mipLevel ) { m_imageSubresourceLayers.mipLevel = mipLevel; @@ -11205,6 +13615,11 @@ namespace vk return m_imageSubresourceLayers.baseArrayLayer; } + uint32_t& baseArrayLayer() + { + return m_imageSubresourceLayers.baseArrayLayer; + } + ImageSubresourceLayers& baseArrayLayer( uint32_t baseArrayLayer ) { m_imageSubresourceLayers.baseArrayLayer = baseArrayLayer; @@ -11216,6 +13631,11 @@ namespace vk return m_imageSubresourceLayers.layerCount; } + uint32_t& layerCount() + { + return m_imageSubresourceLayers.layerCount; + } + ImageSubresourceLayers& layerCount( uint32_t layerCount ) { m_imageSubresourceLayers.layerCount = layerCount; @@ -11264,6 +13684,11 @@ namespace vk return reinterpret_cast( m_imageSubresourceRange.aspectMask ); } + ImageAspectFlags& aspectMask() + { + return reinterpret_cast( m_imageSubresourceRange.aspectMask ); + } + ImageSubresourceRange& aspectMask( ImageAspectFlags aspectMask ) { m_imageSubresourceRange.aspectMask = static_cast( aspectMask ); @@ -11275,6 +13700,11 @@ namespace vk return m_imageSubresourceRange.baseMipLevel; } + uint32_t& baseMipLevel() + { + return m_imageSubresourceRange.baseMipLevel; + } + ImageSubresourceRange& baseMipLevel( uint32_t baseMipLevel ) { m_imageSubresourceRange.baseMipLevel = baseMipLevel; @@ -11286,6 +13716,11 @@ namespace vk return m_imageSubresourceRange.levelCount; } + uint32_t& levelCount() + { + return m_imageSubresourceRange.levelCount; + } + ImageSubresourceRange& levelCount( uint32_t levelCount ) { m_imageSubresourceRange.levelCount = levelCount; @@ -11297,6 +13732,11 @@ namespace vk return m_imageSubresourceRange.baseArrayLayer; } + uint32_t& baseArrayLayer() + { + return m_imageSubresourceRange.baseArrayLayer; + } + ImageSubresourceRange& baseArrayLayer( uint32_t baseArrayLayer ) { m_imageSubresourceRange.baseArrayLayer = baseArrayLayer; @@ -11308,6 +13748,11 @@ namespace vk return m_imageSubresourceRange.layerCount; } + uint32_t& layerCount() + { + return m_imageSubresourceRange.layerCount; + } + ImageSubresourceRange& layerCount( uint32_t layerCount ) { m_imageSubresourceRange.layerCount = layerCount; @@ -11361,6 +13806,11 @@ namespace vk return reinterpret_cast( m_imageMemoryBarrier.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_imageMemoryBarrier.sType ); + } + ImageMemoryBarrier& sType( StructureType sType ) { m_imageMemoryBarrier.sType = static_cast( sType ); @@ -11372,6 +13822,11 @@ namespace vk return reinterpret_cast( m_imageMemoryBarrier.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_imageMemoryBarrier.pNext ); + } + ImageMemoryBarrier& pNext( const void* pNext ) { m_imageMemoryBarrier.pNext = pNext; @@ -11383,6 +13838,11 @@ namespace vk return reinterpret_cast( m_imageMemoryBarrier.srcAccessMask ); } + AccessFlags& srcAccessMask() + { + return reinterpret_cast( m_imageMemoryBarrier.srcAccessMask ); + } + ImageMemoryBarrier& srcAccessMask( AccessFlags srcAccessMask ) { m_imageMemoryBarrier.srcAccessMask = static_cast( srcAccessMask ); @@ -11394,6 +13854,11 @@ namespace vk return reinterpret_cast( m_imageMemoryBarrier.dstAccessMask ); } + AccessFlags& dstAccessMask() + { + return reinterpret_cast( m_imageMemoryBarrier.dstAccessMask ); + } + ImageMemoryBarrier& dstAccessMask( AccessFlags dstAccessMask ) { m_imageMemoryBarrier.dstAccessMask = static_cast( dstAccessMask ); @@ -11405,6 +13870,11 @@ namespace vk return reinterpret_cast( m_imageMemoryBarrier.oldLayout ); } + ImageLayout& oldLayout() + { + return reinterpret_cast( m_imageMemoryBarrier.oldLayout ); + } + ImageMemoryBarrier& oldLayout( ImageLayout oldLayout ) { m_imageMemoryBarrier.oldLayout = static_cast( oldLayout ); @@ -11416,6 +13886,11 @@ namespace vk return reinterpret_cast( m_imageMemoryBarrier.newLayout ); } + ImageLayout& newLayout() + { + return reinterpret_cast( m_imageMemoryBarrier.newLayout ); + } + ImageMemoryBarrier& newLayout( ImageLayout newLayout ) { m_imageMemoryBarrier.newLayout = static_cast( newLayout ); @@ -11427,6 +13902,11 @@ namespace vk return m_imageMemoryBarrier.srcQueueFamilyIndex; } + uint32_t& srcQueueFamilyIndex() + { + return m_imageMemoryBarrier.srcQueueFamilyIndex; + } + ImageMemoryBarrier& srcQueueFamilyIndex( uint32_t srcQueueFamilyIndex ) { m_imageMemoryBarrier.srcQueueFamilyIndex = srcQueueFamilyIndex; @@ -11438,6 +13918,11 @@ namespace vk return m_imageMemoryBarrier.dstQueueFamilyIndex; } + uint32_t& dstQueueFamilyIndex() + { + return m_imageMemoryBarrier.dstQueueFamilyIndex; + } + ImageMemoryBarrier& dstQueueFamilyIndex( uint32_t dstQueueFamilyIndex ) { m_imageMemoryBarrier.dstQueueFamilyIndex = dstQueueFamilyIndex; @@ -11449,6 +13934,11 @@ namespace vk return reinterpret_cast( m_imageMemoryBarrier.image ); } + Image& image() + { + return reinterpret_cast( m_imageMemoryBarrier.image ); + } + ImageMemoryBarrier& image( Image image ) { m_imageMemoryBarrier.image = static_cast( image ); @@ -11460,6 +13950,11 @@ namespace vk return reinterpret_cast( m_imageMemoryBarrier.subresourceRange ); } + ImageSubresourceRange& subresourceRange() + { + return reinterpret_cast( m_imageMemoryBarrier.subresourceRange ); + } + ImageMemoryBarrier& subresourceRange( ImageSubresourceRange subresourceRange ) { m_imageMemoryBarrier.subresourceRange = static_cast( subresourceRange ); @@ -11511,6 +14006,11 @@ namespace vk return reinterpret_cast( m_imageViewCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_imageViewCreateInfo.sType ); + } + ImageViewCreateInfo& sType( StructureType sType ) { m_imageViewCreateInfo.sType = static_cast( sType ); @@ -11522,6 +14022,11 @@ namespace vk return reinterpret_cast( m_imageViewCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_imageViewCreateInfo.pNext ); + } + ImageViewCreateInfo& pNext( const void* pNext ) { m_imageViewCreateInfo.pNext = pNext; @@ -11533,6 +14038,11 @@ namespace vk return reinterpret_cast( m_imageViewCreateInfo.flags ); } + ImageViewCreateFlags& flags() + { + return reinterpret_cast( m_imageViewCreateInfo.flags ); + } + ImageViewCreateInfo& flags( ImageViewCreateFlags flags ) { m_imageViewCreateInfo.flags = static_cast( flags ); @@ -11544,6 +14054,11 @@ namespace vk return reinterpret_cast( m_imageViewCreateInfo.image ); } + Image& image() + { + return reinterpret_cast( m_imageViewCreateInfo.image ); + } + ImageViewCreateInfo& image( Image image ) { m_imageViewCreateInfo.image = static_cast( image ); @@ -11555,6 +14070,11 @@ namespace vk return reinterpret_cast( m_imageViewCreateInfo.viewType ); } + ImageViewType& viewType() + { + return reinterpret_cast( m_imageViewCreateInfo.viewType ); + } + ImageViewCreateInfo& viewType( ImageViewType viewType ) { m_imageViewCreateInfo.viewType = static_cast( viewType ); @@ -11566,6 +14086,11 @@ namespace vk return reinterpret_cast( m_imageViewCreateInfo.format ); } + Format& format() + { + return reinterpret_cast( m_imageViewCreateInfo.format ); + } + ImageViewCreateInfo& format( Format format ) { m_imageViewCreateInfo.format = static_cast( format ); @@ -11577,6 +14102,11 @@ namespace vk return reinterpret_cast( m_imageViewCreateInfo.components ); } + ComponentMapping& components() + { + return reinterpret_cast( m_imageViewCreateInfo.components ); + } + ImageViewCreateInfo& components( ComponentMapping components ) { m_imageViewCreateInfo.components = static_cast( components ); @@ -11588,6 +14118,11 @@ namespace vk return reinterpret_cast( m_imageViewCreateInfo.subresourceRange ); } + ImageSubresourceRange& subresourceRange() + { + return reinterpret_cast( m_imageViewCreateInfo.subresourceRange ); + } + ImageViewCreateInfo& subresourceRange( ImageSubresourceRange subresourceRange ) { m_imageViewCreateInfo.subresourceRange = static_cast( subresourceRange ); @@ -11636,6 +14171,11 @@ namespace vk return reinterpret_cast( m_imageCopy.srcSubresource ); } + ImageSubresourceLayers& srcSubresource() + { + return reinterpret_cast( m_imageCopy.srcSubresource ); + } + ImageCopy& srcSubresource( ImageSubresourceLayers srcSubresource ) { m_imageCopy.srcSubresource = static_cast( srcSubresource ); @@ -11647,6 +14187,11 @@ namespace vk return reinterpret_cast( m_imageCopy.srcOffset ); } + Offset3D& srcOffset() + { + return reinterpret_cast( m_imageCopy.srcOffset ); + } + ImageCopy& srcOffset( Offset3D srcOffset ) { m_imageCopy.srcOffset = static_cast( srcOffset ); @@ -11658,6 +14203,11 @@ namespace vk return reinterpret_cast( m_imageCopy.dstSubresource ); } + ImageSubresourceLayers& dstSubresource() + { + return reinterpret_cast( m_imageCopy.dstSubresource ); + } + ImageCopy& dstSubresource( ImageSubresourceLayers dstSubresource ) { m_imageCopy.dstSubresource = static_cast( dstSubresource ); @@ -11669,6 +14219,11 @@ namespace vk return reinterpret_cast( m_imageCopy.dstOffset ); } + Offset3D& dstOffset() + { + return reinterpret_cast( m_imageCopy.dstOffset ); + } + ImageCopy& dstOffset( Offset3D dstOffset ) { m_imageCopy.dstOffset = static_cast( dstOffset ); @@ -11680,6 +14235,11 @@ namespace vk return reinterpret_cast( m_imageCopy.extent ); } + Extent3D& extent() + { + return reinterpret_cast( m_imageCopy.extent ); + } + ImageCopy& extent( Extent3D extent ) { m_imageCopy.extent = static_cast( extent ); @@ -11727,6 +14287,11 @@ namespace vk return reinterpret_cast( m_imageBlit.srcSubresource ); } + ImageSubresourceLayers& srcSubresource() + { + return reinterpret_cast( m_imageBlit.srcSubresource ); + } + ImageBlit& srcSubresource( ImageSubresourceLayers srcSubresource ) { m_imageBlit.srcSubresource = static_cast( srcSubresource ); @@ -11738,6 +14303,11 @@ namespace vk return reinterpret_cast( m_imageBlit.srcOffsets ); } + Offset3D* srcOffsets() + { + return reinterpret_cast( m_imageBlit.srcOffsets ); + } + ImageBlit& srcOffsets( std::array srcOffsets ) { memcpy( &m_imageBlit.srcOffsets, srcOffsets.data(), 2 * sizeof( Offset3D ) ); @@ -11749,6 +14319,11 @@ namespace vk return reinterpret_cast( m_imageBlit.dstSubresource ); } + ImageSubresourceLayers& dstSubresource() + { + return reinterpret_cast( m_imageBlit.dstSubresource ); + } + ImageBlit& dstSubresource( ImageSubresourceLayers dstSubresource ) { m_imageBlit.dstSubresource = static_cast( dstSubresource ); @@ -11760,6 +14335,11 @@ namespace vk return reinterpret_cast( m_imageBlit.dstOffsets ); } + Offset3D* dstOffsets() + { + return reinterpret_cast( m_imageBlit.dstOffsets ); + } + ImageBlit& dstOffsets( std::array dstOffsets ) { memcpy( &m_imageBlit.dstOffsets, dstOffsets.data(), 2 * sizeof( Offset3D ) ); @@ -11809,6 +14389,11 @@ namespace vk return m_bufferImageCopy.bufferOffset; } + DeviceSize& bufferOffset() + { + return m_bufferImageCopy.bufferOffset; + } + BufferImageCopy& bufferOffset( DeviceSize bufferOffset ) { m_bufferImageCopy.bufferOffset = bufferOffset; @@ -11820,6 +14405,11 @@ namespace vk return m_bufferImageCopy.bufferRowLength; } + uint32_t& bufferRowLength() + { + return m_bufferImageCopy.bufferRowLength; + } + BufferImageCopy& bufferRowLength( uint32_t bufferRowLength ) { m_bufferImageCopy.bufferRowLength = bufferRowLength; @@ -11831,6 +14421,11 @@ namespace vk return m_bufferImageCopy.bufferImageHeight; } + uint32_t& bufferImageHeight() + { + return m_bufferImageCopy.bufferImageHeight; + } + BufferImageCopy& bufferImageHeight( uint32_t bufferImageHeight ) { m_bufferImageCopy.bufferImageHeight = bufferImageHeight; @@ -11842,6 +14437,11 @@ namespace vk return reinterpret_cast( m_bufferImageCopy.imageSubresource ); } + ImageSubresourceLayers& imageSubresource() + { + return reinterpret_cast( m_bufferImageCopy.imageSubresource ); + } + BufferImageCopy& imageSubresource( ImageSubresourceLayers imageSubresource ) { m_bufferImageCopy.imageSubresource = static_cast( imageSubresource ); @@ -11853,6 +14453,11 @@ namespace vk return reinterpret_cast( m_bufferImageCopy.imageOffset ); } + Offset3D& imageOffset() + { + return reinterpret_cast( m_bufferImageCopy.imageOffset ); + } + BufferImageCopy& imageOffset( Offset3D imageOffset ) { m_bufferImageCopy.imageOffset = static_cast( imageOffset ); @@ -11864,6 +14469,11 @@ namespace vk return reinterpret_cast( m_bufferImageCopy.imageExtent ); } + Extent3D& imageExtent() + { + return reinterpret_cast( m_bufferImageCopy.imageExtent ); + } + BufferImageCopy& imageExtent( Extent3D imageExtent ) { m_bufferImageCopy.imageExtent = static_cast( imageExtent ); @@ -11912,6 +14522,11 @@ namespace vk return reinterpret_cast( m_imageResolve.srcSubresource ); } + ImageSubresourceLayers& srcSubresource() + { + return reinterpret_cast( m_imageResolve.srcSubresource ); + } + ImageResolve& srcSubresource( ImageSubresourceLayers srcSubresource ) { m_imageResolve.srcSubresource = static_cast( srcSubresource ); @@ -11923,6 +14538,11 @@ namespace vk return reinterpret_cast( m_imageResolve.srcOffset ); } + Offset3D& srcOffset() + { + return reinterpret_cast( m_imageResolve.srcOffset ); + } + ImageResolve& srcOffset( Offset3D srcOffset ) { m_imageResolve.srcOffset = static_cast( srcOffset ); @@ -11934,6 +14554,11 @@ namespace vk return reinterpret_cast( m_imageResolve.dstSubresource ); } + ImageSubresourceLayers& dstSubresource() + { + return reinterpret_cast( m_imageResolve.dstSubresource ); + } + ImageResolve& dstSubresource( ImageSubresourceLayers dstSubresource ) { m_imageResolve.dstSubresource = static_cast( dstSubresource ); @@ -11945,6 +14570,11 @@ namespace vk return reinterpret_cast( m_imageResolve.dstOffset ); } + Offset3D& dstOffset() + { + return reinterpret_cast( m_imageResolve.dstOffset ); + } + ImageResolve& dstOffset( Offset3D dstOffset ) { m_imageResolve.dstOffset = static_cast( dstOffset ); @@ -11956,6 +14586,11 @@ namespace vk return reinterpret_cast( m_imageResolve.extent ); } + Extent3D& extent() + { + return reinterpret_cast( m_imageResolve.extent ); + } + ImageResolve& extent( Extent3D extent ) { m_imageResolve.extent = static_cast( extent ); @@ -12002,6 +14637,11 @@ namespace vk return reinterpret_cast( m_clearAttachment.aspectMask ); } + ImageAspectFlags& aspectMask() + { + return reinterpret_cast( m_clearAttachment.aspectMask ); + } + ClearAttachment& aspectMask( ImageAspectFlags aspectMask ) { m_clearAttachment.aspectMask = static_cast( aspectMask ); @@ -12013,6 +14653,11 @@ namespace vk return m_clearAttachment.colorAttachment; } + uint32_t& colorAttachment() + { + return m_clearAttachment.colorAttachment; + } + ClearAttachment& colorAttachment( uint32_t colorAttachment ) { m_clearAttachment.colorAttachment = colorAttachment; @@ -12024,6 +14669,11 @@ namespace vk return reinterpret_cast( m_clearAttachment.clearValue ); } + ClearValue& clearValue() + { + return reinterpret_cast( m_clearAttachment.clearValue ); + } + ClearAttachment& clearValue( ClearValue clearValue ) { m_clearAttachment.clearValue = static_cast( clearValue ); @@ -12164,6 +14814,11 @@ namespace vk return m_sparseMemoryBind.resourceOffset; } + DeviceSize& resourceOffset() + { + return m_sparseMemoryBind.resourceOffset; + } + SparseMemoryBind& resourceOffset( DeviceSize resourceOffset ) { m_sparseMemoryBind.resourceOffset = resourceOffset; @@ -12175,6 +14830,11 @@ namespace vk return m_sparseMemoryBind.size; } + DeviceSize& size() + { + return m_sparseMemoryBind.size; + } + SparseMemoryBind& size( DeviceSize size ) { m_sparseMemoryBind.size = size; @@ -12186,6 +14846,11 @@ namespace vk return reinterpret_cast( m_sparseMemoryBind.memory ); } + DeviceMemory& memory() + { + return reinterpret_cast( m_sparseMemoryBind.memory ); + } + SparseMemoryBind& memory( DeviceMemory memory ) { m_sparseMemoryBind.memory = static_cast( memory ); @@ -12197,6 +14862,11 @@ namespace vk return m_sparseMemoryBind.memoryOffset; } + DeviceSize& memoryOffset() + { + return m_sparseMemoryBind.memoryOffset; + } + SparseMemoryBind& memoryOffset( DeviceSize memoryOffset ) { m_sparseMemoryBind.memoryOffset = memoryOffset; @@ -12208,6 +14878,11 @@ namespace vk return reinterpret_cast( m_sparseMemoryBind.flags ); } + SparseMemoryBindFlags& flags() + { + return reinterpret_cast( m_sparseMemoryBind.flags ); + } + SparseMemoryBind& flags( SparseMemoryBindFlags flags ) { m_sparseMemoryBind.flags = static_cast( flags ); @@ -12257,6 +14932,11 @@ namespace vk return reinterpret_cast( m_sparseImageMemoryBind.subresource ); } + ImageSubresource& subresource() + { + return reinterpret_cast( m_sparseImageMemoryBind.subresource ); + } + SparseImageMemoryBind& subresource( ImageSubresource subresource ) { m_sparseImageMemoryBind.subresource = static_cast( subresource ); @@ -12268,6 +14948,11 @@ namespace vk return reinterpret_cast( m_sparseImageMemoryBind.offset ); } + Offset3D& offset() + { + return reinterpret_cast( m_sparseImageMemoryBind.offset ); + } + SparseImageMemoryBind& offset( Offset3D offset ) { m_sparseImageMemoryBind.offset = static_cast( offset ); @@ -12279,6 +14964,11 @@ namespace vk return reinterpret_cast( m_sparseImageMemoryBind.extent ); } + Extent3D& extent() + { + return reinterpret_cast( m_sparseImageMemoryBind.extent ); + } + SparseImageMemoryBind& extent( Extent3D extent ) { m_sparseImageMemoryBind.extent = static_cast( extent ); @@ -12290,6 +14980,11 @@ namespace vk return reinterpret_cast( m_sparseImageMemoryBind.memory ); } + DeviceMemory& memory() + { + return reinterpret_cast( m_sparseImageMemoryBind.memory ); + } + SparseImageMemoryBind& memory( DeviceMemory memory ) { m_sparseImageMemoryBind.memory = static_cast( memory ); @@ -12301,6 +14996,11 @@ namespace vk return m_sparseImageMemoryBind.memoryOffset; } + DeviceSize& memoryOffset() + { + return m_sparseImageMemoryBind.memoryOffset; + } + SparseImageMemoryBind& memoryOffset( DeviceSize memoryOffset ) { m_sparseImageMemoryBind.memoryOffset = memoryOffset; @@ -12312,6 +15012,11 @@ namespace vk return reinterpret_cast( m_sparseImageMemoryBind.flags ); } + SparseMemoryBindFlags& flags() + { + return reinterpret_cast( m_sparseImageMemoryBind.flags ); + } + SparseImageMemoryBind& flags( SparseMemoryBindFlags flags ) { m_sparseImageMemoryBind.flags = static_cast( flags ); @@ -12358,6 +15063,11 @@ namespace vk return reinterpret_cast( m_sparseBufferMemoryBindInfo.buffer ); } + Buffer& buffer() + { + return reinterpret_cast( m_sparseBufferMemoryBindInfo.buffer ); + } + SparseBufferMemoryBindInfo& buffer( Buffer buffer ) { m_sparseBufferMemoryBindInfo.buffer = static_cast( buffer ); @@ -12369,6 +15079,11 @@ namespace vk return m_sparseBufferMemoryBindInfo.bindCount; } + uint32_t& bindCount() + { + return m_sparseBufferMemoryBindInfo.bindCount; + } + SparseBufferMemoryBindInfo& bindCount( uint32_t bindCount ) { m_sparseBufferMemoryBindInfo.bindCount = bindCount; @@ -12380,6 +15095,11 @@ namespace vk return reinterpret_cast( m_sparseBufferMemoryBindInfo.pBinds ); } + const SparseMemoryBind* pBinds() + { + return reinterpret_cast( m_sparseBufferMemoryBindInfo.pBinds ); + } + SparseBufferMemoryBindInfo& pBinds( const SparseMemoryBind* pBinds ) { m_sparseBufferMemoryBindInfo.pBinds = reinterpret_cast( pBinds ); @@ -12426,6 +15146,11 @@ namespace vk return reinterpret_cast( m_sparseImageOpaqueMemoryBindInfo.image ); } + Image& image() + { + return reinterpret_cast( m_sparseImageOpaqueMemoryBindInfo.image ); + } + SparseImageOpaqueMemoryBindInfo& image( Image image ) { m_sparseImageOpaqueMemoryBindInfo.image = static_cast( image ); @@ -12437,6 +15162,11 @@ namespace vk return m_sparseImageOpaqueMemoryBindInfo.bindCount; } + uint32_t& bindCount() + { + return m_sparseImageOpaqueMemoryBindInfo.bindCount; + } + SparseImageOpaqueMemoryBindInfo& bindCount( uint32_t bindCount ) { m_sparseImageOpaqueMemoryBindInfo.bindCount = bindCount; @@ -12448,6 +15178,11 @@ namespace vk return reinterpret_cast( m_sparseImageOpaqueMemoryBindInfo.pBinds ); } + const SparseMemoryBind* pBinds() + { + return reinterpret_cast( m_sparseImageOpaqueMemoryBindInfo.pBinds ); + } + SparseImageOpaqueMemoryBindInfo& pBinds( const SparseMemoryBind* pBinds ) { m_sparseImageOpaqueMemoryBindInfo.pBinds = reinterpret_cast( pBinds ); @@ -12494,6 +15229,11 @@ namespace vk return reinterpret_cast( m_sparseImageMemoryBindInfo.image ); } + Image& image() + { + return reinterpret_cast( m_sparseImageMemoryBindInfo.image ); + } + SparseImageMemoryBindInfo& image( Image image ) { m_sparseImageMemoryBindInfo.image = static_cast( image ); @@ -12505,6 +15245,11 @@ namespace vk return m_sparseImageMemoryBindInfo.bindCount; } + uint32_t& bindCount() + { + return m_sparseImageMemoryBindInfo.bindCount; + } + SparseImageMemoryBindInfo& bindCount( uint32_t bindCount ) { m_sparseImageMemoryBindInfo.bindCount = bindCount; @@ -12516,6 +15261,11 @@ namespace vk return reinterpret_cast( m_sparseImageMemoryBindInfo.pBinds ); } + const SparseImageMemoryBind* pBinds() + { + return reinterpret_cast( m_sparseImageMemoryBindInfo.pBinds ); + } + SparseImageMemoryBindInfo& pBinds( const SparseImageMemoryBind* pBinds ) { m_sparseImageMemoryBindInfo.pBinds = reinterpret_cast( pBinds ); @@ -12571,6 +15321,11 @@ namespace vk return reinterpret_cast( m_bindSparseInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_bindSparseInfo.sType ); + } + BindSparseInfo& sType( StructureType sType ) { m_bindSparseInfo.sType = static_cast( sType ); @@ -12582,6 +15337,11 @@ namespace vk return reinterpret_cast( m_bindSparseInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_bindSparseInfo.pNext ); + } + BindSparseInfo& pNext( const void* pNext ) { m_bindSparseInfo.pNext = pNext; @@ -12593,6 +15353,11 @@ namespace vk return m_bindSparseInfo.waitSemaphoreCount; } + uint32_t& waitSemaphoreCount() + { + return m_bindSparseInfo.waitSemaphoreCount; + } + BindSparseInfo& waitSemaphoreCount( uint32_t waitSemaphoreCount ) { m_bindSparseInfo.waitSemaphoreCount = waitSemaphoreCount; @@ -12604,6 +15369,11 @@ namespace vk return reinterpret_cast( m_bindSparseInfo.pWaitSemaphores ); } + const Semaphore* pWaitSemaphores() + { + return reinterpret_cast( m_bindSparseInfo.pWaitSemaphores ); + } + BindSparseInfo& pWaitSemaphores( const Semaphore* pWaitSemaphores ) { m_bindSparseInfo.pWaitSemaphores = reinterpret_cast( pWaitSemaphores ); @@ -12615,6 +15385,11 @@ namespace vk return m_bindSparseInfo.bufferBindCount; } + uint32_t& bufferBindCount() + { + return m_bindSparseInfo.bufferBindCount; + } + BindSparseInfo& bufferBindCount( uint32_t bufferBindCount ) { m_bindSparseInfo.bufferBindCount = bufferBindCount; @@ -12626,6 +15401,11 @@ namespace vk return reinterpret_cast( m_bindSparseInfo.pBufferBinds ); } + const SparseBufferMemoryBindInfo* pBufferBinds() + { + return reinterpret_cast( m_bindSparseInfo.pBufferBinds ); + } + BindSparseInfo& pBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds ) { m_bindSparseInfo.pBufferBinds = reinterpret_cast( pBufferBinds ); @@ -12637,6 +15417,11 @@ namespace vk return m_bindSparseInfo.imageOpaqueBindCount; } + uint32_t& imageOpaqueBindCount() + { + return m_bindSparseInfo.imageOpaqueBindCount; + } + BindSparseInfo& imageOpaqueBindCount( uint32_t imageOpaqueBindCount ) { m_bindSparseInfo.imageOpaqueBindCount = imageOpaqueBindCount; @@ -12648,6 +15433,11 @@ namespace vk return reinterpret_cast( m_bindSparseInfo.pImageOpaqueBinds ); } + const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds() + { + return reinterpret_cast( m_bindSparseInfo.pImageOpaqueBinds ); + } + BindSparseInfo& pImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds ) { m_bindSparseInfo.pImageOpaqueBinds = reinterpret_cast( pImageOpaqueBinds ); @@ -12659,6 +15449,11 @@ namespace vk return m_bindSparseInfo.imageBindCount; } + uint32_t& imageBindCount() + { + return m_bindSparseInfo.imageBindCount; + } + BindSparseInfo& imageBindCount( uint32_t imageBindCount ) { m_bindSparseInfo.imageBindCount = imageBindCount; @@ -12670,6 +15465,11 @@ namespace vk return reinterpret_cast( m_bindSparseInfo.pImageBinds ); } + const SparseImageMemoryBindInfo* pImageBinds() + { + return reinterpret_cast( m_bindSparseInfo.pImageBinds ); + } + BindSparseInfo& pImageBinds( const SparseImageMemoryBindInfo* pImageBinds ) { m_bindSparseInfo.pImageBinds = reinterpret_cast( pImageBinds ); @@ -12681,6 +15481,11 @@ namespace vk return m_bindSparseInfo.signalSemaphoreCount; } + uint32_t& signalSemaphoreCount() + { + return m_bindSparseInfo.signalSemaphoreCount; + } + BindSparseInfo& signalSemaphoreCount( uint32_t signalSemaphoreCount ) { m_bindSparseInfo.signalSemaphoreCount = signalSemaphoreCount; @@ -12692,6 +15497,11 @@ namespace vk return reinterpret_cast( m_bindSparseInfo.pSignalSemaphores ); } + const Semaphore* pSignalSemaphores() + { + return reinterpret_cast( m_bindSparseInfo.pSignalSemaphores ); + } + BindSparseInfo& pSignalSemaphores( const Semaphore* pSignalSemaphores ) { m_bindSparseInfo.pSignalSemaphores = reinterpret_cast( pSignalSemaphores ); @@ -12780,6 +15590,11 @@ namespace vk return reinterpret_cast( m_commandPoolCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_commandPoolCreateInfo.sType ); + } + CommandPoolCreateInfo& sType( StructureType sType ) { m_commandPoolCreateInfo.sType = static_cast( sType ); @@ -12791,6 +15606,11 @@ namespace vk return reinterpret_cast( m_commandPoolCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_commandPoolCreateInfo.pNext ); + } + CommandPoolCreateInfo& pNext( const void* pNext ) { m_commandPoolCreateInfo.pNext = pNext; @@ -12802,6 +15622,11 @@ namespace vk return reinterpret_cast( m_commandPoolCreateInfo.flags ); } + CommandPoolCreateFlags& flags() + { + return reinterpret_cast( m_commandPoolCreateInfo.flags ); + } + CommandPoolCreateInfo& flags( CommandPoolCreateFlags flags ) { m_commandPoolCreateInfo.flags = static_cast( flags ); @@ -12813,6 +15638,11 @@ namespace vk return m_commandPoolCreateInfo.queueFamilyIndex; } + uint32_t& queueFamilyIndex() + { + return m_commandPoolCreateInfo.queueFamilyIndex; + } + CommandPoolCreateInfo& queueFamilyIndex( uint32_t queueFamilyIndex ) { m_commandPoolCreateInfo.queueFamilyIndex = queueFamilyIndex; @@ -12951,6 +15781,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_imageCreateInfo.sType ); + } + ImageCreateInfo& sType( StructureType sType ) { m_imageCreateInfo.sType = static_cast( sType ); @@ -12962,6 +15797,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_imageCreateInfo.pNext ); + } + ImageCreateInfo& pNext( const void* pNext ) { m_imageCreateInfo.pNext = pNext; @@ -12973,6 +15813,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.flags ); } + ImageCreateFlags& flags() + { + return reinterpret_cast( m_imageCreateInfo.flags ); + } + ImageCreateInfo& flags( ImageCreateFlags flags ) { m_imageCreateInfo.flags = static_cast( flags ); @@ -12984,6 +15829,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.imageType ); } + ImageType& imageType() + { + return reinterpret_cast( m_imageCreateInfo.imageType ); + } + ImageCreateInfo& imageType( ImageType imageType ) { m_imageCreateInfo.imageType = static_cast( imageType ); @@ -12995,6 +15845,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.format ); } + Format& format() + { + return reinterpret_cast( m_imageCreateInfo.format ); + } + ImageCreateInfo& format( Format format ) { m_imageCreateInfo.format = static_cast( format ); @@ -13006,6 +15861,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.extent ); } + Extent3D& extent() + { + return reinterpret_cast( m_imageCreateInfo.extent ); + } + ImageCreateInfo& extent( Extent3D extent ) { m_imageCreateInfo.extent = static_cast( extent ); @@ -13017,6 +15877,11 @@ namespace vk return m_imageCreateInfo.mipLevels; } + uint32_t& mipLevels() + { + return m_imageCreateInfo.mipLevels; + } + ImageCreateInfo& mipLevels( uint32_t mipLevels ) { m_imageCreateInfo.mipLevels = mipLevels; @@ -13028,6 +15893,11 @@ namespace vk return m_imageCreateInfo.arrayLayers; } + uint32_t& arrayLayers() + { + return m_imageCreateInfo.arrayLayers; + } + ImageCreateInfo& arrayLayers( uint32_t arrayLayers ) { m_imageCreateInfo.arrayLayers = arrayLayers; @@ -13039,6 +15909,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.samples ); } + SampleCountFlagBits& samples() + { + return reinterpret_cast( m_imageCreateInfo.samples ); + } + ImageCreateInfo& samples( SampleCountFlagBits samples ) { m_imageCreateInfo.samples = static_cast( samples ); @@ -13050,6 +15925,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.tiling ); } + ImageTiling& tiling() + { + return reinterpret_cast( m_imageCreateInfo.tiling ); + } + ImageCreateInfo& tiling( ImageTiling tiling ) { m_imageCreateInfo.tiling = static_cast( tiling ); @@ -13061,6 +15941,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.usage ); } + ImageUsageFlags& usage() + { + return reinterpret_cast( m_imageCreateInfo.usage ); + } + ImageCreateInfo& usage( ImageUsageFlags usage ) { m_imageCreateInfo.usage = static_cast( usage ); @@ -13072,6 +15957,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.sharingMode ); } + SharingMode& sharingMode() + { + return reinterpret_cast( m_imageCreateInfo.sharingMode ); + } + ImageCreateInfo& sharingMode( SharingMode sharingMode ) { m_imageCreateInfo.sharingMode = static_cast( sharingMode ); @@ -13083,6 +15973,11 @@ namespace vk return m_imageCreateInfo.queueFamilyIndexCount; } + uint32_t& queueFamilyIndexCount() + { + return m_imageCreateInfo.queueFamilyIndexCount; + } + ImageCreateInfo& queueFamilyIndexCount( uint32_t queueFamilyIndexCount ) { m_imageCreateInfo.queueFamilyIndexCount = queueFamilyIndexCount; @@ -13094,6 +15989,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.pQueueFamilyIndices ); } + const uint32_t* pQueueFamilyIndices() + { + return reinterpret_cast( m_imageCreateInfo.pQueueFamilyIndices ); + } + ImageCreateInfo& pQueueFamilyIndices( const uint32_t* pQueueFamilyIndices ) { m_imageCreateInfo.pQueueFamilyIndices = pQueueFamilyIndices; @@ -13105,6 +16005,11 @@ namespace vk return reinterpret_cast( m_imageCreateInfo.initialLayout ); } + ImageLayout& initialLayout() + { + return reinterpret_cast( m_imageCreateInfo.initialLayout ); + } + ImageCreateInfo& initialLayout( ImageLayout initialLayout ) { m_imageCreateInfo.initialLayout = static_cast( initialLayout ); @@ -13157,6 +16062,11 @@ namespace vk return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.sType ); + } + PipelineMultisampleStateCreateInfo& sType( StructureType sType ) { m_pipelineMultisampleStateCreateInfo.sType = static_cast( sType ); @@ -13168,6 +16078,11 @@ namespace vk return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.pNext ); + } + PipelineMultisampleStateCreateInfo& pNext( const void* pNext ) { m_pipelineMultisampleStateCreateInfo.pNext = pNext; @@ -13179,6 +16094,11 @@ namespace vk return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.flags ); } + PipelineMultisampleStateCreateFlags& flags() + { + return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.flags ); + } + PipelineMultisampleStateCreateInfo& flags( PipelineMultisampleStateCreateFlags flags ) { m_pipelineMultisampleStateCreateInfo.flags = static_cast( flags ); @@ -13190,6 +16110,11 @@ namespace vk return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.rasterizationSamples ); } + SampleCountFlagBits& rasterizationSamples() + { + return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.rasterizationSamples ); + } + PipelineMultisampleStateCreateInfo& rasterizationSamples( SampleCountFlagBits rasterizationSamples ) { m_pipelineMultisampleStateCreateInfo.rasterizationSamples = static_cast( rasterizationSamples ); @@ -13201,6 +16126,11 @@ namespace vk return m_pipelineMultisampleStateCreateInfo.sampleShadingEnable; } + Bool32& sampleShadingEnable() + { + return m_pipelineMultisampleStateCreateInfo.sampleShadingEnable; + } + PipelineMultisampleStateCreateInfo& sampleShadingEnable( Bool32 sampleShadingEnable ) { m_pipelineMultisampleStateCreateInfo.sampleShadingEnable = sampleShadingEnable; @@ -13212,6 +16142,11 @@ namespace vk return m_pipelineMultisampleStateCreateInfo.minSampleShading; } + float& minSampleShading() + { + return m_pipelineMultisampleStateCreateInfo.minSampleShading; + } + PipelineMultisampleStateCreateInfo& minSampleShading( float minSampleShading ) { m_pipelineMultisampleStateCreateInfo.minSampleShading = minSampleShading; @@ -13223,6 +16158,11 @@ namespace vk return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.pSampleMask ); } + const SampleMask* pSampleMask() + { + return reinterpret_cast( m_pipelineMultisampleStateCreateInfo.pSampleMask ); + } + PipelineMultisampleStateCreateInfo& pSampleMask( const SampleMask* pSampleMask ) { m_pipelineMultisampleStateCreateInfo.pSampleMask = pSampleMask; @@ -13234,6 +16174,11 @@ namespace vk return m_pipelineMultisampleStateCreateInfo.alphaToCoverageEnable; } + Bool32& alphaToCoverageEnable() + { + return m_pipelineMultisampleStateCreateInfo.alphaToCoverageEnable; + } + PipelineMultisampleStateCreateInfo& alphaToCoverageEnable( Bool32 alphaToCoverageEnable ) { m_pipelineMultisampleStateCreateInfo.alphaToCoverageEnable = alphaToCoverageEnable; @@ -13245,6 +16190,11 @@ namespace vk return m_pipelineMultisampleStateCreateInfo.alphaToOneEnable; } + Bool32& alphaToOneEnable() + { + return m_pipelineMultisampleStateCreateInfo.alphaToOneEnable; + } + PipelineMultisampleStateCreateInfo& alphaToOneEnable( Bool32 alphaToOneEnable ) { m_pipelineMultisampleStateCreateInfo.alphaToOneEnable = alphaToOneEnable; @@ -13307,6 +16257,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.sType ); + } + GraphicsPipelineCreateInfo& sType( StructureType sType ) { m_graphicsPipelineCreateInfo.sType = static_cast( sType ); @@ -13318,6 +16273,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pNext ); + } + GraphicsPipelineCreateInfo& pNext( const void* pNext ) { m_graphicsPipelineCreateInfo.pNext = pNext; @@ -13329,6 +16289,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.flags ); } + PipelineCreateFlags& flags() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.flags ); + } + GraphicsPipelineCreateInfo& flags( PipelineCreateFlags flags ) { m_graphicsPipelineCreateInfo.flags = static_cast( flags ); @@ -13340,6 +16305,11 @@ namespace vk return m_graphicsPipelineCreateInfo.stageCount; } + uint32_t& stageCount() + { + return m_graphicsPipelineCreateInfo.stageCount; + } + GraphicsPipelineCreateInfo& stageCount( uint32_t stageCount ) { m_graphicsPipelineCreateInfo.stageCount = stageCount; @@ -13351,6 +16321,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pStages ); } + const PipelineShaderStageCreateInfo* pStages() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pStages ); + } + GraphicsPipelineCreateInfo& pStages( const PipelineShaderStageCreateInfo* pStages ) { m_graphicsPipelineCreateInfo.pStages = reinterpret_cast( pStages ); @@ -13362,6 +16337,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pVertexInputState ); } + const PipelineVertexInputStateCreateInfo* pVertexInputState() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pVertexInputState ); + } + GraphicsPipelineCreateInfo& pVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState ) { m_graphicsPipelineCreateInfo.pVertexInputState = reinterpret_cast( pVertexInputState ); @@ -13373,6 +16353,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pInputAssemblyState ); } + const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pInputAssemblyState ); + } + GraphicsPipelineCreateInfo& pInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState ) { m_graphicsPipelineCreateInfo.pInputAssemblyState = reinterpret_cast( pInputAssemblyState ); @@ -13384,6 +16369,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pTessellationState ); } + const PipelineTessellationStateCreateInfo* pTessellationState() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pTessellationState ); + } + GraphicsPipelineCreateInfo& pTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState ) { m_graphicsPipelineCreateInfo.pTessellationState = reinterpret_cast( pTessellationState ); @@ -13395,6 +16385,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pViewportState ); } + const PipelineViewportStateCreateInfo* pViewportState() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pViewportState ); + } + GraphicsPipelineCreateInfo& pViewportState( const PipelineViewportStateCreateInfo* pViewportState ) { m_graphicsPipelineCreateInfo.pViewportState = reinterpret_cast( pViewportState ); @@ -13406,6 +16401,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pRasterizationState ); } + const PipelineRasterizationStateCreateInfo* pRasterizationState() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pRasterizationState ); + } + GraphicsPipelineCreateInfo& pRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState ) { m_graphicsPipelineCreateInfo.pRasterizationState = reinterpret_cast( pRasterizationState ); @@ -13417,6 +16417,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pMultisampleState ); } + const PipelineMultisampleStateCreateInfo* pMultisampleState() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pMultisampleState ); + } + GraphicsPipelineCreateInfo& pMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState ) { m_graphicsPipelineCreateInfo.pMultisampleState = reinterpret_cast( pMultisampleState ); @@ -13428,6 +16433,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pDepthStencilState ); } + const PipelineDepthStencilStateCreateInfo* pDepthStencilState() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pDepthStencilState ); + } + GraphicsPipelineCreateInfo& pDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState ) { m_graphicsPipelineCreateInfo.pDepthStencilState = reinterpret_cast( pDepthStencilState ); @@ -13439,6 +16449,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pColorBlendState ); } + const PipelineColorBlendStateCreateInfo* pColorBlendState() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pColorBlendState ); + } + GraphicsPipelineCreateInfo& pColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState ) { m_graphicsPipelineCreateInfo.pColorBlendState = reinterpret_cast( pColorBlendState ); @@ -13450,6 +16465,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.pDynamicState ); } + const PipelineDynamicStateCreateInfo* pDynamicState() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.pDynamicState ); + } + GraphicsPipelineCreateInfo& pDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState ) { m_graphicsPipelineCreateInfo.pDynamicState = reinterpret_cast( pDynamicState ); @@ -13461,6 +16481,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.layout ); } + PipelineLayout& layout() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.layout ); + } + GraphicsPipelineCreateInfo& layout( PipelineLayout layout ) { m_graphicsPipelineCreateInfo.layout = static_cast( layout ); @@ -13472,6 +16497,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.renderPass ); } + RenderPass& renderPass() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.renderPass ); + } + GraphicsPipelineCreateInfo& renderPass( RenderPass renderPass ) { m_graphicsPipelineCreateInfo.renderPass = static_cast( renderPass ); @@ -13483,6 +16513,11 @@ namespace vk return m_graphicsPipelineCreateInfo.subpass; } + uint32_t& subpass() + { + return m_graphicsPipelineCreateInfo.subpass; + } + GraphicsPipelineCreateInfo& subpass( uint32_t subpass ) { m_graphicsPipelineCreateInfo.subpass = subpass; @@ -13494,6 +16529,11 @@ namespace vk return reinterpret_cast( m_graphicsPipelineCreateInfo.basePipelineHandle ); } + Pipeline& basePipelineHandle() + { + return reinterpret_cast( m_graphicsPipelineCreateInfo.basePipelineHandle ); + } + GraphicsPipelineCreateInfo& basePipelineHandle( Pipeline basePipelineHandle ) { m_graphicsPipelineCreateInfo.basePipelineHandle = static_cast( basePipelineHandle ); @@ -13505,6 +16545,11 @@ namespace vk return m_graphicsPipelineCreateInfo.basePipelineIndex; } + int32_t& basePipelineIndex() + { + return m_graphicsPipelineCreateInfo.basePipelineIndex; + } + GraphicsPipelineCreateInfo& basePipelineIndex( int32_t basePipelineIndex ) { m_graphicsPipelineCreateInfo.basePipelineIndex = basePipelineIndex; @@ -14170,6 +17215,11 @@ namespace vk return reinterpret_cast( m_attachmentDescription.flags ); } + AttachmentDescriptionFlags& flags() + { + return reinterpret_cast( m_attachmentDescription.flags ); + } + AttachmentDescription& flags( AttachmentDescriptionFlags flags ) { m_attachmentDescription.flags = static_cast( flags ); @@ -14181,6 +17231,11 @@ namespace vk return reinterpret_cast( m_attachmentDescription.format ); } + Format& format() + { + return reinterpret_cast( m_attachmentDescription.format ); + } + AttachmentDescription& format( Format format ) { m_attachmentDescription.format = static_cast( format ); @@ -14192,6 +17247,11 @@ namespace vk return reinterpret_cast( m_attachmentDescription.samples ); } + SampleCountFlagBits& samples() + { + return reinterpret_cast( m_attachmentDescription.samples ); + } + AttachmentDescription& samples( SampleCountFlagBits samples ) { m_attachmentDescription.samples = static_cast( samples ); @@ -14203,6 +17263,11 @@ namespace vk return reinterpret_cast( m_attachmentDescription.loadOp ); } + AttachmentLoadOp& loadOp() + { + return reinterpret_cast( m_attachmentDescription.loadOp ); + } + AttachmentDescription& loadOp( AttachmentLoadOp loadOp ) { m_attachmentDescription.loadOp = static_cast( loadOp ); @@ -14214,6 +17279,11 @@ namespace vk return reinterpret_cast( m_attachmentDescription.storeOp ); } + AttachmentStoreOp& storeOp() + { + return reinterpret_cast( m_attachmentDescription.storeOp ); + } + AttachmentDescription& storeOp( AttachmentStoreOp storeOp ) { m_attachmentDescription.storeOp = static_cast( storeOp ); @@ -14225,6 +17295,11 @@ namespace vk return reinterpret_cast( m_attachmentDescription.stencilLoadOp ); } + AttachmentLoadOp& stencilLoadOp() + { + return reinterpret_cast( m_attachmentDescription.stencilLoadOp ); + } + AttachmentDescription& stencilLoadOp( AttachmentLoadOp stencilLoadOp ) { m_attachmentDescription.stencilLoadOp = static_cast( stencilLoadOp ); @@ -14236,6 +17311,11 @@ namespace vk return reinterpret_cast( m_attachmentDescription.stencilStoreOp ); } + AttachmentStoreOp& stencilStoreOp() + { + return reinterpret_cast( m_attachmentDescription.stencilStoreOp ); + } + AttachmentDescription& stencilStoreOp( AttachmentStoreOp stencilStoreOp ) { m_attachmentDescription.stencilStoreOp = static_cast( stencilStoreOp ); @@ -14247,6 +17327,11 @@ namespace vk return reinterpret_cast( m_attachmentDescription.initialLayout ); } + ImageLayout& initialLayout() + { + return reinterpret_cast( m_attachmentDescription.initialLayout ); + } + AttachmentDescription& initialLayout( ImageLayout initialLayout ) { m_attachmentDescription.initialLayout = static_cast( initialLayout ); @@ -14258,6 +17343,11 @@ namespace vk return reinterpret_cast( m_attachmentDescription.finalLayout ); } + ImageLayout& finalLayout() + { + return reinterpret_cast( m_attachmentDescription.finalLayout ); + } + AttachmentDescription& finalLayout( ImageLayout finalLayout ) { m_attachmentDescription.finalLayout = static_cast( finalLayout ); @@ -14333,6 +17423,11 @@ namespace vk return reinterpret_cast( m_descriptorPoolCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_descriptorPoolCreateInfo.sType ); + } + DescriptorPoolCreateInfo& sType( StructureType sType ) { m_descriptorPoolCreateInfo.sType = static_cast( sType ); @@ -14344,6 +17439,11 @@ namespace vk return reinterpret_cast( m_descriptorPoolCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_descriptorPoolCreateInfo.pNext ); + } + DescriptorPoolCreateInfo& pNext( const void* pNext ) { m_descriptorPoolCreateInfo.pNext = pNext; @@ -14355,6 +17455,11 @@ namespace vk return reinterpret_cast( m_descriptorPoolCreateInfo.flags ); } + DescriptorPoolCreateFlags& flags() + { + return reinterpret_cast( m_descriptorPoolCreateInfo.flags ); + } + DescriptorPoolCreateInfo& flags( DescriptorPoolCreateFlags flags ) { m_descriptorPoolCreateInfo.flags = static_cast( flags ); @@ -14366,6 +17471,11 @@ namespace vk return m_descriptorPoolCreateInfo.maxSets; } + uint32_t& maxSets() + { + return m_descriptorPoolCreateInfo.maxSets; + } + DescriptorPoolCreateInfo& maxSets( uint32_t maxSets ) { m_descriptorPoolCreateInfo.maxSets = maxSets; @@ -14377,6 +17487,11 @@ namespace vk return m_descriptorPoolCreateInfo.poolSizeCount; } + uint32_t& poolSizeCount() + { + return m_descriptorPoolCreateInfo.poolSizeCount; + } + DescriptorPoolCreateInfo& poolSizeCount( uint32_t poolSizeCount ) { m_descriptorPoolCreateInfo.poolSizeCount = poolSizeCount; @@ -14388,6 +17503,11 @@ namespace vk return reinterpret_cast( m_descriptorPoolCreateInfo.pPoolSizes ); } + const DescriptorPoolSize* pPoolSizes() + { + return reinterpret_cast( m_descriptorPoolCreateInfo.pPoolSizes ); + } + DescriptorPoolCreateInfo& pPoolSizes( const DescriptorPoolSize* pPoolSizes ) { m_descriptorPoolCreateInfo.pPoolSizes = reinterpret_cast( pPoolSizes ); @@ -14747,6 +17867,11 @@ namespace vk return m_subpassDependency.srcSubpass; } + uint32_t& srcSubpass() + { + return m_subpassDependency.srcSubpass; + } + SubpassDependency& srcSubpass( uint32_t srcSubpass ) { m_subpassDependency.srcSubpass = srcSubpass; @@ -14758,6 +17883,11 @@ namespace vk return m_subpassDependency.dstSubpass; } + uint32_t& dstSubpass() + { + return m_subpassDependency.dstSubpass; + } + SubpassDependency& dstSubpass( uint32_t dstSubpass ) { m_subpassDependency.dstSubpass = dstSubpass; @@ -14769,6 +17899,11 @@ namespace vk return reinterpret_cast( m_subpassDependency.srcStageMask ); } + PipelineStageFlags& srcStageMask() + { + return reinterpret_cast( m_subpassDependency.srcStageMask ); + } + SubpassDependency& srcStageMask( PipelineStageFlags srcStageMask ) { m_subpassDependency.srcStageMask = static_cast( srcStageMask ); @@ -14780,6 +17915,11 @@ namespace vk return reinterpret_cast( m_subpassDependency.dstStageMask ); } + PipelineStageFlags& dstStageMask() + { + return reinterpret_cast( m_subpassDependency.dstStageMask ); + } + SubpassDependency& dstStageMask( PipelineStageFlags dstStageMask ) { m_subpassDependency.dstStageMask = static_cast( dstStageMask ); @@ -14791,6 +17931,11 @@ namespace vk return reinterpret_cast( m_subpassDependency.srcAccessMask ); } + AccessFlags& srcAccessMask() + { + return reinterpret_cast( m_subpassDependency.srcAccessMask ); + } + SubpassDependency& srcAccessMask( AccessFlags srcAccessMask ) { m_subpassDependency.srcAccessMask = static_cast( srcAccessMask ); @@ -14802,6 +17947,11 @@ namespace vk return reinterpret_cast( m_subpassDependency.dstAccessMask ); } + AccessFlags& dstAccessMask() + { + return reinterpret_cast( m_subpassDependency.dstAccessMask ); + } + SubpassDependency& dstAccessMask( AccessFlags dstAccessMask ) { m_subpassDependency.dstAccessMask = static_cast( dstAccessMask ); @@ -14813,6 +17963,11 @@ namespace vk return reinterpret_cast( m_subpassDependency.dependencyFlags ); } + DependencyFlags& dependencyFlags() + { + return reinterpret_cast( m_subpassDependency.dependencyFlags ); + } + SubpassDependency& dependencyFlags( DependencyFlags dependencyFlags ) { m_subpassDependency.dependencyFlags = static_cast( dependencyFlags ); @@ -14865,6 +18020,11 @@ namespace vk return reinterpret_cast( m_renderPassCreateInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_renderPassCreateInfo.sType ); + } + RenderPassCreateInfo& sType( StructureType sType ) { m_renderPassCreateInfo.sType = static_cast( sType ); @@ -14876,6 +18036,11 @@ namespace vk return reinterpret_cast( m_renderPassCreateInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_renderPassCreateInfo.pNext ); + } + RenderPassCreateInfo& pNext( const void* pNext ) { m_renderPassCreateInfo.pNext = pNext; @@ -14887,6 +18052,11 @@ namespace vk return reinterpret_cast( m_renderPassCreateInfo.flags ); } + RenderPassCreateFlags& flags() + { + return reinterpret_cast( m_renderPassCreateInfo.flags ); + } + RenderPassCreateInfo& flags( RenderPassCreateFlags flags ) { m_renderPassCreateInfo.flags = static_cast( flags ); @@ -14898,6 +18068,11 @@ namespace vk return m_renderPassCreateInfo.attachmentCount; } + uint32_t& attachmentCount() + { + return m_renderPassCreateInfo.attachmentCount; + } + RenderPassCreateInfo& attachmentCount( uint32_t attachmentCount ) { m_renderPassCreateInfo.attachmentCount = attachmentCount; @@ -14909,6 +18084,11 @@ namespace vk return reinterpret_cast( m_renderPassCreateInfo.pAttachments ); } + const AttachmentDescription* pAttachments() + { + return reinterpret_cast( m_renderPassCreateInfo.pAttachments ); + } + RenderPassCreateInfo& pAttachments( const AttachmentDescription* pAttachments ) { m_renderPassCreateInfo.pAttachments = reinterpret_cast( pAttachments ); @@ -14920,6 +18100,11 @@ namespace vk return m_renderPassCreateInfo.subpassCount; } + uint32_t& subpassCount() + { + return m_renderPassCreateInfo.subpassCount; + } + RenderPassCreateInfo& subpassCount( uint32_t subpassCount ) { m_renderPassCreateInfo.subpassCount = subpassCount; @@ -14931,6 +18116,11 @@ namespace vk return reinterpret_cast( m_renderPassCreateInfo.pSubpasses ); } + const SubpassDescription* pSubpasses() + { + return reinterpret_cast( m_renderPassCreateInfo.pSubpasses ); + } + RenderPassCreateInfo& pSubpasses( const SubpassDescription* pSubpasses ) { m_renderPassCreateInfo.pSubpasses = reinterpret_cast( pSubpasses ); @@ -14942,6 +18132,11 @@ namespace vk return m_renderPassCreateInfo.dependencyCount; } + uint32_t& dependencyCount() + { + return m_renderPassCreateInfo.dependencyCount; + } + RenderPassCreateInfo& dependencyCount( uint32_t dependencyCount ) { m_renderPassCreateInfo.dependencyCount = dependencyCount; @@ -14953,6 +18148,11 @@ namespace vk return reinterpret_cast( m_renderPassCreateInfo.pDependencies ); } + const SubpassDependency* pDependencies() + { + return reinterpret_cast( m_renderPassCreateInfo.pDependencies ); + } + RenderPassCreateInfo& pDependencies( const SubpassDependency* pDependencies ) { m_renderPassCreateInfo.pDependencies = reinterpret_cast( pDependencies ); @@ -15005,6 +18205,11 @@ namespace vk return reinterpret_cast( m_submitInfo.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_submitInfo.sType ); + } + SubmitInfo& sType( StructureType sType ) { m_submitInfo.sType = static_cast( sType ); @@ -15016,6 +18221,11 @@ namespace vk return reinterpret_cast( m_submitInfo.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_submitInfo.pNext ); + } + SubmitInfo& pNext( const void* pNext ) { m_submitInfo.pNext = pNext; @@ -15027,6 +18237,11 @@ namespace vk return m_submitInfo.waitSemaphoreCount; } + uint32_t& waitSemaphoreCount() + { + return m_submitInfo.waitSemaphoreCount; + } + SubmitInfo& waitSemaphoreCount( uint32_t waitSemaphoreCount ) { m_submitInfo.waitSemaphoreCount = waitSemaphoreCount; @@ -15038,6 +18253,11 @@ namespace vk return reinterpret_cast( m_submitInfo.pWaitSemaphores ); } + const Semaphore* pWaitSemaphores() + { + return reinterpret_cast( m_submitInfo.pWaitSemaphores ); + } + SubmitInfo& pWaitSemaphores( const Semaphore* pWaitSemaphores ) { m_submitInfo.pWaitSemaphores = reinterpret_cast( pWaitSemaphores ); @@ -15049,6 +18269,11 @@ namespace vk return reinterpret_cast( m_submitInfo.pWaitDstStageMask ); } + const PipelineStageFlags* pWaitDstStageMask() + { + return reinterpret_cast( m_submitInfo.pWaitDstStageMask ); + } + SubmitInfo& pWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask ) { m_submitInfo.pWaitDstStageMask = reinterpret_cast( pWaitDstStageMask ); @@ -15060,6 +18285,11 @@ namespace vk return m_submitInfo.commandBufferCount; } + uint32_t& commandBufferCount() + { + return m_submitInfo.commandBufferCount; + } + SubmitInfo& commandBufferCount( uint32_t commandBufferCount ) { m_submitInfo.commandBufferCount = commandBufferCount; @@ -15071,6 +18301,11 @@ namespace vk return reinterpret_cast( m_submitInfo.pCommandBuffers ); } + const CommandBuffer* pCommandBuffers() + { + return reinterpret_cast( m_submitInfo.pCommandBuffers ); + } + SubmitInfo& pCommandBuffers( const CommandBuffer* pCommandBuffers ) { m_submitInfo.pCommandBuffers = reinterpret_cast( pCommandBuffers ); @@ -15082,6 +18317,11 @@ namespace vk return m_submitInfo.signalSemaphoreCount; } + uint32_t& signalSemaphoreCount() + { + return m_submitInfo.signalSemaphoreCount; + } + SubmitInfo& signalSemaphoreCount( uint32_t signalSemaphoreCount ) { m_submitInfo.signalSemaphoreCount = signalSemaphoreCount; @@ -15093,6 +18333,11 @@ namespace vk return reinterpret_cast( m_submitInfo.pSignalSemaphores ); } + const Semaphore* pSignalSemaphores() + { + return reinterpret_cast( m_submitInfo.pSignalSemaphores ); + } + SubmitInfo& pSignalSemaphores( const Semaphore* pSignalSemaphores ) { m_submitInfo.pSignalSemaphores = reinterpret_cast( pSignalSemaphores ); @@ -15232,6 +18477,11 @@ namespace vk return reinterpret_cast( m_surfaceFormatKHR.format ); } + Format& format() + { + return reinterpret_cast( m_surfaceFormatKHR.format ); + } + SurfaceFormatKHR& format( Format format ) { m_surfaceFormatKHR.format = static_cast( format ); @@ -15243,6 +18493,11 @@ namespace vk return reinterpret_cast( m_surfaceFormatKHR.colorSpace ); } + ColorSpaceKHR& colorSpace() + { + return reinterpret_cast( m_surfaceFormatKHR.colorSpace ); + } + SurfaceFormatKHR& colorSpace( ColorSpaceKHR colorSpace ) { m_surfaceFormatKHR.colorSpace = static_cast( colorSpace ); @@ -15310,6 +18565,11 @@ namespace vk return reinterpret_cast( m_displayPlaneCapabilitiesKHR.supportedAlpha ); } + DisplayPlaneAlphaFlagsKHR& supportedAlpha() + { + return reinterpret_cast( m_displayPlaneCapabilitiesKHR.supportedAlpha ); + } + DisplayPlaneCapabilitiesKHR& supportedAlpha( DisplayPlaneAlphaFlagsKHR supportedAlpha ) { m_displayPlaneCapabilitiesKHR.supportedAlpha = static_cast( supportedAlpha ); @@ -15321,6 +18581,11 @@ namespace vk return reinterpret_cast( m_displayPlaneCapabilitiesKHR.minSrcPosition ); } + Offset2D& minSrcPosition() + { + return reinterpret_cast( m_displayPlaneCapabilitiesKHR.minSrcPosition ); + } + DisplayPlaneCapabilitiesKHR& minSrcPosition( Offset2D minSrcPosition ) { m_displayPlaneCapabilitiesKHR.minSrcPosition = static_cast( minSrcPosition ); @@ -15332,6 +18597,11 @@ namespace vk return reinterpret_cast( m_displayPlaneCapabilitiesKHR.maxSrcPosition ); } + Offset2D& maxSrcPosition() + { + return reinterpret_cast( m_displayPlaneCapabilitiesKHR.maxSrcPosition ); + } + DisplayPlaneCapabilitiesKHR& maxSrcPosition( Offset2D maxSrcPosition ) { m_displayPlaneCapabilitiesKHR.maxSrcPosition = static_cast( maxSrcPosition ); @@ -15343,6 +18613,11 @@ namespace vk return reinterpret_cast( m_displayPlaneCapabilitiesKHR.minSrcExtent ); } + Extent2D& minSrcExtent() + { + return reinterpret_cast( m_displayPlaneCapabilitiesKHR.minSrcExtent ); + } + DisplayPlaneCapabilitiesKHR& minSrcExtent( Extent2D minSrcExtent ) { m_displayPlaneCapabilitiesKHR.minSrcExtent = static_cast( minSrcExtent ); @@ -15354,6 +18629,11 @@ namespace vk return reinterpret_cast( m_displayPlaneCapabilitiesKHR.maxSrcExtent ); } + Extent2D& maxSrcExtent() + { + return reinterpret_cast( m_displayPlaneCapabilitiesKHR.maxSrcExtent ); + } + DisplayPlaneCapabilitiesKHR& maxSrcExtent( Extent2D maxSrcExtent ) { m_displayPlaneCapabilitiesKHR.maxSrcExtent = static_cast( maxSrcExtent ); @@ -15365,6 +18645,11 @@ namespace vk return reinterpret_cast( m_displayPlaneCapabilitiesKHR.minDstPosition ); } + Offset2D& minDstPosition() + { + return reinterpret_cast( m_displayPlaneCapabilitiesKHR.minDstPosition ); + } + DisplayPlaneCapabilitiesKHR& minDstPosition( Offset2D minDstPosition ) { m_displayPlaneCapabilitiesKHR.minDstPosition = static_cast( minDstPosition ); @@ -15376,6 +18661,11 @@ namespace vk return reinterpret_cast( m_displayPlaneCapabilitiesKHR.maxDstPosition ); } + Offset2D& maxDstPosition() + { + return reinterpret_cast( m_displayPlaneCapabilitiesKHR.maxDstPosition ); + } + DisplayPlaneCapabilitiesKHR& maxDstPosition( Offset2D maxDstPosition ) { m_displayPlaneCapabilitiesKHR.maxDstPosition = static_cast( maxDstPosition ); @@ -15387,6 +18677,11 @@ namespace vk return reinterpret_cast( m_displayPlaneCapabilitiesKHR.minDstExtent ); } + Extent2D& minDstExtent() + { + return reinterpret_cast( m_displayPlaneCapabilitiesKHR.minDstExtent ); + } + DisplayPlaneCapabilitiesKHR& minDstExtent( Extent2D minDstExtent ) { m_displayPlaneCapabilitiesKHR.minDstExtent = static_cast( minDstExtent ); @@ -15398,6 +18693,11 @@ namespace vk return reinterpret_cast( m_displayPlaneCapabilitiesKHR.maxDstExtent ); } + Extent2D& maxDstExtent() + { + return reinterpret_cast( m_displayPlaneCapabilitiesKHR.maxDstExtent ); + } + DisplayPlaneCapabilitiesKHR& maxDstExtent( Extent2D maxDstExtent ) { m_displayPlaneCapabilitiesKHR.maxDstExtent = static_cast( maxDstExtent ); @@ -15483,6 +18783,11 @@ namespace vk return reinterpret_cast( m_displayPropertiesKHR.display ); } + DisplayKHR& display() + { + return reinterpret_cast( m_displayPropertiesKHR.display ); + } + DisplayPropertiesKHR& display( DisplayKHR display ) { m_displayPropertiesKHR.display = static_cast( display ); @@ -15494,6 +18799,11 @@ namespace vk return reinterpret_cast( m_displayPropertiesKHR.displayName ); } + const char* displayName() + { + return reinterpret_cast( m_displayPropertiesKHR.displayName ); + } + DisplayPropertiesKHR& displayName( const char* displayName ) { m_displayPropertiesKHR.displayName = displayName; @@ -15505,6 +18815,11 @@ namespace vk return reinterpret_cast( m_displayPropertiesKHR.physicalDimensions ); } + Extent2D& physicalDimensions() + { + return reinterpret_cast( m_displayPropertiesKHR.physicalDimensions ); + } + DisplayPropertiesKHR& physicalDimensions( Extent2D physicalDimensions ) { m_displayPropertiesKHR.physicalDimensions = static_cast( physicalDimensions ); @@ -15516,6 +18831,11 @@ namespace vk return reinterpret_cast( m_displayPropertiesKHR.physicalResolution ); } + Extent2D& physicalResolution() + { + return reinterpret_cast( m_displayPropertiesKHR.physicalResolution ); + } + DisplayPropertiesKHR& physicalResolution( Extent2D physicalResolution ) { m_displayPropertiesKHR.physicalResolution = static_cast( physicalResolution ); @@ -15527,6 +18847,11 @@ namespace vk return reinterpret_cast( m_displayPropertiesKHR.supportedTransforms ); } + SurfaceTransformFlagsKHR& supportedTransforms() + { + return reinterpret_cast( m_displayPropertiesKHR.supportedTransforms ); + } + DisplayPropertiesKHR& supportedTransforms( SurfaceTransformFlagsKHR supportedTransforms ) { m_displayPropertiesKHR.supportedTransforms = static_cast( supportedTransforms ); @@ -15538,6 +18863,11 @@ namespace vk return m_displayPropertiesKHR.planeReorderPossible; } + Bool32& planeReorderPossible() + { + return m_displayPropertiesKHR.planeReorderPossible; + } + DisplayPropertiesKHR& planeReorderPossible( Bool32 planeReorderPossible ) { m_displayPropertiesKHR.planeReorderPossible = planeReorderPossible; @@ -15549,6 +18879,11 @@ namespace vk return m_displayPropertiesKHR.persistentContent; } + Bool32& persistentContent() + { + return m_displayPropertiesKHR.persistentContent; + } + DisplayPropertiesKHR& persistentContent( Bool32 persistentContent ) { m_displayPropertiesKHR.persistentContent = persistentContent; @@ -15602,6 +18937,11 @@ namespace vk return reinterpret_cast( m_displaySurfaceCreateInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_displaySurfaceCreateInfoKHR.sType ); + } + DisplaySurfaceCreateInfoKHR& sType( StructureType sType ) { m_displaySurfaceCreateInfoKHR.sType = static_cast( sType ); @@ -15613,6 +18953,11 @@ namespace vk return reinterpret_cast( m_displaySurfaceCreateInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_displaySurfaceCreateInfoKHR.pNext ); + } + DisplaySurfaceCreateInfoKHR& pNext( const void* pNext ) { m_displaySurfaceCreateInfoKHR.pNext = pNext; @@ -15624,6 +18969,11 @@ namespace vk return reinterpret_cast( m_displaySurfaceCreateInfoKHR.flags ); } + DisplaySurfaceCreateFlagsKHR& flags() + { + return reinterpret_cast( m_displaySurfaceCreateInfoKHR.flags ); + } + DisplaySurfaceCreateInfoKHR& flags( DisplaySurfaceCreateFlagsKHR flags ) { m_displaySurfaceCreateInfoKHR.flags = static_cast( flags ); @@ -15635,6 +18985,11 @@ namespace vk return reinterpret_cast( m_displaySurfaceCreateInfoKHR.displayMode ); } + DisplayModeKHR& displayMode() + { + return reinterpret_cast( m_displaySurfaceCreateInfoKHR.displayMode ); + } + DisplaySurfaceCreateInfoKHR& displayMode( DisplayModeKHR displayMode ) { m_displaySurfaceCreateInfoKHR.displayMode = static_cast( displayMode ); @@ -15646,6 +19001,11 @@ namespace vk return m_displaySurfaceCreateInfoKHR.planeIndex; } + uint32_t& planeIndex() + { + return m_displaySurfaceCreateInfoKHR.planeIndex; + } + DisplaySurfaceCreateInfoKHR& planeIndex( uint32_t planeIndex ) { m_displaySurfaceCreateInfoKHR.planeIndex = planeIndex; @@ -15657,6 +19017,11 @@ namespace vk return m_displaySurfaceCreateInfoKHR.planeStackIndex; } + uint32_t& planeStackIndex() + { + return m_displaySurfaceCreateInfoKHR.planeStackIndex; + } + DisplaySurfaceCreateInfoKHR& planeStackIndex( uint32_t planeStackIndex ) { m_displaySurfaceCreateInfoKHR.planeStackIndex = planeStackIndex; @@ -15668,6 +19033,11 @@ namespace vk return reinterpret_cast( m_displaySurfaceCreateInfoKHR.transform ); } + SurfaceTransformFlagBitsKHR& transform() + { + return reinterpret_cast( m_displaySurfaceCreateInfoKHR.transform ); + } + DisplaySurfaceCreateInfoKHR& transform( SurfaceTransformFlagBitsKHR transform ) { m_displaySurfaceCreateInfoKHR.transform = static_cast( transform ); @@ -15679,6 +19049,11 @@ namespace vk return m_displaySurfaceCreateInfoKHR.globalAlpha; } + float& globalAlpha() + { + return m_displaySurfaceCreateInfoKHR.globalAlpha; + } + DisplaySurfaceCreateInfoKHR& globalAlpha( float globalAlpha ) { m_displaySurfaceCreateInfoKHR.globalAlpha = globalAlpha; @@ -15690,6 +19065,11 @@ namespace vk return reinterpret_cast( m_displaySurfaceCreateInfoKHR.alphaMode ); } + DisplayPlaneAlphaFlagBitsKHR& alphaMode() + { + return reinterpret_cast( m_displaySurfaceCreateInfoKHR.alphaMode ); + } + DisplaySurfaceCreateInfoKHR& alphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode ) { m_displaySurfaceCreateInfoKHR.alphaMode = static_cast( alphaMode ); @@ -15701,6 +19081,11 @@ namespace vk return reinterpret_cast( m_displaySurfaceCreateInfoKHR.imageExtent ); } + Extent2D& imageExtent() + { + return reinterpret_cast( m_displaySurfaceCreateInfoKHR.imageExtent ); + } + DisplaySurfaceCreateInfoKHR& imageExtent( Extent2D imageExtent ) { m_displaySurfaceCreateInfoKHR.imageExtent = static_cast( imageExtent ); @@ -15754,6 +19139,11 @@ namespace vk return m_surfaceCapabilitiesKHR.minImageCount; } + uint32_t& minImageCount() + { + return m_surfaceCapabilitiesKHR.minImageCount; + } + SurfaceCapabilitiesKHR& minImageCount( uint32_t minImageCount ) { m_surfaceCapabilitiesKHR.minImageCount = minImageCount; @@ -15765,6 +19155,11 @@ namespace vk return m_surfaceCapabilitiesKHR.maxImageCount; } + uint32_t& maxImageCount() + { + return m_surfaceCapabilitiesKHR.maxImageCount; + } + SurfaceCapabilitiesKHR& maxImageCount( uint32_t maxImageCount ) { m_surfaceCapabilitiesKHR.maxImageCount = maxImageCount; @@ -15776,6 +19171,11 @@ namespace vk return reinterpret_cast( m_surfaceCapabilitiesKHR.currentExtent ); } + Extent2D& currentExtent() + { + return reinterpret_cast( m_surfaceCapabilitiesKHR.currentExtent ); + } + SurfaceCapabilitiesKHR& currentExtent( Extent2D currentExtent ) { m_surfaceCapabilitiesKHR.currentExtent = static_cast( currentExtent ); @@ -15787,6 +19187,11 @@ namespace vk return reinterpret_cast( m_surfaceCapabilitiesKHR.minImageExtent ); } + Extent2D& minImageExtent() + { + return reinterpret_cast( m_surfaceCapabilitiesKHR.minImageExtent ); + } + SurfaceCapabilitiesKHR& minImageExtent( Extent2D minImageExtent ) { m_surfaceCapabilitiesKHR.minImageExtent = static_cast( minImageExtent ); @@ -15798,6 +19203,11 @@ namespace vk return reinterpret_cast( m_surfaceCapabilitiesKHR.maxImageExtent ); } + Extent2D& maxImageExtent() + { + return reinterpret_cast( m_surfaceCapabilitiesKHR.maxImageExtent ); + } + SurfaceCapabilitiesKHR& maxImageExtent( Extent2D maxImageExtent ) { m_surfaceCapabilitiesKHR.maxImageExtent = static_cast( maxImageExtent ); @@ -15809,6 +19219,11 @@ namespace vk return m_surfaceCapabilitiesKHR.maxImageArrayLayers; } + uint32_t& maxImageArrayLayers() + { + return m_surfaceCapabilitiesKHR.maxImageArrayLayers; + } + SurfaceCapabilitiesKHR& maxImageArrayLayers( uint32_t maxImageArrayLayers ) { m_surfaceCapabilitiesKHR.maxImageArrayLayers = maxImageArrayLayers; @@ -15820,6 +19235,11 @@ namespace vk return reinterpret_cast( m_surfaceCapabilitiesKHR.supportedTransforms ); } + SurfaceTransformFlagsKHR& supportedTransforms() + { + return reinterpret_cast( m_surfaceCapabilitiesKHR.supportedTransforms ); + } + SurfaceCapabilitiesKHR& supportedTransforms( SurfaceTransformFlagsKHR supportedTransforms ) { m_surfaceCapabilitiesKHR.supportedTransforms = static_cast( supportedTransforms ); @@ -15831,6 +19251,11 @@ namespace vk return reinterpret_cast( m_surfaceCapabilitiesKHR.currentTransform ); } + SurfaceTransformFlagBitsKHR& currentTransform() + { + return reinterpret_cast( m_surfaceCapabilitiesKHR.currentTransform ); + } + SurfaceCapabilitiesKHR& currentTransform( SurfaceTransformFlagBitsKHR currentTransform ) { m_surfaceCapabilitiesKHR.currentTransform = static_cast( currentTransform ); @@ -15842,6 +19267,11 @@ namespace vk return reinterpret_cast( m_surfaceCapabilitiesKHR.supportedCompositeAlpha ); } + CompositeAlphaFlagsKHR& supportedCompositeAlpha() + { + return reinterpret_cast( m_surfaceCapabilitiesKHR.supportedCompositeAlpha ); + } + SurfaceCapabilitiesKHR& supportedCompositeAlpha( CompositeAlphaFlagsKHR supportedCompositeAlpha ) { m_surfaceCapabilitiesKHR.supportedCompositeAlpha = static_cast( supportedCompositeAlpha ); @@ -15853,6 +19283,11 @@ namespace vk return reinterpret_cast( m_surfaceCapabilitiesKHR.supportedUsageFlags ); } + ImageUsageFlags& supportedUsageFlags() + { + return reinterpret_cast( m_surfaceCapabilitiesKHR.supportedUsageFlags ); + } + SurfaceCapabilitiesKHR& supportedUsageFlags( ImageUsageFlags supportedUsageFlags ) { m_surfaceCapabilitiesKHR.supportedUsageFlags = static_cast( supportedUsageFlags ); @@ -15914,6 +19349,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.sType ); + } + SwapchainCreateInfoKHR& sType( StructureType sType ) { m_swapchainCreateInfoKHR.sType = static_cast( sType ); @@ -15925,6 +19365,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.pNext ); + } + SwapchainCreateInfoKHR& pNext( const void* pNext ) { m_swapchainCreateInfoKHR.pNext = pNext; @@ -15936,6 +19381,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.flags ); } + SwapchainCreateFlagsKHR& flags() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.flags ); + } + SwapchainCreateInfoKHR& flags( SwapchainCreateFlagsKHR flags ) { m_swapchainCreateInfoKHR.flags = static_cast( flags ); @@ -15947,6 +19397,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.surface ); } + SurfaceKHR& surface() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.surface ); + } + SwapchainCreateInfoKHR& surface( SurfaceKHR surface ) { m_swapchainCreateInfoKHR.surface = static_cast( surface ); @@ -15958,6 +19413,11 @@ namespace vk return m_swapchainCreateInfoKHR.minImageCount; } + uint32_t& minImageCount() + { + return m_swapchainCreateInfoKHR.minImageCount; + } + SwapchainCreateInfoKHR& minImageCount( uint32_t minImageCount ) { m_swapchainCreateInfoKHR.minImageCount = minImageCount; @@ -15969,6 +19429,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.imageFormat ); } + Format& imageFormat() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.imageFormat ); + } + SwapchainCreateInfoKHR& imageFormat( Format imageFormat ) { m_swapchainCreateInfoKHR.imageFormat = static_cast( imageFormat ); @@ -15980,6 +19445,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.imageColorSpace ); } + ColorSpaceKHR& imageColorSpace() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.imageColorSpace ); + } + SwapchainCreateInfoKHR& imageColorSpace( ColorSpaceKHR imageColorSpace ) { m_swapchainCreateInfoKHR.imageColorSpace = static_cast( imageColorSpace ); @@ -15991,6 +19461,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.imageExtent ); } + Extent2D& imageExtent() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.imageExtent ); + } + SwapchainCreateInfoKHR& imageExtent( Extent2D imageExtent ) { m_swapchainCreateInfoKHR.imageExtent = static_cast( imageExtent ); @@ -16002,6 +19477,11 @@ namespace vk return m_swapchainCreateInfoKHR.imageArrayLayers; } + uint32_t& imageArrayLayers() + { + return m_swapchainCreateInfoKHR.imageArrayLayers; + } + SwapchainCreateInfoKHR& imageArrayLayers( uint32_t imageArrayLayers ) { m_swapchainCreateInfoKHR.imageArrayLayers = imageArrayLayers; @@ -16013,6 +19493,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.imageUsage ); } + ImageUsageFlags& imageUsage() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.imageUsage ); + } + SwapchainCreateInfoKHR& imageUsage( ImageUsageFlags imageUsage ) { m_swapchainCreateInfoKHR.imageUsage = static_cast( imageUsage ); @@ -16024,6 +19509,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.imageSharingMode ); } + SharingMode& imageSharingMode() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.imageSharingMode ); + } + SwapchainCreateInfoKHR& imageSharingMode( SharingMode imageSharingMode ) { m_swapchainCreateInfoKHR.imageSharingMode = static_cast( imageSharingMode ); @@ -16035,6 +19525,11 @@ namespace vk return m_swapchainCreateInfoKHR.queueFamilyIndexCount; } + uint32_t& queueFamilyIndexCount() + { + return m_swapchainCreateInfoKHR.queueFamilyIndexCount; + } + SwapchainCreateInfoKHR& queueFamilyIndexCount( uint32_t queueFamilyIndexCount ) { m_swapchainCreateInfoKHR.queueFamilyIndexCount = queueFamilyIndexCount; @@ -16046,6 +19541,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.pQueueFamilyIndices ); } + const uint32_t* pQueueFamilyIndices() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.pQueueFamilyIndices ); + } + SwapchainCreateInfoKHR& pQueueFamilyIndices( const uint32_t* pQueueFamilyIndices ) { m_swapchainCreateInfoKHR.pQueueFamilyIndices = pQueueFamilyIndices; @@ -16057,6 +19557,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.preTransform ); } + SurfaceTransformFlagBitsKHR& preTransform() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.preTransform ); + } + SwapchainCreateInfoKHR& preTransform( SurfaceTransformFlagBitsKHR preTransform ) { m_swapchainCreateInfoKHR.preTransform = static_cast( preTransform ); @@ -16068,6 +19573,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.compositeAlpha ); } + CompositeAlphaFlagBitsKHR& compositeAlpha() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.compositeAlpha ); + } + SwapchainCreateInfoKHR& compositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha ) { m_swapchainCreateInfoKHR.compositeAlpha = static_cast( compositeAlpha ); @@ -16079,6 +19589,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.presentMode ); } + PresentModeKHR& presentMode() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.presentMode ); + } + SwapchainCreateInfoKHR& presentMode( PresentModeKHR presentMode ) { m_swapchainCreateInfoKHR.presentMode = static_cast( presentMode ); @@ -16090,6 +19605,11 @@ namespace vk return m_swapchainCreateInfoKHR.clipped; } + Bool32& clipped() + { + return m_swapchainCreateInfoKHR.clipped; + } + SwapchainCreateInfoKHR& clipped( Bool32 clipped ) { m_swapchainCreateInfoKHR.clipped = clipped; @@ -16101,6 +19621,11 @@ namespace vk return reinterpret_cast( m_swapchainCreateInfoKHR.oldSwapchain ); } + SwapchainKHR& oldSwapchain() + { + return reinterpret_cast( m_swapchainCreateInfoKHR.oldSwapchain ); + } + SwapchainCreateInfoKHR& oldSwapchain( SwapchainKHR oldSwapchain ) { m_swapchainCreateInfoKHR.oldSwapchain = static_cast( oldSwapchain ); @@ -17179,6 +20704,11 @@ namespace vk return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.sType ); } + StructureType& sType() + { + return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.sType ); + } + DebugReportCallbackCreateInfoEXT& sType( StructureType sType ) { m_debugReportCallbackCreateInfoEXT.sType = static_cast( sType ); @@ -17190,6 +20720,11 @@ namespace vk return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.pNext ); } + const void* pNext() + { + return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.pNext ); + } + DebugReportCallbackCreateInfoEXT& pNext( const void* pNext ) { m_debugReportCallbackCreateInfoEXT.pNext = pNext; @@ -17201,6 +20736,11 @@ namespace vk return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.flags ); } + DebugReportFlagsEXT& flags() + { + return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.flags ); + } + DebugReportCallbackCreateInfoEXT& flags( DebugReportFlagsEXT flags ) { m_debugReportCallbackCreateInfoEXT.flags = static_cast( flags ); @@ -17212,6 +20752,11 @@ namespace vk return m_debugReportCallbackCreateInfoEXT.pfnCallback; } + PFN_vkDebugReportCallbackEXT& pfnCallback() + { + return m_debugReportCallbackCreateInfoEXT.pfnCallback; + } + DebugReportCallbackCreateInfoEXT& pfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback ) { m_debugReportCallbackCreateInfoEXT.pfnCallback = pfnCallback; @@ -17219,6 +20764,11 @@ namespace vk } const void* pUserData() const + { + return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.pUserData ); + } + + void* pUserData() { return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.pUserData ); }