diff --git a/VkCppGenerator.cpp b/VkCppGenerator.cpp index 6485920..dc1ba69 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 ); } } @@ -2634,8 +2663,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 ba5903d..6047c7e 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; @@ -1747,6 +1757,11 @@ namespace vk return m_offset3D.x; } + int32_t& x() + { + return m_offset3D.x; + } + Offset3D& x( int32_t x ) { m_offset3D.x = x; @@ -1758,6 +1773,11 @@ namespace vk return m_offset3D.y; } + int32_t& y() + { + return m_offset3D.y; + } + Offset3D& y( int32_t y ) { m_offset3D.y = y; @@ -1769,6 +1789,11 @@ namespace vk return m_offset3D.z; } + int32_t& z() + { + return m_offset3D.z; + } + Offset3D& z( int32_t z ) { m_offset3D.z = z; @@ -1819,6 +1844,11 @@ namespace vk return m_extent2D.width; } + uint32_t& width() + { + return m_extent2D.width; + } + Extent2D& width( uint32_t width ) { m_extent2D.width = width; @@ -1830,6 +1860,11 @@ namespace vk return m_extent2D.height; } + uint32_t& height() + { + return m_extent2D.height; + } + Extent2D& height( uint32_t height ) { m_extent2D.height = height; @@ -1881,6 +1916,11 @@ namespace vk return m_extent3D.width; } + uint32_t& width() + { + return m_extent3D.width; + } + Extent3D& width( uint32_t width ) { m_extent3D.width = width; @@ -1892,6 +1932,11 @@ namespace vk return m_extent3D.height; } + uint32_t& height() + { + return m_extent3D.height; + } + Extent3D& height( uint32_t height ) { m_extent3D.height = height; @@ -1903,6 +1948,11 @@ namespace vk return m_extent3D.depth; } + uint32_t& depth() + { + return m_extent3D.depth; + } + Extent3D& depth( uint32_t depth ) { m_extent3D.depth = depth; @@ -1957,6 +2007,11 @@ namespace vk return m_viewport.x; } + float& x() + { + return m_viewport.x; + } + Viewport& x( float x ) { m_viewport.x = x; @@ -1968,6 +2023,11 @@ namespace vk return m_viewport.y; } + float& y() + { + return m_viewport.y; + } + Viewport& y( float y ) { m_viewport.y = y; @@ -1979,6 +2039,11 @@ namespace vk return m_viewport.width; } + float& width() + { + return m_viewport.width; + } + Viewport& width( float width ) { m_viewport.width = width; @@ -1990,6 +2055,11 @@ namespace vk return m_viewport.height; } + float& height() + { + return m_viewport.height; + } + Viewport& height( float height ) { m_viewport.height = height; @@ -2001,6 +2071,11 @@ namespace vk return m_viewport.minDepth; } + float& minDepth() + { + return m_viewport.minDepth; + } + Viewport& minDepth( float minDepth ) { m_viewport.minDepth = minDepth; @@ -2012,6 +2087,11 @@ namespace vk return m_viewport.maxDepth; } + float& maxDepth() + { + return m_viewport.maxDepth; + } + Viewport& maxDepth( float maxDepth ) { m_viewport.maxDepth = maxDepth; @@ -2062,6 +2142,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 ); @@ -2073,6 +2158,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 ); @@ -2124,6 +2214,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 ); @@ -2135,6 +2230,11 @@ namespace vk return m_clearRect.baseArrayLayer; } + uint32_t& baseArrayLayer() + { + return m_clearRect.baseArrayLayer; + } + ClearRect& baseArrayLayer( uint32_t baseArrayLayer ) { m_clearRect.baseArrayLayer = baseArrayLayer; @@ -2146,6 +2246,11 @@ namespace vk return m_clearRect.layerCount; } + uint32_t& layerCount() + { + return m_clearRect.layerCount; + } + ClearRect& layerCount( uint32_t layerCount ) { m_clearRect.layerCount = layerCount; @@ -2258,6 +2363,11 @@ namespace vk } const void* pUserData() const + { + return reinterpret_cast( m_allocationCallbacks.pUserData ); + } + + void* pUserData() { return reinterpret_cast( m_allocationCallbacks.pUserData ); } @@ -2273,6 +2383,11 @@ namespace vk return m_allocationCallbacks.pfnAllocation; } + PFN_vkAllocationFunction& pfnAllocation() + { + return m_allocationCallbacks.pfnAllocation; + } + AllocationCallbacks& pfnAllocation( PFN_vkAllocationFunction pfnAllocation ) { m_allocationCallbacks.pfnAllocation = pfnAllocation; @@ -2284,6 +2399,11 @@ namespace vk return m_allocationCallbacks.pfnReallocation; } + PFN_vkReallocationFunction& pfnReallocation() + { + return m_allocationCallbacks.pfnReallocation; + } + AllocationCallbacks& pfnReallocation( PFN_vkReallocationFunction pfnReallocation ) { m_allocationCallbacks.pfnReallocation = pfnReallocation; @@ -2295,6 +2415,11 @@ namespace vk return m_allocationCallbacks.pfnFree; } + PFN_vkFreeFunction& pfnFree() + { + return m_allocationCallbacks.pfnFree; + } + AllocationCallbacks& pfnFree( PFN_vkFreeFunction pfnFree ) { m_allocationCallbacks.pfnFree = pfnFree; @@ -2306,6 +2431,11 @@ namespace vk return m_allocationCallbacks.pfnInternalAllocation; } + PFN_vkInternalAllocationNotification& pfnInternalAllocation() + { + return m_allocationCallbacks.pfnInternalAllocation; + } + AllocationCallbacks& pfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation ) { m_allocationCallbacks.pfnInternalAllocation = pfnInternalAllocation; @@ -2317,6 +2447,11 @@ namespace vk return m_allocationCallbacks.pfnInternalFree; } + PFN_vkInternalFreeNotification& pfnInternalFree() + { + return m_allocationCallbacks.pfnInternalFree; + } + AllocationCallbacks& pfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree ) { m_allocationCallbacks.pfnInternalFree = pfnInternalFree; @@ -2401,6 +2536,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 ); @@ -2412,6 +2552,11 @@ namespace vk return m_descriptorBufferInfo.offset; } + DeviceSize& offset() + { + return m_descriptorBufferInfo.offset; + } + DescriptorBufferInfo& offset( DeviceSize offset ) { m_descriptorBufferInfo.offset = offset; @@ -2423,6 +2568,11 @@ namespace vk return m_descriptorBufferInfo.range; } + DeviceSize& range() + { + return m_descriptorBufferInfo.range; + } + DescriptorBufferInfo& range( DeviceSize range ) { m_descriptorBufferInfo.range = range; @@ -2476,6 +2626,11 @@ namespace vk return m_subresourceLayout.offset; } + DeviceSize& offset() + { + return m_subresourceLayout.offset; + } + SubresourceLayout& offset( DeviceSize offset ) { m_subresourceLayout.offset = offset; @@ -2487,6 +2642,11 @@ namespace vk return m_subresourceLayout.size; } + DeviceSize& size() + { + return m_subresourceLayout.size; + } + SubresourceLayout& size( DeviceSize size ) { m_subresourceLayout.size = size; @@ -2498,6 +2658,11 @@ namespace vk return m_subresourceLayout.rowPitch; } + DeviceSize& rowPitch() + { + return m_subresourceLayout.rowPitch; + } + SubresourceLayout& rowPitch( DeviceSize rowPitch ) { m_subresourceLayout.rowPitch = rowPitch; @@ -2509,6 +2674,11 @@ namespace vk return m_subresourceLayout.arrayPitch; } + DeviceSize& arrayPitch() + { + return m_subresourceLayout.arrayPitch; + } + SubresourceLayout& arrayPitch( DeviceSize arrayPitch ) { m_subresourceLayout.arrayPitch = arrayPitch; @@ -2520,6 +2690,11 @@ namespace vk return m_subresourceLayout.depthPitch; } + DeviceSize& depthPitch() + { + return m_subresourceLayout.depthPitch; + } + SubresourceLayout& depthPitch( DeviceSize depthPitch ) { m_subresourceLayout.depthPitch = depthPitch; @@ -2571,6 +2746,11 @@ namespace vk return m_bufferCopy.srcOffset; } + DeviceSize& srcOffset() + { + return m_bufferCopy.srcOffset; + } + BufferCopy& srcOffset( DeviceSize srcOffset ) { m_bufferCopy.srcOffset = srcOffset; @@ -2582,6 +2762,11 @@ namespace vk return m_bufferCopy.dstOffset; } + DeviceSize& dstOffset() + { + return m_bufferCopy.dstOffset; + } + BufferCopy& dstOffset( DeviceSize dstOffset ) { m_bufferCopy.dstOffset = dstOffset; @@ -2593,6 +2778,11 @@ namespace vk return m_bufferCopy.size; } + DeviceSize& size() + { + return m_bufferCopy.size; + } + BufferCopy& size( DeviceSize size ) { m_bufferCopy.size = size; @@ -2644,6 +2834,11 @@ namespace vk return m_specializationMapEntry.constantID; } + uint32_t& constantID() + { + return m_specializationMapEntry.constantID; + } + SpecializationMapEntry& constantID( uint32_t constantID ) { m_specializationMapEntry.constantID = constantID; @@ -2655,6 +2850,11 @@ namespace vk return m_specializationMapEntry.offset; } + uint32_t& offset() + { + return m_specializationMapEntry.offset; + } + SpecializationMapEntry& offset( uint32_t offset ) { m_specializationMapEntry.offset = offset; @@ -2666,6 +2866,11 @@ namespace vk return m_specializationMapEntry.size; } + size_t& size() + { + return m_specializationMapEntry.size; + } + SpecializationMapEntry& size( size_t size ) { m_specializationMapEntry.size = size; @@ -2718,6 +2923,11 @@ namespace vk return m_specializationInfo.mapEntryCount; } + uint32_t& mapEntryCount() + { + return m_specializationInfo.mapEntryCount; + } + SpecializationInfo& mapEntryCount( uint32_t mapEntryCount ) { m_specializationInfo.mapEntryCount = mapEntryCount; @@ -2729,6 +2939,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 ); @@ -2740,6 +2955,11 @@ namespace vk return m_specializationInfo.dataSize; } + size_t& dataSize() + { + return m_specializationInfo.dataSize; + } + SpecializationInfo& dataSize( size_t dataSize ) { m_specializationInfo.dataSize = dataSize; @@ -2751,6 +2971,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; @@ -2785,6 +3010,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 ) ); @@ -2801,6 +3031,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 ) ); @@ -2817,6 +3052,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 ) ); @@ -2861,6 +3101,11 @@ namespace vk return m_clearDepthStencilValue.depth; } + float& depth() + { + return m_clearDepthStencilValue.depth; + } + ClearDepthStencilValue& depth( float depth ) { m_clearDepthStencilValue.depth = depth; @@ -2872,6 +3117,11 @@ namespace vk return m_clearDepthStencilValue.stencil; } + uint32_t& stencil() + { + return m_clearDepthStencilValue.stencil; + } + ClearDepthStencilValue& stencil( uint32_t stencil ) { m_clearDepthStencilValue.stencil = stencil; @@ -2906,6 +3156,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 ); @@ -2922,6 +3177,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 ); @@ -3019,6 +3279,11 @@ namespace vk return m_physicalDeviceFeatures.robustBufferAccess; } + Bool32& robustBufferAccess() + { + return m_physicalDeviceFeatures.robustBufferAccess; + } + PhysicalDeviceFeatures& robustBufferAccess( Bool32 robustBufferAccess ) { m_physicalDeviceFeatures.robustBufferAccess = robustBufferAccess; @@ -3030,6 +3295,11 @@ namespace vk return m_physicalDeviceFeatures.fullDrawIndexUint32; } + Bool32& fullDrawIndexUint32() + { + return m_physicalDeviceFeatures.fullDrawIndexUint32; + } + PhysicalDeviceFeatures& fullDrawIndexUint32( Bool32 fullDrawIndexUint32 ) { m_physicalDeviceFeatures.fullDrawIndexUint32 = fullDrawIndexUint32; @@ -3041,6 +3311,11 @@ namespace vk return m_physicalDeviceFeatures.imageCubeArray; } + Bool32& imageCubeArray() + { + return m_physicalDeviceFeatures.imageCubeArray; + } + PhysicalDeviceFeatures& imageCubeArray( Bool32 imageCubeArray ) { m_physicalDeviceFeatures.imageCubeArray = imageCubeArray; @@ -3052,6 +3327,11 @@ namespace vk return m_physicalDeviceFeatures.independentBlend; } + Bool32& independentBlend() + { + return m_physicalDeviceFeatures.independentBlend; + } + PhysicalDeviceFeatures& independentBlend( Bool32 independentBlend ) { m_physicalDeviceFeatures.independentBlend = independentBlend; @@ -3063,6 +3343,11 @@ namespace vk return m_physicalDeviceFeatures.geometryShader; } + Bool32& geometryShader() + { + return m_physicalDeviceFeatures.geometryShader; + } + PhysicalDeviceFeatures& geometryShader( Bool32 geometryShader ) { m_physicalDeviceFeatures.geometryShader = geometryShader; @@ -3074,6 +3359,11 @@ namespace vk return m_physicalDeviceFeatures.tessellationShader; } + Bool32& tessellationShader() + { + return m_physicalDeviceFeatures.tessellationShader; + } + PhysicalDeviceFeatures& tessellationShader( Bool32 tessellationShader ) { m_physicalDeviceFeatures.tessellationShader = tessellationShader; @@ -3085,6 +3375,11 @@ namespace vk return m_physicalDeviceFeatures.sampleRateShading; } + Bool32& sampleRateShading() + { + return m_physicalDeviceFeatures.sampleRateShading; + } + PhysicalDeviceFeatures& sampleRateShading( Bool32 sampleRateShading ) { m_physicalDeviceFeatures.sampleRateShading = sampleRateShading; @@ -3096,6 +3391,11 @@ namespace vk return m_physicalDeviceFeatures.dualSrcBlend; } + Bool32& dualSrcBlend() + { + return m_physicalDeviceFeatures.dualSrcBlend; + } + PhysicalDeviceFeatures& dualSrcBlend( Bool32 dualSrcBlend ) { m_physicalDeviceFeatures.dualSrcBlend = dualSrcBlend; @@ -3107,6 +3407,11 @@ namespace vk return m_physicalDeviceFeatures.logicOp; } + Bool32& logicOp() + { + return m_physicalDeviceFeatures.logicOp; + } + PhysicalDeviceFeatures& logicOp( Bool32 logicOp ) { m_physicalDeviceFeatures.logicOp = logicOp; @@ -3118,6 +3423,11 @@ namespace vk return m_physicalDeviceFeatures.multiDrawIndirect; } + Bool32& multiDrawIndirect() + { + return m_physicalDeviceFeatures.multiDrawIndirect; + } + PhysicalDeviceFeatures& multiDrawIndirect( Bool32 multiDrawIndirect ) { m_physicalDeviceFeatures.multiDrawIndirect = multiDrawIndirect; @@ -3129,6 +3439,11 @@ namespace vk return m_physicalDeviceFeatures.drawIndirectFirstInstance; } + Bool32& drawIndirectFirstInstance() + { + return m_physicalDeviceFeatures.drawIndirectFirstInstance; + } + PhysicalDeviceFeatures& drawIndirectFirstInstance( Bool32 drawIndirectFirstInstance ) { m_physicalDeviceFeatures.drawIndirectFirstInstance = drawIndirectFirstInstance; @@ -3140,6 +3455,11 @@ namespace vk return m_physicalDeviceFeatures.depthClamp; } + Bool32& depthClamp() + { + return m_physicalDeviceFeatures.depthClamp; + } + PhysicalDeviceFeatures& depthClamp( Bool32 depthClamp ) { m_physicalDeviceFeatures.depthClamp = depthClamp; @@ -3151,6 +3471,11 @@ namespace vk return m_physicalDeviceFeatures.depthBiasClamp; } + Bool32& depthBiasClamp() + { + return m_physicalDeviceFeatures.depthBiasClamp; + } + PhysicalDeviceFeatures& depthBiasClamp( Bool32 depthBiasClamp ) { m_physicalDeviceFeatures.depthBiasClamp = depthBiasClamp; @@ -3162,6 +3487,11 @@ namespace vk return m_physicalDeviceFeatures.fillModeNonSolid; } + Bool32& fillModeNonSolid() + { + return m_physicalDeviceFeatures.fillModeNonSolid; + } + PhysicalDeviceFeatures& fillModeNonSolid( Bool32 fillModeNonSolid ) { m_physicalDeviceFeatures.fillModeNonSolid = fillModeNonSolid; @@ -3173,6 +3503,11 @@ namespace vk return m_physicalDeviceFeatures.depthBounds; } + Bool32& depthBounds() + { + return m_physicalDeviceFeatures.depthBounds; + } + PhysicalDeviceFeatures& depthBounds( Bool32 depthBounds ) { m_physicalDeviceFeatures.depthBounds = depthBounds; @@ -3184,6 +3519,11 @@ namespace vk return m_physicalDeviceFeatures.wideLines; } + Bool32& wideLines() + { + return m_physicalDeviceFeatures.wideLines; + } + PhysicalDeviceFeatures& wideLines( Bool32 wideLines ) { m_physicalDeviceFeatures.wideLines = wideLines; @@ -3195,6 +3535,11 @@ namespace vk return m_physicalDeviceFeatures.largePoints; } + Bool32& largePoints() + { + return m_physicalDeviceFeatures.largePoints; + } + PhysicalDeviceFeatures& largePoints( Bool32 largePoints ) { m_physicalDeviceFeatures.largePoints = largePoints; @@ -3206,6 +3551,11 @@ namespace vk return m_physicalDeviceFeatures.alphaToOne; } + Bool32& alphaToOne() + { + return m_physicalDeviceFeatures.alphaToOne; + } + PhysicalDeviceFeatures& alphaToOne( Bool32 alphaToOne ) { m_physicalDeviceFeatures.alphaToOne = alphaToOne; @@ -3217,6 +3567,11 @@ namespace vk return m_physicalDeviceFeatures.multiViewport; } + Bool32& multiViewport() + { + return m_physicalDeviceFeatures.multiViewport; + } + PhysicalDeviceFeatures& multiViewport( Bool32 multiViewport ) { m_physicalDeviceFeatures.multiViewport = multiViewport; @@ -3228,6 +3583,11 @@ namespace vk return m_physicalDeviceFeatures.samplerAnisotropy; } + Bool32& samplerAnisotropy() + { + return m_physicalDeviceFeatures.samplerAnisotropy; + } + PhysicalDeviceFeatures& samplerAnisotropy( Bool32 samplerAnisotropy ) { m_physicalDeviceFeatures.samplerAnisotropy = samplerAnisotropy; @@ -3239,6 +3599,11 @@ namespace vk return m_physicalDeviceFeatures.textureCompressionETC2; } + Bool32& textureCompressionETC2() + { + return m_physicalDeviceFeatures.textureCompressionETC2; + } + PhysicalDeviceFeatures& textureCompressionETC2( Bool32 textureCompressionETC2 ) { m_physicalDeviceFeatures.textureCompressionETC2 = textureCompressionETC2; @@ -3250,6 +3615,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; @@ -3261,6 +3631,11 @@ namespace vk return m_physicalDeviceFeatures.textureCompressionBC; } + Bool32& textureCompressionBC() + { + return m_physicalDeviceFeatures.textureCompressionBC; + } + PhysicalDeviceFeatures& textureCompressionBC( Bool32 textureCompressionBC ) { m_physicalDeviceFeatures.textureCompressionBC = textureCompressionBC; @@ -3272,6 +3647,11 @@ namespace vk return m_physicalDeviceFeatures.occlusionQueryPrecise; } + Bool32& occlusionQueryPrecise() + { + return m_physicalDeviceFeatures.occlusionQueryPrecise; + } + PhysicalDeviceFeatures& occlusionQueryPrecise( Bool32 occlusionQueryPrecise ) { m_physicalDeviceFeatures.occlusionQueryPrecise = occlusionQueryPrecise; @@ -3283,6 +3663,11 @@ namespace vk return m_physicalDeviceFeatures.pipelineStatisticsQuery; } + Bool32& pipelineStatisticsQuery() + { + return m_physicalDeviceFeatures.pipelineStatisticsQuery; + } + PhysicalDeviceFeatures& pipelineStatisticsQuery( Bool32 pipelineStatisticsQuery ) { m_physicalDeviceFeatures.pipelineStatisticsQuery = pipelineStatisticsQuery; @@ -3294,6 +3679,11 @@ namespace vk return m_physicalDeviceFeatures.vertexPipelineStoresAndAtomics; } + Bool32& vertexPipelineStoresAndAtomics() + { + return m_physicalDeviceFeatures.vertexPipelineStoresAndAtomics; + } + PhysicalDeviceFeatures& vertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics ) { m_physicalDeviceFeatures.vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics; @@ -3305,6 +3695,11 @@ namespace vk return m_physicalDeviceFeatures.fragmentStoresAndAtomics; } + Bool32& fragmentStoresAndAtomics() + { + return m_physicalDeviceFeatures.fragmentStoresAndAtomics; + } + PhysicalDeviceFeatures& fragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics ) { m_physicalDeviceFeatures.fragmentStoresAndAtomics = fragmentStoresAndAtomics; @@ -3316,6 +3711,11 @@ namespace vk return m_physicalDeviceFeatures.shaderTessellationAndGeometryPointSize; } + Bool32& shaderTessellationAndGeometryPointSize() + { + return m_physicalDeviceFeatures.shaderTessellationAndGeometryPointSize; + } + PhysicalDeviceFeatures& shaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize ) { m_physicalDeviceFeatures.shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize; @@ -3327,6 +3727,11 @@ namespace vk return m_physicalDeviceFeatures.shaderImageGatherExtended; } + Bool32& shaderImageGatherExtended() + { + return m_physicalDeviceFeatures.shaderImageGatherExtended; + } + PhysicalDeviceFeatures& shaderImageGatherExtended( Bool32 shaderImageGatherExtended ) { m_physicalDeviceFeatures.shaderImageGatherExtended = shaderImageGatherExtended; @@ -3338,6 +3743,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageExtendedFormats; } + Bool32& shaderStorageImageExtendedFormats() + { + return m_physicalDeviceFeatures.shaderStorageImageExtendedFormats; + } + PhysicalDeviceFeatures& shaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats ) { m_physicalDeviceFeatures.shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats; @@ -3349,6 +3759,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageMultisample; } + Bool32& shaderStorageImageMultisample() + { + return m_physicalDeviceFeatures.shaderStorageImageMultisample; + } + PhysicalDeviceFeatures& shaderStorageImageMultisample( Bool32 shaderStorageImageMultisample ) { m_physicalDeviceFeatures.shaderStorageImageMultisample = shaderStorageImageMultisample; @@ -3360,6 +3775,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageReadWithoutFormat; } + Bool32& shaderStorageImageReadWithoutFormat() + { + return m_physicalDeviceFeatures.shaderStorageImageReadWithoutFormat; + } + PhysicalDeviceFeatures& shaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat ) { m_physicalDeviceFeatures.shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat; @@ -3371,6 +3791,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat; } + Bool32& shaderStorageImageWriteWithoutFormat() + { + return m_physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat; + } + PhysicalDeviceFeatures& shaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat ) { m_physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat; @@ -3382,6 +3807,11 @@ namespace vk return m_physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing; } + Bool32& shaderUniformBufferArrayDynamicIndexing() + { + return m_physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing; + } + PhysicalDeviceFeatures& shaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing ) { m_physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing; @@ -3393,6 +3823,11 @@ namespace vk return m_physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing; } + Bool32& shaderSampledImageArrayDynamicIndexing() + { + return m_physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing; + } + PhysicalDeviceFeatures& shaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing ) { m_physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing; @@ -3404,6 +3839,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing; } + Bool32& shaderStorageBufferArrayDynamicIndexing() + { + return m_physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing; + } + PhysicalDeviceFeatures& shaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing ) { m_physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing; @@ -3415,6 +3855,11 @@ namespace vk return m_physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing; } + Bool32& shaderStorageImageArrayDynamicIndexing() + { + return m_physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing; + } + PhysicalDeviceFeatures& shaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing ) { m_physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing; @@ -3426,6 +3871,11 @@ namespace vk return m_physicalDeviceFeatures.shaderClipDistance; } + Bool32& shaderClipDistance() + { + return m_physicalDeviceFeatures.shaderClipDistance; + } + PhysicalDeviceFeatures& shaderClipDistance( Bool32 shaderClipDistance ) { m_physicalDeviceFeatures.shaderClipDistance = shaderClipDistance; @@ -3437,6 +3887,11 @@ namespace vk return m_physicalDeviceFeatures.shaderCullDistance; } + Bool32& shaderCullDistance() + { + return m_physicalDeviceFeatures.shaderCullDistance; + } + PhysicalDeviceFeatures& shaderCullDistance( Bool32 shaderCullDistance ) { m_physicalDeviceFeatures.shaderCullDistance = shaderCullDistance; @@ -3448,6 +3903,11 @@ namespace vk return m_physicalDeviceFeatures.shaderFloat64; } + Bool32& shaderFloat64() + { + return m_physicalDeviceFeatures.shaderFloat64; + } + PhysicalDeviceFeatures& shaderFloat64( Bool32 shaderFloat64 ) { m_physicalDeviceFeatures.shaderFloat64 = shaderFloat64; @@ -3459,6 +3919,11 @@ namespace vk return m_physicalDeviceFeatures.shaderInt64; } + Bool32& shaderInt64() + { + return m_physicalDeviceFeatures.shaderInt64; + } + PhysicalDeviceFeatures& shaderInt64( Bool32 shaderInt64 ) { m_physicalDeviceFeatures.shaderInt64 = shaderInt64; @@ -3470,6 +3935,11 @@ namespace vk return m_physicalDeviceFeatures.shaderInt16; } + Bool32& shaderInt16() + { + return m_physicalDeviceFeatures.shaderInt16; + } + PhysicalDeviceFeatures& shaderInt16( Bool32 shaderInt16 ) { m_physicalDeviceFeatures.shaderInt16 = shaderInt16; @@ -3481,6 +3951,11 @@ namespace vk return m_physicalDeviceFeatures.shaderResourceResidency; } + Bool32& shaderResourceResidency() + { + return m_physicalDeviceFeatures.shaderResourceResidency; + } + PhysicalDeviceFeatures& shaderResourceResidency( Bool32 shaderResourceResidency ) { m_physicalDeviceFeatures.shaderResourceResidency = shaderResourceResidency; @@ -3492,6 +3967,11 @@ namespace vk return m_physicalDeviceFeatures.shaderResourceMinLod; } + Bool32& shaderResourceMinLod() + { + return m_physicalDeviceFeatures.shaderResourceMinLod; + } + PhysicalDeviceFeatures& shaderResourceMinLod( Bool32 shaderResourceMinLod ) { m_physicalDeviceFeatures.shaderResourceMinLod = shaderResourceMinLod; @@ -3503,6 +3983,11 @@ namespace vk return m_physicalDeviceFeatures.sparseBinding; } + Bool32& sparseBinding() + { + return m_physicalDeviceFeatures.sparseBinding; + } + PhysicalDeviceFeatures& sparseBinding( Bool32 sparseBinding ) { m_physicalDeviceFeatures.sparseBinding = sparseBinding; @@ -3514,6 +3999,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidencyBuffer; } + Bool32& sparseResidencyBuffer() + { + return m_physicalDeviceFeatures.sparseResidencyBuffer; + } + PhysicalDeviceFeatures& sparseResidencyBuffer( Bool32 sparseResidencyBuffer ) { m_physicalDeviceFeatures.sparseResidencyBuffer = sparseResidencyBuffer; @@ -3525,6 +4015,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidencyImage2D; } + Bool32& sparseResidencyImage2D() + { + return m_physicalDeviceFeatures.sparseResidencyImage2D; + } + PhysicalDeviceFeatures& sparseResidencyImage2D( Bool32 sparseResidencyImage2D ) { m_physicalDeviceFeatures.sparseResidencyImage2D = sparseResidencyImage2D; @@ -3536,6 +4031,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidencyImage3D; } + Bool32& sparseResidencyImage3D() + { + return m_physicalDeviceFeatures.sparseResidencyImage3D; + } + PhysicalDeviceFeatures& sparseResidencyImage3D( Bool32 sparseResidencyImage3D ) { m_physicalDeviceFeatures.sparseResidencyImage3D = sparseResidencyImage3D; @@ -3547,6 +4047,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidency2Samples; } + Bool32& sparseResidency2Samples() + { + return m_physicalDeviceFeatures.sparseResidency2Samples; + } + PhysicalDeviceFeatures& sparseResidency2Samples( Bool32 sparseResidency2Samples ) { m_physicalDeviceFeatures.sparseResidency2Samples = sparseResidency2Samples; @@ -3558,6 +4063,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidency4Samples; } + Bool32& sparseResidency4Samples() + { + return m_physicalDeviceFeatures.sparseResidency4Samples; + } + PhysicalDeviceFeatures& sparseResidency4Samples( Bool32 sparseResidency4Samples ) { m_physicalDeviceFeatures.sparseResidency4Samples = sparseResidency4Samples; @@ -3569,6 +4079,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidency8Samples; } + Bool32& sparseResidency8Samples() + { + return m_physicalDeviceFeatures.sparseResidency8Samples; + } + PhysicalDeviceFeatures& sparseResidency8Samples( Bool32 sparseResidency8Samples ) { m_physicalDeviceFeatures.sparseResidency8Samples = sparseResidency8Samples; @@ -3580,6 +4095,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidency16Samples; } + Bool32& sparseResidency16Samples() + { + return m_physicalDeviceFeatures.sparseResidency16Samples; + } + PhysicalDeviceFeatures& sparseResidency16Samples( Bool32 sparseResidency16Samples ) { m_physicalDeviceFeatures.sparseResidency16Samples = sparseResidency16Samples; @@ -3591,6 +4111,11 @@ namespace vk return m_physicalDeviceFeatures.sparseResidencyAliased; } + Bool32& sparseResidencyAliased() + { + return m_physicalDeviceFeatures.sparseResidencyAliased; + } + PhysicalDeviceFeatures& sparseResidencyAliased( Bool32 sparseResidencyAliased ) { m_physicalDeviceFeatures.sparseResidencyAliased = sparseResidencyAliased; @@ -3602,6 +4127,11 @@ namespace vk return m_physicalDeviceFeatures.variableMultisampleRate; } + Bool32& variableMultisampleRate() + { + return m_physicalDeviceFeatures.variableMultisampleRate; + } + PhysicalDeviceFeatures& variableMultisampleRate( Bool32 variableMultisampleRate ) { m_physicalDeviceFeatures.variableMultisampleRate = variableMultisampleRate; @@ -3613,6 +4143,11 @@ namespace vk return m_physicalDeviceFeatures.inheritedQueries; } + Bool32& inheritedQueries() + { + return m_physicalDeviceFeatures.inheritedQueries; + } + PhysicalDeviceFeatures& inheritedQueries( Bool32 inheritedQueries ) { m_physicalDeviceFeatures.inheritedQueries = inheritedQueries; @@ -3708,6 +4243,11 @@ namespace vk return m_drawIndirectCommand.vertexCount; } + uint32_t& vertexCount() + { + return m_drawIndirectCommand.vertexCount; + } + DrawIndirectCommand& vertexCount( uint32_t vertexCount ) { m_drawIndirectCommand.vertexCount = vertexCount; @@ -3719,6 +4259,11 @@ namespace vk return m_drawIndirectCommand.instanceCount; } + uint32_t& instanceCount() + { + return m_drawIndirectCommand.instanceCount; + } + DrawIndirectCommand& instanceCount( uint32_t instanceCount ) { m_drawIndirectCommand.instanceCount = instanceCount; @@ -3730,6 +4275,11 @@ namespace vk return m_drawIndirectCommand.firstVertex; } + uint32_t& firstVertex() + { + return m_drawIndirectCommand.firstVertex; + } + DrawIndirectCommand& firstVertex( uint32_t firstVertex ) { m_drawIndirectCommand.firstVertex = firstVertex; @@ -3741,6 +4291,11 @@ namespace vk return m_drawIndirectCommand.firstInstance; } + uint32_t& firstInstance() + { + return m_drawIndirectCommand.firstInstance; + } + DrawIndirectCommand& firstInstance( uint32_t firstInstance ) { m_drawIndirectCommand.firstInstance = firstInstance; @@ -3794,6 +4349,11 @@ namespace vk return m_drawIndexedIndirectCommand.indexCount; } + uint32_t& indexCount() + { + return m_drawIndexedIndirectCommand.indexCount; + } + DrawIndexedIndirectCommand& indexCount( uint32_t indexCount ) { m_drawIndexedIndirectCommand.indexCount = indexCount; @@ -3805,6 +4365,11 @@ namespace vk return m_drawIndexedIndirectCommand.instanceCount; } + uint32_t& instanceCount() + { + return m_drawIndexedIndirectCommand.instanceCount; + } + DrawIndexedIndirectCommand& instanceCount( uint32_t instanceCount ) { m_drawIndexedIndirectCommand.instanceCount = instanceCount; @@ -3816,6 +4381,11 @@ namespace vk return m_drawIndexedIndirectCommand.firstIndex; } + uint32_t& firstIndex() + { + return m_drawIndexedIndirectCommand.firstIndex; + } + DrawIndexedIndirectCommand& firstIndex( uint32_t firstIndex ) { m_drawIndexedIndirectCommand.firstIndex = firstIndex; @@ -3827,6 +4397,11 @@ namespace vk return m_drawIndexedIndirectCommand.vertexOffset; } + int32_t& vertexOffset() + { + return m_drawIndexedIndirectCommand.vertexOffset; + } + DrawIndexedIndirectCommand& vertexOffset( int32_t vertexOffset ) { m_drawIndexedIndirectCommand.vertexOffset = vertexOffset; @@ -3838,6 +4413,11 @@ namespace vk return m_drawIndexedIndirectCommand.firstInstance; } + uint32_t& firstInstance() + { + return m_drawIndexedIndirectCommand.firstInstance; + } + DrawIndexedIndirectCommand& firstInstance( uint32_t firstInstance ) { m_drawIndexedIndirectCommand.firstInstance = firstInstance; @@ -3889,6 +4469,11 @@ namespace vk return m_dispatchIndirectCommand.x; } + uint32_t& x() + { + return m_dispatchIndirectCommand.x; + } + DispatchIndirectCommand& x( uint32_t x ) { m_dispatchIndirectCommand.x = x; @@ -3900,6 +4485,11 @@ namespace vk return m_dispatchIndirectCommand.y; } + uint32_t& y() + { + return m_dispatchIndirectCommand.y; + } + DispatchIndirectCommand& y( uint32_t y ) { m_dispatchIndirectCommand.y = y; @@ -3911,6 +4501,11 @@ namespace vk return m_dispatchIndirectCommand.z; } + uint32_t& z() + { + return m_dispatchIndirectCommand.z; + } + DispatchIndirectCommand& z( uint32_t z ) { m_dispatchIndirectCommand.z = z; @@ -3961,6 +4556,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 ); @@ -3972,6 +4572,11 @@ namespace vk return m_displayPlanePropertiesKHR.currentStackIndex; } + uint32_t& currentStackIndex() + { + return m_displayPlanePropertiesKHR.currentStackIndex; + } + DisplayPlanePropertiesKHR& currentStackIndex( uint32_t currentStackIndex ) { m_displayPlanePropertiesKHR.currentStackIndex = currentStackIndex; @@ -4022,6 +4627,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 ); @@ -4033,6 +4643,11 @@ namespace vk return m_displayModeParametersKHR.refreshRate; } + uint32_t& refreshRate() + { + return m_displayModeParametersKHR.refreshRate; + } + DisplayModeParametersKHR& refreshRate( uint32_t refreshRate ) { m_displayModeParametersKHR.refreshRate = refreshRate; @@ -4083,6 +4698,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 ); @@ -4094,6 +4714,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 ); @@ -4159,6 +4784,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 ); @@ -4170,6 +4800,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 ); @@ -4181,6 +4816,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 ); @@ -4231,6 +4871,11 @@ namespace vk return m_attachmentReference.attachment; } + uint32_t& attachment() + { + return m_attachmentReference.attachment; + } + AttachmentReference& attachment( uint32_t attachment ) { m_attachmentReference.attachment = attachment; @@ -4242,6 +4887,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 ); @@ -4348,6 +4998,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 ); @@ -4359,6 +5014,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 ); @@ -4370,6 +5030,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 ); @@ -4381,6 +5046,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 ); @@ -4446,6 +5116,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 ); @@ -4457,6 +5132,11 @@ namespace vk return m_descriptorPoolSize.descriptorCount; } + uint32_t& descriptorCount() + { + return m_descriptorPoolSize.descriptorCount; + } + DescriptorPoolSize& descriptorCount( uint32_t descriptorCount ) { m_descriptorPoolSize.descriptorCount = descriptorCount; @@ -4538,6 +5218,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 ); @@ -4549,6 +5234,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 ); @@ -4560,6 +5250,11 @@ namespace vk return m_subpassDescription.inputAttachmentCount; } + uint32_t& inputAttachmentCount() + { + return m_subpassDescription.inputAttachmentCount; + } + SubpassDescription& inputAttachmentCount( uint32_t inputAttachmentCount ) { m_subpassDescription.inputAttachmentCount = inputAttachmentCount; @@ -4571,6 +5266,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 ); @@ -4582,6 +5282,11 @@ namespace vk return m_subpassDescription.colorAttachmentCount; } + uint32_t& colorAttachmentCount() + { + return m_subpassDescription.colorAttachmentCount; + } + SubpassDescription& colorAttachmentCount( uint32_t colorAttachmentCount ) { m_subpassDescription.colorAttachmentCount = colorAttachmentCount; @@ -4593,6 +5298,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 ); @@ -4604,6 +5314,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 ); @@ -4615,6 +5330,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 ); @@ -4626,6 +5346,11 @@ namespace vk return m_subpassDescription.preserveAttachmentCount; } + uint32_t& preserveAttachmentCount() + { + return m_subpassDescription.preserveAttachmentCount; + } + SubpassDescription& preserveAttachmentCount( uint32_t preserveAttachmentCount ) { m_subpassDescription.preserveAttachmentCount = preserveAttachmentCount; @@ -4637,6 +5362,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; @@ -4829,6 +5559,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 ); @@ -4840,6 +5575,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 ); @@ -4851,6 +5591,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 ); @@ -4862,6 +5607,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 ); @@ -4873,6 +5623,11 @@ namespace vk return m_stencilOpState.compareMask; } + uint32_t& compareMask() + { + return m_stencilOpState.compareMask; + } + StencilOpState& compareMask( uint32_t compareMask ) { m_stencilOpState.compareMask = compareMask; @@ -4884,6 +5639,11 @@ namespace vk return m_stencilOpState.writeMask; } + uint32_t& writeMask() + { + return m_stencilOpState.writeMask; + } + StencilOpState& writeMask( uint32_t writeMask ) { m_stencilOpState.writeMask = writeMask; @@ -4895,6 +5655,11 @@ namespace vk return m_stencilOpState.reference; } + uint32_t& reference() + { + return m_stencilOpState.reference; + } + StencilOpState& reference( uint32_t reference ) { m_stencilOpState.reference = reference; @@ -4995,6 +5760,11 @@ namespace vk return m_vertexInputBindingDescription.binding; } + uint32_t& binding() + { + return m_vertexInputBindingDescription.binding; + } + VertexInputBindingDescription& binding( uint32_t binding ) { m_vertexInputBindingDescription.binding = binding; @@ -5006,6 +5776,11 @@ namespace vk return m_vertexInputBindingDescription.stride; } + uint32_t& stride() + { + return m_vertexInputBindingDescription.stride; + } + VertexInputBindingDescription& stride( uint32_t stride ) { m_vertexInputBindingDescription.stride = stride; @@ -5017,6 +5792,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 ); @@ -5258,6 +6038,11 @@ namespace vk return m_vertexInputAttributeDescription.location; } + uint32_t& location() + { + return m_vertexInputAttributeDescription.location; + } + VertexInputAttributeDescription& location( uint32_t location ) { m_vertexInputAttributeDescription.location = location; @@ -5269,6 +6054,11 @@ namespace vk return m_vertexInputAttributeDescription.binding; } + uint32_t& binding() + { + return m_vertexInputAttributeDescription.binding; + } + VertexInputAttributeDescription& binding( uint32_t binding ) { m_vertexInputAttributeDescription.binding = binding; @@ -5280,6 +6070,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 ); @@ -5291,6 +6086,11 @@ namespace vk return m_vertexInputAttributeDescription.offset; } + uint32_t& offset() + { + return m_vertexInputAttributeDescription.offset; + } + VertexInputAttributeDescription& offset( uint32_t offset ) { m_vertexInputAttributeDescription.offset = offset; @@ -5411,6 +6211,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 ); @@ -5422,6 +6227,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; @@ -5433,6 +6243,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; @@ -5444,6 +6259,11 @@ namespace vk return m_applicationInfo.applicationVersion; } + uint32_t& applicationVersion() + { + return m_applicationInfo.applicationVersion; + } + ApplicationInfo& applicationVersion( uint32_t applicationVersion ) { m_applicationInfo.applicationVersion = applicationVersion; @@ -5455,6 +6275,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; @@ -5466,6 +6291,11 @@ namespace vk return m_applicationInfo.engineVersion; } + uint32_t& engineVersion() + { + return m_applicationInfo.engineVersion; + } + ApplicationInfo& engineVersion( uint32_t engineVersion ) { m_applicationInfo.engineVersion = engineVersion; @@ -5477,6 +6307,11 @@ namespace vk return m_applicationInfo.apiVersion; } + uint32_t& apiVersion() + { + return m_applicationInfo.apiVersion; + } + ApplicationInfo& apiVersion( uint32_t apiVersion ) { m_applicationInfo.apiVersion = apiVersion; @@ -5531,6 +6366,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 ); @@ -5542,6 +6382,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; @@ -5553,6 +6398,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 ); @@ -5564,6 +6414,11 @@ namespace vk return m_deviceQueueCreateInfo.queueFamilyIndex; } + uint32_t& queueFamilyIndex() + { + return m_deviceQueueCreateInfo.queueFamilyIndex; + } + DeviceQueueCreateInfo& queueFamilyIndex( uint32_t queueFamilyIndex ) { m_deviceQueueCreateInfo.queueFamilyIndex = queueFamilyIndex; @@ -5575,6 +6430,11 @@ namespace vk return m_deviceQueueCreateInfo.queueCount; } + uint32_t& queueCount() + { + return m_deviceQueueCreateInfo.queueCount; + } + DeviceQueueCreateInfo& queueCount( uint32_t queueCount ) { m_deviceQueueCreateInfo.queueCount = queueCount; @@ -5586,6 +6446,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; @@ -5644,6 +6509,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 ); @@ -5655,6 +6525,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; @@ -5666,6 +6541,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 ); @@ -5677,6 +6557,11 @@ namespace vk return m_deviceCreateInfo.queueCreateInfoCount; } + uint32_t& queueCreateInfoCount() + { + return m_deviceCreateInfo.queueCreateInfoCount; + } + DeviceCreateInfo& queueCreateInfoCount( uint32_t queueCreateInfoCount ) { m_deviceCreateInfo.queueCreateInfoCount = queueCreateInfoCount; @@ -5688,6 +6573,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 ); @@ -5699,6 +6589,11 @@ namespace vk return m_deviceCreateInfo.enabledLayerCount; } + uint32_t& enabledLayerCount() + { + return m_deviceCreateInfo.enabledLayerCount; + } + DeviceCreateInfo& enabledLayerCount( uint32_t enabledLayerCount ) { m_deviceCreateInfo.enabledLayerCount = enabledLayerCount; @@ -5710,6 +6605,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; @@ -5721,6 +6621,11 @@ namespace vk return m_deviceCreateInfo.enabledExtensionCount; } + uint32_t& enabledExtensionCount() + { + return m_deviceCreateInfo.enabledExtensionCount; + } + DeviceCreateInfo& enabledExtensionCount( uint32_t enabledExtensionCount ) { m_deviceCreateInfo.enabledExtensionCount = enabledExtensionCount; @@ -5732,6 +6637,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; @@ -5743,6 +6653,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 ); @@ -5799,6 +6714,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 ); @@ -5810,6 +6730,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; @@ -5821,6 +6746,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 ); @@ -5832,6 +6762,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 ); @@ -5843,6 +6778,11 @@ namespace vk return m_instanceCreateInfo.enabledLayerCount; } + uint32_t& enabledLayerCount() + { + return m_instanceCreateInfo.enabledLayerCount; + } + InstanceCreateInfo& enabledLayerCount( uint32_t enabledLayerCount ) { m_instanceCreateInfo.enabledLayerCount = enabledLayerCount; @@ -5854,6 +6794,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; @@ -5865,6 +6810,11 @@ namespace vk return m_instanceCreateInfo.enabledExtensionCount; } + uint32_t& enabledExtensionCount() + { + return m_instanceCreateInfo.enabledExtensionCount; + } + InstanceCreateInfo& enabledExtensionCount( uint32_t enabledExtensionCount ) { m_instanceCreateInfo.enabledExtensionCount = enabledExtensionCount; @@ -5876,6 +6826,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; @@ -5928,6 +6883,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 ); @@ -5939,6 +6899,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; @@ -5950,6 +6915,11 @@ namespace vk return m_memoryAllocateInfo.allocationSize; } + DeviceSize& allocationSize() + { + return m_memoryAllocateInfo.allocationSize; + } + MemoryAllocateInfo& allocationSize( DeviceSize allocationSize ) { m_memoryAllocateInfo.allocationSize = allocationSize; @@ -5961,6 +6931,11 @@ namespace vk return m_memoryAllocateInfo.memoryTypeIndex; } + uint32_t& memoryTypeIndex() + { + return m_memoryAllocateInfo.memoryTypeIndex; + } + MemoryAllocateInfo& memoryTypeIndex( uint32_t memoryTypeIndex ) { m_memoryAllocateInfo.memoryTypeIndex = memoryTypeIndex; @@ -6014,6 +6989,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 ); @@ -6025,6 +7005,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; @@ -6036,6 +7021,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 ); @@ -6047,6 +7037,11 @@ namespace vk return m_mappedMemoryRange.offset; } + DeviceSize& offset() + { + return m_mappedMemoryRange.offset; + } + MappedMemoryRange& offset( DeviceSize offset ) { m_mappedMemoryRange.offset = offset; @@ -6058,6 +7053,11 @@ namespace vk return m_mappedMemoryRange.size; } + DeviceSize& size() + { + return m_mappedMemoryRange.size; + } + MappedMemoryRange& size( DeviceSize size ) { m_mappedMemoryRange.size = size; @@ -6116,6 +7116,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 ); @@ -6127,6 +7132,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; @@ -6138,6 +7148,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 ); @@ -6149,6 +7164,11 @@ namespace vk return m_writeDescriptorSet.dstBinding; } + uint32_t& dstBinding() + { + return m_writeDescriptorSet.dstBinding; + } + WriteDescriptorSet& dstBinding( uint32_t dstBinding ) { m_writeDescriptorSet.dstBinding = dstBinding; @@ -6160,6 +7180,11 @@ namespace vk return m_writeDescriptorSet.dstArrayElement; } + uint32_t& dstArrayElement() + { + return m_writeDescriptorSet.dstArrayElement; + } + WriteDescriptorSet& dstArrayElement( uint32_t dstArrayElement ) { m_writeDescriptorSet.dstArrayElement = dstArrayElement; @@ -6171,6 +7196,11 @@ namespace vk return m_writeDescriptorSet.descriptorCount; } + uint32_t& descriptorCount() + { + return m_writeDescriptorSet.descriptorCount; + } + WriteDescriptorSet& descriptorCount( uint32_t descriptorCount ) { m_writeDescriptorSet.descriptorCount = descriptorCount; @@ -6182,6 +7212,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 ); @@ -6193,6 +7228,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 ); @@ -6204,6 +7244,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 ); @@ -6215,6 +7260,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 ); @@ -6272,6 +7322,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 ); @@ -6283,6 +7338,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; @@ -6294,6 +7354,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 ); @@ -6305,6 +7370,11 @@ namespace vk return m_copyDescriptorSet.srcBinding; } + uint32_t& srcBinding() + { + return m_copyDescriptorSet.srcBinding; + } + CopyDescriptorSet& srcBinding( uint32_t srcBinding ) { m_copyDescriptorSet.srcBinding = srcBinding; @@ -6316,6 +7386,11 @@ namespace vk return m_copyDescriptorSet.srcArrayElement; } + uint32_t& srcArrayElement() + { + return m_copyDescriptorSet.srcArrayElement; + } + CopyDescriptorSet& srcArrayElement( uint32_t srcArrayElement ) { m_copyDescriptorSet.srcArrayElement = srcArrayElement; @@ -6327,6 +7402,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 ); @@ -6338,6 +7418,11 @@ namespace vk return m_copyDescriptorSet.dstBinding; } + uint32_t& dstBinding() + { + return m_copyDescriptorSet.dstBinding; + } + CopyDescriptorSet& dstBinding( uint32_t dstBinding ) { m_copyDescriptorSet.dstBinding = dstBinding; @@ -6349,6 +7434,11 @@ namespace vk return m_copyDescriptorSet.dstArrayElement; } + uint32_t& dstArrayElement() + { + return m_copyDescriptorSet.dstArrayElement; + } + CopyDescriptorSet& dstArrayElement( uint32_t dstArrayElement ) { m_copyDescriptorSet.dstArrayElement = dstArrayElement; @@ -6360,6 +7450,11 @@ namespace vk return m_copyDescriptorSet.descriptorCount; } + uint32_t& descriptorCount() + { + return m_copyDescriptorSet.descriptorCount; + } + CopyDescriptorSet& descriptorCount( uint32_t descriptorCount ) { m_copyDescriptorSet.descriptorCount = descriptorCount; @@ -6415,6 +7510,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 ); @@ -6426,6 +7526,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; @@ -6437,6 +7542,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 ); @@ -6448,6 +7558,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 ); @@ -6459,6 +7574,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 ); @@ -6470,6 +7590,11 @@ namespace vk return m_bufferViewCreateInfo.offset; } + DeviceSize& offset() + { + return m_bufferViewCreateInfo.offset; + } + BufferViewCreateInfo& offset( DeviceSize offset ) { m_bufferViewCreateInfo.offset = offset; @@ -6481,6 +7606,11 @@ namespace vk return m_bufferViewCreateInfo.range; } + DeviceSize& range() + { + return m_bufferViewCreateInfo.range; + } + BufferViewCreateInfo& range( DeviceSize range ) { m_bufferViewCreateInfo.range = range; @@ -6534,6 +7664,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 ); @@ -6545,6 +7680,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; @@ -6556,6 +7696,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 ); @@ -6567,6 +7712,11 @@ namespace vk return m_shaderModuleCreateInfo.codeSize; } + size_t& codeSize() + { + return m_shaderModuleCreateInfo.codeSize; + } + ShaderModuleCreateInfo& codeSize( size_t codeSize ) { m_shaderModuleCreateInfo.codeSize = codeSize; @@ -6578,6 +7728,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; @@ -6631,6 +7786,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 ); @@ -6642,6 +7802,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; @@ -6653,6 +7818,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 ); @@ -6664,6 +7834,11 @@ namespace vk return m_descriptorSetAllocateInfo.descriptorSetCount; } + uint32_t& descriptorSetCount() + { + return m_descriptorSetAllocateInfo.descriptorSetCount; + } + DescriptorSetAllocateInfo& descriptorSetCount( uint32_t descriptorSetCount ) { m_descriptorSetAllocateInfo.descriptorSetCount = descriptorSetCount; @@ -6675,6 +7850,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 ); @@ -6730,6 +7910,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 ); @@ -6741,6 +7926,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; @@ -6752,6 +7942,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 ); @@ -6763,6 +7958,11 @@ namespace vk return m_pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount; } + uint32_t& vertexBindingDescriptionCount() + { + return m_pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount; + } + PipelineVertexInputStateCreateInfo& vertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount ) { m_pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount = vertexBindingDescriptionCount; @@ -6774,6 +7974,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 ); @@ -6785,6 +7990,11 @@ namespace vk return m_pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount; } + uint32_t& vertexAttributeDescriptionCount() + { + return m_pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount; + } + PipelineVertexInputStateCreateInfo& vertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount ) { m_pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount = vertexAttributeDescriptionCount; @@ -6796,6 +8006,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 ); @@ -6849,6 +8064,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 ); @@ -6860,6 +8080,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; @@ -6871,6 +8096,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 ); @@ -6882,6 +8112,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 ); @@ -6893,6 +8128,11 @@ namespace vk return m_pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable; } + Bool32& primitiveRestartEnable() + { + return m_pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable; + } + PipelineInputAssemblyStateCreateInfo& primitiveRestartEnable( Bool32 primitiveRestartEnable ) { m_pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable = primitiveRestartEnable; @@ -6945,6 +8185,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 ); @@ -6956,6 +8201,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; @@ -6967,6 +8217,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 ); @@ -6978,6 +8233,11 @@ namespace vk return m_pipelineTessellationStateCreateInfo.patchControlPoints; } + uint32_t& patchControlPoints() + { + return m_pipelineTessellationStateCreateInfo.patchControlPoints; + } + PipelineTessellationStateCreateInfo& patchControlPoints( uint32_t patchControlPoints ) { m_pipelineTessellationStateCreateInfo.patchControlPoints = patchControlPoints; @@ -7033,6 +8293,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 ); @@ -7044,6 +8309,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; @@ -7055,6 +8325,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 ); @@ -7066,6 +8341,11 @@ namespace vk return m_pipelineViewportStateCreateInfo.viewportCount; } + uint32_t& viewportCount() + { + return m_pipelineViewportStateCreateInfo.viewportCount; + } + PipelineViewportStateCreateInfo& viewportCount( uint32_t viewportCount ) { m_pipelineViewportStateCreateInfo.viewportCount = viewportCount; @@ -7077,6 +8357,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 ); @@ -7088,6 +8373,11 @@ namespace vk return m_pipelineViewportStateCreateInfo.scissorCount; } + uint32_t& scissorCount() + { + return m_pipelineViewportStateCreateInfo.scissorCount; + } + PipelineViewportStateCreateInfo& scissorCount( uint32_t scissorCount ) { m_pipelineViewportStateCreateInfo.scissorCount = scissorCount; @@ -7099,6 +8389,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 ); @@ -7160,6 +8455,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 ); @@ -7171,6 +8471,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; @@ -7182,6 +8487,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 ); @@ -7193,6 +8503,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthClampEnable; } + Bool32& depthClampEnable() + { + return m_pipelineRasterizationStateCreateInfo.depthClampEnable; + } + PipelineRasterizationStateCreateInfo& depthClampEnable( Bool32 depthClampEnable ) { m_pipelineRasterizationStateCreateInfo.depthClampEnable = depthClampEnable; @@ -7204,6 +8519,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable; } + Bool32& rasterizerDiscardEnable() + { + return m_pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable; + } + PipelineRasterizationStateCreateInfo& rasterizerDiscardEnable( Bool32 rasterizerDiscardEnable ) { m_pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable = rasterizerDiscardEnable; @@ -7215,6 +8535,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 ); @@ -7226,6 +8551,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 ); @@ -7237,6 +8567,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 ); @@ -7248,6 +8583,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthBiasEnable; } + Bool32& depthBiasEnable() + { + return m_pipelineRasterizationStateCreateInfo.depthBiasEnable; + } + PipelineRasterizationStateCreateInfo& depthBiasEnable( Bool32 depthBiasEnable ) { m_pipelineRasterizationStateCreateInfo.depthBiasEnable = depthBiasEnable; @@ -7259,6 +8599,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthBiasConstantFactor; } + float& depthBiasConstantFactor() + { + return m_pipelineRasterizationStateCreateInfo.depthBiasConstantFactor; + } + PipelineRasterizationStateCreateInfo& depthBiasConstantFactor( float depthBiasConstantFactor ) { m_pipelineRasterizationStateCreateInfo.depthBiasConstantFactor = depthBiasConstantFactor; @@ -7270,6 +8615,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthBiasClamp; } + float& depthBiasClamp() + { + return m_pipelineRasterizationStateCreateInfo.depthBiasClamp; + } + PipelineRasterizationStateCreateInfo& depthBiasClamp( float depthBiasClamp ) { m_pipelineRasterizationStateCreateInfo.depthBiasClamp = depthBiasClamp; @@ -7281,6 +8631,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor; } + float& depthBiasSlopeFactor() + { + return m_pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor; + } + PipelineRasterizationStateCreateInfo& depthBiasSlopeFactor( float depthBiasSlopeFactor ) { m_pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor = depthBiasSlopeFactor; @@ -7292,6 +8647,11 @@ namespace vk return m_pipelineRasterizationStateCreateInfo.lineWidth; } + float& lineWidth() + { + return m_pipelineRasterizationStateCreateInfo.lineWidth; + } + PipelineRasterizationStateCreateInfo& lineWidth( float lineWidth ) { m_pipelineRasterizationStateCreateInfo.lineWidth = lineWidth; @@ -7352,6 +8712,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 ); @@ -7363,6 +8728,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; @@ -7374,6 +8744,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 ); @@ -7385,6 +8760,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.depthTestEnable; } + Bool32& depthTestEnable() + { + return m_pipelineDepthStencilStateCreateInfo.depthTestEnable; + } + PipelineDepthStencilStateCreateInfo& depthTestEnable( Bool32 depthTestEnable ) { m_pipelineDepthStencilStateCreateInfo.depthTestEnable = depthTestEnable; @@ -7396,6 +8776,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.depthWriteEnable; } + Bool32& depthWriteEnable() + { + return m_pipelineDepthStencilStateCreateInfo.depthWriteEnable; + } + PipelineDepthStencilStateCreateInfo& depthWriteEnable( Bool32 depthWriteEnable ) { m_pipelineDepthStencilStateCreateInfo.depthWriteEnable = depthWriteEnable; @@ -7407,6 +8792,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 ); @@ -7418,6 +8808,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable; } + Bool32& depthBoundsTestEnable() + { + return m_pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable; + } + PipelineDepthStencilStateCreateInfo& depthBoundsTestEnable( Bool32 depthBoundsTestEnable ) { m_pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable = depthBoundsTestEnable; @@ -7429,6 +8824,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.stencilTestEnable; } + Bool32& stencilTestEnable() + { + return m_pipelineDepthStencilStateCreateInfo.stencilTestEnable; + } + PipelineDepthStencilStateCreateInfo& stencilTestEnable( Bool32 stencilTestEnable ) { m_pipelineDepthStencilStateCreateInfo.stencilTestEnable = stencilTestEnable; @@ -7440,6 +8840,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 ); @@ -7451,6 +8856,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 ); @@ -7462,6 +8872,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.minDepthBounds; } + float& minDepthBounds() + { + return m_pipelineDepthStencilStateCreateInfo.minDepthBounds; + } + PipelineDepthStencilStateCreateInfo& minDepthBounds( float minDepthBounds ) { m_pipelineDepthStencilStateCreateInfo.minDepthBounds = minDepthBounds; @@ -7473,6 +8888,11 @@ namespace vk return m_pipelineDepthStencilStateCreateInfo.maxDepthBounds; } + float& maxDepthBounds() + { + return m_pipelineDepthStencilStateCreateInfo.maxDepthBounds; + } + PipelineDepthStencilStateCreateInfo& maxDepthBounds( float maxDepthBounds ) { m_pipelineDepthStencilStateCreateInfo.maxDepthBounds = maxDepthBounds; @@ -7526,6 +8946,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 ); @@ -7537,6 +8962,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; @@ -7548,6 +8978,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 ); @@ -7559,6 +8994,11 @@ namespace vk return m_pipelineCacheCreateInfo.initialDataSize; } + size_t& initialDataSize() + { + return m_pipelineCacheCreateInfo.initialDataSize; + } + PipelineCacheCreateInfo& initialDataSize( size_t initialDataSize ) { m_pipelineCacheCreateInfo.initialDataSize = initialDataSize; @@ -7570,6 +9010,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; @@ -7636,6 +9081,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 ); @@ -7647,6 +9097,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; @@ -7658,6 +9113,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 ); @@ -7669,6 +9129,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 ); @@ -7680,6 +9145,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 ); @@ -7691,6 +9161,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 ); @@ -7702,6 +9177,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 ); @@ -7713,6 +9193,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 ); @@ -7724,6 +9209,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 ); @@ -7735,6 +9225,11 @@ namespace vk return m_samplerCreateInfo.mipLodBias; } + float& mipLodBias() + { + return m_samplerCreateInfo.mipLodBias; + } + SamplerCreateInfo& mipLodBias( float mipLodBias ) { m_samplerCreateInfo.mipLodBias = mipLodBias; @@ -7746,6 +9241,11 @@ namespace vk return m_samplerCreateInfo.anisotropyEnable; } + Bool32& anisotropyEnable() + { + return m_samplerCreateInfo.anisotropyEnable; + } + SamplerCreateInfo& anisotropyEnable( Bool32 anisotropyEnable ) { m_samplerCreateInfo.anisotropyEnable = anisotropyEnable; @@ -7757,6 +9257,11 @@ namespace vk return m_samplerCreateInfo.maxAnisotropy; } + float& maxAnisotropy() + { + return m_samplerCreateInfo.maxAnisotropy; + } + SamplerCreateInfo& maxAnisotropy( float maxAnisotropy ) { m_samplerCreateInfo.maxAnisotropy = maxAnisotropy; @@ -7768,6 +9273,11 @@ namespace vk return m_samplerCreateInfo.compareEnable; } + Bool32& compareEnable() + { + return m_samplerCreateInfo.compareEnable; + } + SamplerCreateInfo& compareEnable( Bool32 compareEnable ) { m_samplerCreateInfo.compareEnable = compareEnable; @@ -7779,6 +9289,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 ); @@ -7790,6 +9305,11 @@ namespace vk return m_samplerCreateInfo.minLod; } + float& minLod() + { + return m_samplerCreateInfo.minLod; + } + SamplerCreateInfo& minLod( float minLod ) { m_samplerCreateInfo.minLod = minLod; @@ -7801,6 +9321,11 @@ namespace vk return m_samplerCreateInfo.maxLod; } + float& maxLod() + { + return m_samplerCreateInfo.maxLod; + } + SamplerCreateInfo& maxLod( float maxLod ) { m_samplerCreateInfo.maxLod = maxLod; @@ -7812,6 +9337,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 ); @@ -7823,6 +9353,11 @@ namespace vk return m_samplerCreateInfo.unnormalizedCoordinates; } + Bool32& unnormalizedCoordinates() + { + return m_samplerCreateInfo.unnormalizedCoordinates; + } + SamplerCreateInfo& unnormalizedCoordinates( Bool32 unnormalizedCoordinates ) { m_samplerCreateInfo.unnormalizedCoordinates = unnormalizedCoordinates; @@ -7876,6 +9411,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 ); @@ -7887,6 +9427,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; @@ -7898,6 +9443,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 ); @@ -7909,6 +9459,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 ); @@ -7920,6 +9475,11 @@ namespace vk return m_commandBufferAllocateInfo.commandBufferCount; } + uint32_t& commandBufferCount() + { + return m_commandBufferAllocateInfo.commandBufferCount; + } + CommandBufferAllocateInfo& commandBufferCount( uint32_t commandBufferCount ) { m_commandBufferAllocateInfo.commandBufferCount = commandBufferCount; @@ -7975,6 +9535,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 ); @@ -7986,6 +9551,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; @@ -7997,6 +9567,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 ); @@ -8008,6 +9583,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 ); @@ -8019,6 +9599,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 ); @@ -8030,6 +9615,11 @@ namespace vk return m_renderPassBeginInfo.clearValueCount; } + uint32_t& clearValueCount() + { + return m_renderPassBeginInfo.clearValueCount; + } + RenderPassBeginInfo& clearValueCount( uint32_t clearValueCount ) { m_renderPassBeginInfo.clearValueCount = clearValueCount; @@ -8041,6 +9631,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 ); @@ -8092,6 +9687,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 ); @@ -8103,6 +9703,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; @@ -8114,6 +9719,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 ); @@ -8165,6 +9775,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 ); @@ -8176,6 +9791,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; @@ -8187,6 +9807,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 ); @@ -8244,6 +9869,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 ); @@ -8255,6 +9885,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; @@ -8266,6 +9901,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 ); @@ -8277,6 +9917,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 ); @@ -8288,6 +9933,11 @@ namespace vk return m_framebufferCreateInfo.attachmentCount; } + uint32_t& attachmentCount() + { + return m_framebufferCreateInfo.attachmentCount; + } + FramebufferCreateInfo& attachmentCount( uint32_t attachmentCount ) { m_framebufferCreateInfo.attachmentCount = attachmentCount; @@ -8299,6 +9949,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 ); @@ -8310,6 +9965,11 @@ namespace vk return m_framebufferCreateInfo.width; } + uint32_t& width() + { + return m_framebufferCreateInfo.width; + } + FramebufferCreateInfo& width( uint32_t width ) { m_framebufferCreateInfo.width = width; @@ -8321,6 +9981,11 @@ namespace vk return m_framebufferCreateInfo.height; } + uint32_t& height() + { + return m_framebufferCreateInfo.height; + } + FramebufferCreateInfo& height( uint32_t height ) { m_framebufferCreateInfo.height = height; @@ -8332,6 +9997,11 @@ namespace vk return m_framebufferCreateInfo.layers; } + uint32_t& layers() + { + return m_framebufferCreateInfo.layers; + } + FramebufferCreateInfo& layers( uint32_t layers ) { m_framebufferCreateInfo.layers = layers; @@ -8384,6 +10054,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 ); @@ -8395,6 +10070,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; @@ -8406,6 +10086,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 ); @@ -8417,6 +10102,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 ); @@ -8470,6 +10160,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 ); @@ -8481,6 +10176,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; @@ -8492,6 +10192,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 ); @@ -8503,6 +10208,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 ); @@ -8514,6 +10224,11 @@ namespace vk return m_displayPresentInfoKHR.persistent; } + Bool32& persistent() + { + return m_displayPresentInfoKHR.persistent; + } + DisplayPresentInfoKHR& persistent( Bool32 persistent ) { m_displayPresentInfoKHR.persistent = persistent; @@ -8567,6 +10282,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 ); @@ -8578,6 +10298,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; @@ -8589,6 +10314,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 ); @@ -8596,6 +10326,11 @@ namespace vk } const ANativeWindow* window() const + { + return reinterpret_cast( m_androidSurfaceCreateInfoKHR.window ); + } + + ANativeWindow* window() { return reinterpret_cast( m_androidSurfaceCreateInfoKHR.window ); } @@ -8655,6 +10390,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 ); @@ -8666,6 +10406,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; @@ -8677,6 +10422,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 ); @@ -8684,6 +10434,11 @@ namespace vk } const MirConnection* connection() const + { + return reinterpret_cast( m_mirSurfaceCreateInfoKHR.connection ); + } + + MirConnection* connection() { return reinterpret_cast( m_mirSurfaceCreateInfoKHR.connection ); } @@ -8695,6 +10450,11 @@ namespace vk } const MirSurface* mirSurface() const + { + return reinterpret_cast( m_mirSurfaceCreateInfoKHR.mirSurface ); + } + + MirSurface* mirSurface() { return reinterpret_cast( m_mirSurfaceCreateInfoKHR.mirSurface ); } @@ -8754,6 +10514,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 ); @@ -8765,6 +10530,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; @@ -8776,6 +10546,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 ); @@ -8783,6 +10558,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 ); } @@ -8794,6 +10574,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 ); } @@ -8853,6 +10638,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 ); @@ -8864,6 +10654,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; @@ -8875,6 +10670,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 ); @@ -8886,6 +10686,11 @@ namespace vk return m_win32SurfaceCreateInfoKHR.hinstance; } + HINSTANCE& hinstance() + { + return m_win32SurfaceCreateInfoKHR.hinstance; + } + Win32SurfaceCreateInfoKHR& hinstance( HINSTANCE hinstance ) { m_win32SurfaceCreateInfoKHR.hinstance = hinstance; @@ -8897,6 +10702,11 @@ namespace vk return m_win32SurfaceCreateInfoKHR.hwnd; } + HWND& hwnd() + { + return m_win32SurfaceCreateInfoKHR.hwnd; + } + Win32SurfaceCreateInfoKHR& hwnd( HWND hwnd ) { m_win32SurfaceCreateInfoKHR.hwnd = hwnd; @@ -8952,6 +10762,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 ); @@ -8963,6 +10778,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; @@ -8974,6 +10794,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 ); @@ -8981,6 +10806,11 @@ namespace vk } const Display* dpy() const + { + return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.dpy ); + } + + Display* dpy() { return reinterpret_cast( m_xlibSurfaceCreateInfoKHR.dpy ); } @@ -8996,6 +10826,11 @@ namespace vk return m_xlibSurfaceCreateInfoKHR.window; } + Window& window() + { + return m_xlibSurfaceCreateInfoKHR.window; + } + XlibSurfaceCreateInfoKHR& window( Window window ) { m_xlibSurfaceCreateInfoKHR.window = window; @@ -9051,6 +10886,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 ); @@ -9062,6 +10902,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; @@ -9073,6 +10918,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 ); @@ -9080,6 +10930,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 ); } @@ -9095,6 +10950,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; @@ -9185,6 +11045,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 ); @@ -9196,6 +11061,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; @@ -9207,6 +11077,11 @@ namespace vk return m_presentInfoKHR.waitSemaphoreCount; } + uint32_t& waitSemaphoreCount() + { + return m_presentInfoKHR.waitSemaphoreCount; + } + PresentInfoKHR& waitSemaphoreCount( uint32_t waitSemaphoreCount ) { m_presentInfoKHR.waitSemaphoreCount = waitSemaphoreCount; @@ -9218,6 +11093,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 ); @@ -9229,6 +11109,11 @@ namespace vk return m_presentInfoKHR.swapchainCount; } + uint32_t& swapchainCount() + { + return m_presentInfoKHR.swapchainCount; + } + PresentInfoKHR& swapchainCount( uint32_t swapchainCount ) { m_presentInfoKHR.swapchainCount = swapchainCount; @@ -9240,6 +11125,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 ); @@ -9251,6 +11141,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; @@ -9258,6 +11153,11 @@ namespace vk } const Result* pResults() const + { + return reinterpret_cast( m_presentInfoKHR.pResults ); + } + + Result* pResults() { return reinterpret_cast( m_presentInfoKHR.pResults ); } @@ -9328,6 +11228,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 ); @@ -9339,6 +11244,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; @@ -9350,6 +11260,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 ); @@ -9361,6 +11276,11 @@ namespace vk return m_pipelineDynamicStateCreateInfo.dynamicStateCount; } + uint32_t& dynamicStateCount() + { + return m_pipelineDynamicStateCreateInfo.dynamicStateCount; + } + PipelineDynamicStateCreateInfo& dynamicStateCount( uint32_t dynamicStateCount ) { m_pipelineDynamicStateCreateInfo.dynamicStateCount = dynamicStateCount; @@ -9372,6 +11292,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 ); @@ -9627,6 +11552,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 ); @@ -9638,6 +11568,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; @@ -9649,6 +11584,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 ); @@ -9660,6 +11600,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 ); @@ -9717,6 +11662,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 ); @@ -9728,6 +11678,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; @@ -9739,6 +11694,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 ); @@ -9750,6 +11710,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 ); @@ -9761,6 +11726,11 @@ namespace vk return m_bufferMemoryBarrier.srcQueueFamilyIndex; } + uint32_t& srcQueueFamilyIndex() + { + return m_bufferMemoryBarrier.srcQueueFamilyIndex; + } + BufferMemoryBarrier& srcQueueFamilyIndex( uint32_t srcQueueFamilyIndex ) { m_bufferMemoryBarrier.srcQueueFamilyIndex = srcQueueFamilyIndex; @@ -9772,6 +11742,11 @@ namespace vk return m_bufferMemoryBarrier.dstQueueFamilyIndex; } + uint32_t& dstQueueFamilyIndex() + { + return m_bufferMemoryBarrier.dstQueueFamilyIndex; + } + BufferMemoryBarrier& dstQueueFamilyIndex( uint32_t dstQueueFamilyIndex ) { m_bufferMemoryBarrier.dstQueueFamilyIndex = dstQueueFamilyIndex; @@ -9783,6 +11758,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 ); @@ -9794,6 +11774,11 @@ namespace vk return m_bufferMemoryBarrier.offset; } + DeviceSize& offset() + { + return m_bufferMemoryBarrier.offset; + } + BufferMemoryBarrier& offset( DeviceSize offset ) { m_bufferMemoryBarrier.offset = offset; @@ -9805,6 +11790,11 @@ namespace vk return m_bufferMemoryBarrier.size; } + DeviceSize& size() + { + return m_bufferMemoryBarrier.size; + } + BufferMemoryBarrier& size( DeviceSize size ) { m_bufferMemoryBarrier.size = size; @@ -9895,6 +11885,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 ); @@ -9906,6 +11901,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; @@ -9917,6 +11917,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 ); @@ -9928,6 +11933,11 @@ namespace vk return m_bufferCreateInfo.size; } + DeviceSize& size() + { + return m_bufferCreateInfo.size; + } + BufferCreateInfo& size( DeviceSize size ) { m_bufferCreateInfo.size = size; @@ -9939,6 +11949,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 ); @@ -9950,6 +11965,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 ); @@ -9961,6 +11981,11 @@ namespace vk return m_bufferCreateInfo.queueFamilyIndexCount; } + uint32_t& queueFamilyIndexCount() + { + return m_bufferCreateInfo.queueFamilyIndexCount; + } + BufferCreateInfo& queueFamilyIndexCount( uint32_t queueFamilyIndexCount ) { m_bufferCreateInfo.queueFamilyIndexCount = queueFamilyIndexCount; @@ -9972,6 +11997,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; @@ -10044,6 +12074,11 @@ namespace vk return m_descriptorSetLayoutBinding.binding; } + uint32_t& binding() + { + return m_descriptorSetLayoutBinding.binding; + } + DescriptorSetLayoutBinding& binding( uint32_t binding ) { m_descriptorSetLayoutBinding.binding = binding; @@ -10055,6 +12090,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 ); @@ -10066,6 +12106,11 @@ namespace vk return m_descriptorSetLayoutBinding.descriptorCount; } + uint32_t& descriptorCount() + { + return m_descriptorSetLayoutBinding.descriptorCount; + } + DescriptorSetLayoutBinding& descriptorCount( uint32_t descriptorCount ) { m_descriptorSetLayoutBinding.descriptorCount = descriptorCount; @@ -10077,6 +12122,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 ); @@ -10088,6 +12138,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 ); @@ -10141,6 +12196,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 ); @@ -10152,6 +12212,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; @@ -10163,6 +12228,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 ); @@ -10174,6 +12244,11 @@ namespace vk return m_descriptorSetLayoutCreateInfo.bindingCount; } + uint32_t& bindingCount() + { + return m_descriptorSetLayoutCreateInfo.bindingCount; + } + DescriptorSetLayoutCreateInfo& bindingCount( uint32_t bindingCount ) { m_descriptorSetLayoutCreateInfo.bindingCount = bindingCount; @@ -10185,6 +12260,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 ); @@ -10240,6 +12320,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 ); @@ -10251,6 +12336,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; @@ -10262,6 +12352,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 ); @@ -10273,6 +12368,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 ); @@ -10284,6 +12384,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 ); @@ -10295,6 +12400,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; @@ -10306,6 +12416,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 ); @@ -10357,6 +12472,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 ); @@ -10368,6 +12488,11 @@ namespace vk return m_pushConstantRange.offset; } + uint32_t& offset() + { + return m_pushConstantRange.offset; + } + PushConstantRange& offset( uint32_t offset ) { m_pushConstantRange.offset = offset; @@ -10379,6 +12504,11 @@ namespace vk return m_pushConstantRange.size; } + uint32_t& size() + { + return m_pushConstantRange.size; + } + PushConstantRange& size( uint32_t size ) { m_pushConstantRange.size = size; @@ -10434,6 +12564,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 ); @@ -10445,6 +12580,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; @@ -10456,6 +12596,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 ); @@ -10467,6 +12612,11 @@ namespace vk return m_pipelineLayoutCreateInfo.setLayoutCount; } + uint32_t& setLayoutCount() + { + return m_pipelineLayoutCreateInfo.setLayoutCount; + } + PipelineLayoutCreateInfo& setLayoutCount( uint32_t setLayoutCount ) { m_pipelineLayoutCreateInfo.setLayoutCount = setLayoutCount; @@ -10478,6 +12628,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 ); @@ -10489,6 +12644,11 @@ namespace vk return m_pipelineLayoutCreateInfo.pushConstantRangeCount; } + uint32_t& pushConstantRangeCount() + { + return m_pipelineLayoutCreateInfo.pushConstantRangeCount; + } + PipelineLayoutCreateInfo& pushConstantRangeCount( uint32_t pushConstantRangeCount ) { m_pipelineLayoutCreateInfo.pushConstantRangeCount = pushConstantRangeCount; @@ -10500,6 +12660,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 ); @@ -10604,6 +12769,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 ); @@ -10615,6 +12785,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; @@ -10626,6 +12801,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 ); @@ -10637,6 +12817,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 ); @@ -10648,6 +12833,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 ); @@ -10659,6 +12849,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 ); @@ -10670,6 +12865,11 @@ namespace vk return m_computePipelineCreateInfo.basePipelineIndex; } + int32_t& basePipelineIndex() + { + return m_computePipelineCreateInfo.basePipelineIndex; + } + ComputePipelineCreateInfo& basePipelineIndex( int32_t basePipelineIndex ) { m_computePipelineCreateInfo.basePipelineIndex = basePipelineIndex; @@ -10741,6 +12941,11 @@ namespace vk return m_pipelineColorBlendAttachmentState.blendEnable; } + Bool32& blendEnable() + { + return m_pipelineColorBlendAttachmentState.blendEnable; + } + PipelineColorBlendAttachmentState& blendEnable( Bool32 blendEnable ) { m_pipelineColorBlendAttachmentState.blendEnable = blendEnable; @@ -10752,6 +12957,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 ); @@ -10763,6 +12973,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 ); @@ -10774,6 +12989,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 ); @@ -10785,6 +13005,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 ); @@ -10796,6 +13021,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 ); @@ -10807,6 +13037,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 ); @@ -10818,6 +13053,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 ); @@ -10874,6 +13114,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 ); @@ -10885,6 +13130,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; @@ -10896,6 +13146,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 ); @@ -10907,6 +13162,11 @@ namespace vk return m_pipelineColorBlendStateCreateInfo.logicOpEnable; } + Bool32& logicOpEnable() + { + return m_pipelineColorBlendStateCreateInfo.logicOpEnable; + } + PipelineColorBlendStateCreateInfo& logicOpEnable( Bool32 logicOpEnable ) { m_pipelineColorBlendStateCreateInfo.logicOpEnable = logicOpEnable; @@ -10918,6 +13178,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 ); @@ -10929,6 +13194,11 @@ namespace vk return m_pipelineColorBlendStateCreateInfo.attachmentCount; } + uint32_t& attachmentCount() + { + return m_pipelineColorBlendStateCreateInfo.attachmentCount; + } + PipelineColorBlendStateCreateInfo& attachmentCount( uint32_t attachmentCount ) { m_pipelineColorBlendStateCreateInfo.attachmentCount = attachmentCount; @@ -10940,6 +13210,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 ); @@ -10951,6 +13226,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 ) ); @@ -11014,6 +13294,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 ); @@ -11025,6 +13310,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; @@ -11036,6 +13326,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 ); @@ -11212,6 +13507,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 ); @@ -11223,6 +13523,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; @@ -11234,6 +13539,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 ); @@ -11245,6 +13555,11 @@ namespace vk return m_commandBufferInheritanceInfo.subpass; } + uint32_t& subpass() + { + return m_commandBufferInheritanceInfo.subpass; + } + CommandBufferInheritanceInfo& subpass( uint32_t subpass ) { m_commandBufferInheritanceInfo.subpass = subpass; @@ -11256,6 +13571,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 ); @@ -11267,6 +13587,11 @@ namespace vk return m_commandBufferInheritanceInfo.occlusionQueryEnable; } + Bool32& occlusionQueryEnable() + { + return m_commandBufferInheritanceInfo.occlusionQueryEnable; + } + CommandBufferInheritanceInfo& occlusionQueryEnable( Bool32 occlusionQueryEnable ) { m_commandBufferInheritanceInfo.occlusionQueryEnable = occlusionQueryEnable; @@ -11278,6 +13603,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 ); @@ -11289,6 +13619,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 ); @@ -11341,6 +13676,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 ); @@ -11352,6 +13692,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; @@ -11363,6 +13708,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 ); @@ -11374,6 +13724,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 ); @@ -11428,6 +13783,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 ); @@ -11439,6 +13799,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; @@ -11450,6 +13815,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 ); @@ -11461,6 +13831,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 ); @@ -11472,6 +13847,11 @@ namespace vk return m_queryPoolCreateInfo.queryCount; } + uint32_t& queryCount() + { + return m_queryPoolCreateInfo.queryCount; + } + QueryPoolCreateInfo& queryCount( uint32_t queryCount ) { m_queryPoolCreateInfo.queryCount = queryCount; @@ -11483,6 +13863,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 ); @@ -11549,6 +13934,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 ); @@ -11560,6 +13950,11 @@ namespace vk return m_imageSubresource.mipLevel; } + uint32_t& mipLevel() + { + return m_imageSubresource.mipLevel; + } + ImageSubresource& mipLevel( uint32_t mipLevel ) { m_imageSubresource.mipLevel = mipLevel; @@ -11571,6 +13966,11 @@ namespace vk return m_imageSubresource.arrayLayer; } + uint32_t& arrayLayer() + { + return m_imageSubresource.arrayLayer; + } + ImageSubresource& arrayLayer( uint32_t arrayLayer ) { m_imageSubresource.arrayLayer = arrayLayer; @@ -11623,6 +14023,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 ); @@ -11634,6 +14039,11 @@ namespace vk return m_imageSubresourceLayers.mipLevel; } + uint32_t& mipLevel() + { + return m_imageSubresourceLayers.mipLevel; + } + ImageSubresourceLayers& mipLevel( uint32_t mipLevel ) { m_imageSubresourceLayers.mipLevel = mipLevel; @@ -11645,6 +14055,11 @@ namespace vk return m_imageSubresourceLayers.baseArrayLayer; } + uint32_t& baseArrayLayer() + { + return m_imageSubresourceLayers.baseArrayLayer; + } + ImageSubresourceLayers& baseArrayLayer( uint32_t baseArrayLayer ) { m_imageSubresourceLayers.baseArrayLayer = baseArrayLayer; @@ -11656,6 +14071,11 @@ namespace vk return m_imageSubresourceLayers.layerCount; } + uint32_t& layerCount() + { + return m_imageSubresourceLayers.layerCount; + } + ImageSubresourceLayers& layerCount( uint32_t layerCount ) { m_imageSubresourceLayers.layerCount = layerCount; @@ -11709,6 +14129,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 ); @@ -11720,6 +14145,11 @@ namespace vk return m_imageSubresourceRange.baseMipLevel; } + uint32_t& baseMipLevel() + { + return m_imageSubresourceRange.baseMipLevel; + } + ImageSubresourceRange& baseMipLevel( uint32_t baseMipLevel ) { m_imageSubresourceRange.baseMipLevel = baseMipLevel; @@ -11731,6 +14161,11 @@ namespace vk return m_imageSubresourceRange.levelCount; } + uint32_t& levelCount() + { + return m_imageSubresourceRange.levelCount; + } + ImageSubresourceRange& levelCount( uint32_t levelCount ) { m_imageSubresourceRange.levelCount = levelCount; @@ -11742,6 +14177,11 @@ namespace vk return m_imageSubresourceRange.baseArrayLayer; } + uint32_t& baseArrayLayer() + { + return m_imageSubresourceRange.baseArrayLayer; + } + ImageSubresourceRange& baseArrayLayer( uint32_t baseArrayLayer ) { m_imageSubresourceRange.baseArrayLayer = baseArrayLayer; @@ -11753,6 +14193,11 @@ namespace vk return m_imageSubresourceRange.layerCount; } + uint32_t& layerCount() + { + return m_imageSubresourceRange.layerCount; + } + ImageSubresourceRange& layerCount( uint32_t layerCount ) { m_imageSubresourceRange.layerCount = layerCount; @@ -11811,6 +14256,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 ); @@ -11822,6 +14272,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; @@ -11833,6 +14288,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 ); @@ -11844,6 +14304,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 ); @@ -11855,6 +14320,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 ); @@ -11866,6 +14336,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 ); @@ -11877,6 +14352,11 @@ namespace vk return m_imageMemoryBarrier.srcQueueFamilyIndex; } + uint32_t& srcQueueFamilyIndex() + { + return m_imageMemoryBarrier.srcQueueFamilyIndex; + } + ImageMemoryBarrier& srcQueueFamilyIndex( uint32_t srcQueueFamilyIndex ) { m_imageMemoryBarrier.srcQueueFamilyIndex = srcQueueFamilyIndex; @@ -11888,6 +14368,11 @@ namespace vk return m_imageMemoryBarrier.dstQueueFamilyIndex; } + uint32_t& dstQueueFamilyIndex() + { + return m_imageMemoryBarrier.dstQueueFamilyIndex; + } + ImageMemoryBarrier& dstQueueFamilyIndex( uint32_t dstQueueFamilyIndex ) { m_imageMemoryBarrier.dstQueueFamilyIndex = dstQueueFamilyIndex; @@ -11899,6 +14384,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 ); @@ -11910,6 +14400,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 ); @@ -11966,6 +14461,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 ); @@ -11977,6 +14477,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; @@ -11988,6 +14493,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 ); @@ -11999,6 +14509,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 ); @@ -12010,6 +14525,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 ); @@ -12021,6 +14541,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 ); @@ -12032,6 +14557,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 ); @@ -12043,6 +14573,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 ); @@ -12096,6 +14631,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 ); @@ -12107,6 +14647,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 ); @@ -12118,6 +14663,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 ); @@ -12129,6 +14679,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 ); @@ -12140,6 +14695,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 ); @@ -12192,6 +14752,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 ); @@ -12203,6 +14768,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 ) ); @@ -12214,6 +14784,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 ); @@ -12225,6 +14800,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 ) ); @@ -12279,6 +14859,11 @@ namespace vk return m_bufferImageCopy.bufferOffset; } + DeviceSize& bufferOffset() + { + return m_bufferImageCopy.bufferOffset; + } + BufferImageCopy& bufferOffset( DeviceSize bufferOffset ) { m_bufferImageCopy.bufferOffset = bufferOffset; @@ -12290,6 +14875,11 @@ namespace vk return m_bufferImageCopy.bufferRowLength; } + uint32_t& bufferRowLength() + { + return m_bufferImageCopy.bufferRowLength; + } + BufferImageCopy& bufferRowLength( uint32_t bufferRowLength ) { m_bufferImageCopy.bufferRowLength = bufferRowLength; @@ -12301,6 +14891,11 @@ namespace vk return m_bufferImageCopy.bufferImageHeight; } + uint32_t& bufferImageHeight() + { + return m_bufferImageCopy.bufferImageHeight; + } + BufferImageCopy& bufferImageHeight( uint32_t bufferImageHeight ) { m_bufferImageCopy.bufferImageHeight = bufferImageHeight; @@ -12312,6 +14907,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 ); @@ -12323,6 +14923,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 ); @@ -12334,6 +14939,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 ); @@ -12387,6 +14997,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 ); @@ -12398,6 +15013,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 ); @@ -12409,6 +15029,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 ); @@ -12420,6 +15045,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 ); @@ -12431,6 +15061,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 ); @@ -12482,6 +15117,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 ); @@ -12493,6 +15133,11 @@ namespace vk return m_clearAttachment.colorAttachment; } + uint32_t& colorAttachment() + { + return m_clearAttachment.colorAttachment; + } + ClearAttachment& colorAttachment( uint32_t colorAttachment ) { m_clearAttachment.colorAttachment = colorAttachment; @@ -12504,6 +15149,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 ); @@ -12659,6 +15309,11 @@ namespace vk return m_sparseMemoryBind.resourceOffset; } + DeviceSize& resourceOffset() + { + return m_sparseMemoryBind.resourceOffset; + } + SparseMemoryBind& resourceOffset( DeviceSize resourceOffset ) { m_sparseMemoryBind.resourceOffset = resourceOffset; @@ -12670,6 +15325,11 @@ namespace vk return m_sparseMemoryBind.size; } + DeviceSize& size() + { + return m_sparseMemoryBind.size; + } + SparseMemoryBind& size( DeviceSize size ) { m_sparseMemoryBind.size = size; @@ -12681,6 +15341,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 ); @@ -12692,6 +15357,11 @@ namespace vk return m_sparseMemoryBind.memoryOffset; } + DeviceSize& memoryOffset() + { + return m_sparseMemoryBind.memoryOffset; + } + SparseMemoryBind& memoryOffset( DeviceSize memoryOffset ) { m_sparseMemoryBind.memoryOffset = memoryOffset; @@ -12703,6 +15373,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 ); @@ -12757,6 +15432,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 ); @@ -12768,6 +15448,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 ); @@ -12779,6 +15464,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 ); @@ -12790,6 +15480,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 ); @@ -12801,6 +15496,11 @@ namespace vk return m_sparseImageMemoryBind.memoryOffset; } + DeviceSize& memoryOffset() + { + return m_sparseImageMemoryBind.memoryOffset; + } + SparseImageMemoryBind& memoryOffset( DeviceSize memoryOffset ) { m_sparseImageMemoryBind.memoryOffset = memoryOffset; @@ -12812,6 +15512,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 ); @@ -12863,6 +15568,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 ); @@ -12874,6 +15584,11 @@ namespace vk return m_sparseBufferMemoryBindInfo.bindCount; } + uint32_t& bindCount() + { + return m_sparseBufferMemoryBindInfo.bindCount; + } + SparseBufferMemoryBindInfo& bindCount( uint32_t bindCount ) { m_sparseBufferMemoryBindInfo.bindCount = bindCount; @@ -12885,6 +15600,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 ); @@ -12936,6 +15656,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 ); @@ -12947,6 +15672,11 @@ namespace vk return m_sparseImageOpaqueMemoryBindInfo.bindCount; } + uint32_t& bindCount() + { + return m_sparseImageOpaqueMemoryBindInfo.bindCount; + } + SparseImageOpaqueMemoryBindInfo& bindCount( uint32_t bindCount ) { m_sparseImageOpaqueMemoryBindInfo.bindCount = bindCount; @@ -12958,6 +15688,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 ); @@ -13009,6 +15744,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 ); @@ -13020,6 +15760,11 @@ namespace vk return m_sparseImageMemoryBindInfo.bindCount; } + uint32_t& bindCount() + { + return m_sparseImageMemoryBindInfo.bindCount; + } + SparseImageMemoryBindInfo& bindCount( uint32_t bindCount ) { m_sparseImageMemoryBindInfo.bindCount = bindCount; @@ -13031,6 +15776,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 ); @@ -13091,6 +15841,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 ); @@ -13102,6 +15857,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; @@ -13113,6 +15873,11 @@ namespace vk return m_bindSparseInfo.waitSemaphoreCount; } + uint32_t& waitSemaphoreCount() + { + return m_bindSparseInfo.waitSemaphoreCount; + } + BindSparseInfo& waitSemaphoreCount( uint32_t waitSemaphoreCount ) { m_bindSparseInfo.waitSemaphoreCount = waitSemaphoreCount; @@ -13124,6 +15889,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 ); @@ -13135,6 +15905,11 @@ namespace vk return m_bindSparseInfo.bufferBindCount; } + uint32_t& bufferBindCount() + { + return m_bindSparseInfo.bufferBindCount; + } + BindSparseInfo& bufferBindCount( uint32_t bufferBindCount ) { m_bindSparseInfo.bufferBindCount = bufferBindCount; @@ -13146,6 +15921,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 ); @@ -13157,6 +15937,11 @@ namespace vk return m_bindSparseInfo.imageOpaqueBindCount; } + uint32_t& imageOpaqueBindCount() + { + return m_bindSparseInfo.imageOpaqueBindCount; + } + BindSparseInfo& imageOpaqueBindCount( uint32_t imageOpaqueBindCount ) { m_bindSparseInfo.imageOpaqueBindCount = imageOpaqueBindCount; @@ -13168,6 +15953,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 ); @@ -13179,6 +15969,11 @@ namespace vk return m_bindSparseInfo.imageBindCount; } + uint32_t& imageBindCount() + { + return m_bindSparseInfo.imageBindCount; + } + BindSparseInfo& imageBindCount( uint32_t imageBindCount ) { m_bindSparseInfo.imageBindCount = imageBindCount; @@ -13190,6 +15985,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 ); @@ -13201,6 +16001,11 @@ namespace vk return m_bindSparseInfo.signalSemaphoreCount; } + uint32_t& signalSemaphoreCount() + { + return m_bindSparseInfo.signalSemaphoreCount; + } + BindSparseInfo& signalSemaphoreCount( uint32_t signalSemaphoreCount ) { m_bindSparseInfo.signalSemaphoreCount = signalSemaphoreCount; @@ -13212,6 +16017,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 ); @@ -13305,6 +16115,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 ); @@ -13316,6 +16131,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; @@ -13327,6 +16147,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 ); @@ -13338,6 +16163,11 @@ namespace vk return m_commandPoolCreateInfo.queueFamilyIndex; } + uint32_t& queueFamilyIndex() + { + return m_commandPoolCreateInfo.queueFamilyIndex; + } + CommandPoolCreateInfo& queueFamilyIndex( uint32_t queueFamilyIndex ) { m_commandPoolCreateInfo.queueFamilyIndex = queueFamilyIndex; @@ -13486,6 +16316,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 ); @@ -13497,6 +16332,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; @@ -13508,6 +16348,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 ); @@ -13519,6 +16364,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 ); @@ -13530,6 +16380,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 ); @@ -13541,6 +16396,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 ); @@ -13552,6 +16412,11 @@ namespace vk return m_imageCreateInfo.mipLevels; } + uint32_t& mipLevels() + { + return m_imageCreateInfo.mipLevels; + } + ImageCreateInfo& mipLevels( uint32_t mipLevels ) { m_imageCreateInfo.mipLevels = mipLevels; @@ -13563,6 +16428,11 @@ namespace vk return m_imageCreateInfo.arrayLayers; } + uint32_t& arrayLayers() + { + return m_imageCreateInfo.arrayLayers; + } + ImageCreateInfo& arrayLayers( uint32_t arrayLayers ) { m_imageCreateInfo.arrayLayers = arrayLayers; @@ -13574,6 +16444,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 ); @@ -13585,6 +16460,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 ); @@ -13596,6 +16476,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 ); @@ -13607,6 +16492,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 ); @@ -13618,6 +16508,11 @@ namespace vk return m_imageCreateInfo.queueFamilyIndexCount; } + uint32_t& queueFamilyIndexCount() + { + return m_imageCreateInfo.queueFamilyIndexCount; + } + ImageCreateInfo& queueFamilyIndexCount( uint32_t queueFamilyIndexCount ) { m_imageCreateInfo.queueFamilyIndexCount = queueFamilyIndexCount; @@ -13629,6 +16524,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; @@ -13640,6 +16540,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 ); @@ -13697,6 +16602,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 ); @@ -13708,6 +16618,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; @@ -13719,6 +16634,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 ); @@ -13730,6 +16650,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 ); @@ -13741,6 +16666,11 @@ namespace vk return m_pipelineMultisampleStateCreateInfo.sampleShadingEnable; } + Bool32& sampleShadingEnable() + { + return m_pipelineMultisampleStateCreateInfo.sampleShadingEnable; + } + PipelineMultisampleStateCreateInfo& sampleShadingEnable( Bool32 sampleShadingEnable ) { m_pipelineMultisampleStateCreateInfo.sampleShadingEnable = sampleShadingEnable; @@ -13752,6 +16682,11 @@ namespace vk return m_pipelineMultisampleStateCreateInfo.minSampleShading; } + float& minSampleShading() + { + return m_pipelineMultisampleStateCreateInfo.minSampleShading; + } + PipelineMultisampleStateCreateInfo& minSampleShading( float minSampleShading ) { m_pipelineMultisampleStateCreateInfo.minSampleShading = minSampleShading; @@ -13763,6 +16698,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; @@ -13774,6 +16714,11 @@ namespace vk return m_pipelineMultisampleStateCreateInfo.alphaToCoverageEnable; } + Bool32& alphaToCoverageEnable() + { + return m_pipelineMultisampleStateCreateInfo.alphaToCoverageEnable; + } + PipelineMultisampleStateCreateInfo& alphaToCoverageEnable( Bool32 alphaToCoverageEnable ) { m_pipelineMultisampleStateCreateInfo.alphaToCoverageEnable = alphaToCoverageEnable; @@ -13785,6 +16730,11 @@ namespace vk return m_pipelineMultisampleStateCreateInfo.alphaToOneEnable; } + Bool32& alphaToOneEnable() + { + return m_pipelineMultisampleStateCreateInfo.alphaToOneEnable; + } + PipelineMultisampleStateCreateInfo& alphaToOneEnable( Bool32 alphaToOneEnable ) { m_pipelineMultisampleStateCreateInfo.alphaToOneEnable = alphaToOneEnable; @@ -13852,6 +16802,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 ); @@ -13863,6 +16818,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; @@ -13874,6 +16834,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 ); @@ -13885,6 +16850,11 @@ namespace vk return m_graphicsPipelineCreateInfo.stageCount; } + uint32_t& stageCount() + { + return m_graphicsPipelineCreateInfo.stageCount; + } + GraphicsPipelineCreateInfo& stageCount( uint32_t stageCount ) { m_graphicsPipelineCreateInfo.stageCount = stageCount; @@ -13896,6 +16866,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 ); @@ -13907,6 +16882,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 ); @@ -13918,6 +16898,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 ); @@ -13929,6 +16914,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 ); @@ -13940,6 +16930,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 ); @@ -13951,6 +16946,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 ); @@ -13962,6 +16962,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 ); @@ -13973,6 +16978,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 ); @@ -13984,6 +16994,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 ); @@ -13995,6 +17010,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 ); @@ -14006,6 +17026,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 ); @@ -14017,6 +17042,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 ); @@ -14028,6 +17058,11 @@ namespace vk return m_graphicsPipelineCreateInfo.subpass; } + uint32_t& subpass() + { + return m_graphicsPipelineCreateInfo.subpass; + } + GraphicsPipelineCreateInfo& subpass( uint32_t subpass ) { m_graphicsPipelineCreateInfo.subpass = subpass; @@ -14039,6 +17074,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 ); @@ -14050,6 +17090,11 @@ namespace vk return m_graphicsPipelineCreateInfo.basePipelineIndex; } + int32_t& basePipelineIndex() + { + return m_graphicsPipelineCreateInfo.basePipelineIndex; + } + GraphicsPipelineCreateInfo& basePipelineIndex( int32_t basePipelineIndex ) { m_graphicsPipelineCreateInfo.basePipelineIndex = basePipelineIndex; @@ -14730,6 +17775,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 ); @@ -14741,6 +17791,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 ); @@ -14752,6 +17807,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 ); @@ -14763,6 +17823,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 ); @@ -14774,6 +17839,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 ); @@ -14785,6 +17855,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 ); @@ -14796,6 +17871,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 ); @@ -14807,6 +17887,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 ); @@ -14818,6 +17903,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 ); @@ -14898,6 +17988,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 ); @@ -14909,6 +18004,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; @@ -14920,6 +18020,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 ); @@ -14931,6 +18036,11 @@ namespace vk return m_descriptorPoolCreateInfo.maxSets; } + uint32_t& maxSets() + { + return m_descriptorPoolCreateInfo.maxSets; + } + DescriptorPoolCreateInfo& maxSets( uint32_t maxSets ) { m_descriptorPoolCreateInfo.maxSets = maxSets; @@ -14942,6 +18052,11 @@ namespace vk return m_descriptorPoolCreateInfo.poolSizeCount; } + uint32_t& poolSizeCount() + { + return m_descriptorPoolCreateInfo.poolSizeCount; + } + DescriptorPoolCreateInfo& poolSizeCount( uint32_t poolSizeCount ) { m_descriptorPoolCreateInfo.poolSizeCount = poolSizeCount; @@ -14953,6 +18068,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 ); @@ -15317,6 +18437,11 @@ namespace vk return m_subpassDependency.srcSubpass; } + uint32_t& srcSubpass() + { + return m_subpassDependency.srcSubpass; + } + SubpassDependency& srcSubpass( uint32_t srcSubpass ) { m_subpassDependency.srcSubpass = srcSubpass; @@ -15328,6 +18453,11 @@ namespace vk return m_subpassDependency.dstSubpass; } + uint32_t& dstSubpass() + { + return m_subpassDependency.dstSubpass; + } + SubpassDependency& dstSubpass( uint32_t dstSubpass ) { m_subpassDependency.dstSubpass = dstSubpass; @@ -15339,6 +18469,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 ); @@ -15350,6 +18485,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 ); @@ -15361,6 +18501,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 ); @@ -15372,6 +18517,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 ); @@ -15383,6 +18533,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 ); @@ -15440,6 +18595,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 ); @@ -15451,6 +18611,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; @@ -15462,6 +18627,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 ); @@ -15473,6 +18643,11 @@ namespace vk return m_renderPassCreateInfo.attachmentCount; } + uint32_t& attachmentCount() + { + return m_renderPassCreateInfo.attachmentCount; + } + RenderPassCreateInfo& attachmentCount( uint32_t attachmentCount ) { m_renderPassCreateInfo.attachmentCount = attachmentCount; @@ -15484,6 +18659,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 ); @@ -15495,6 +18675,11 @@ namespace vk return m_renderPassCreateInfo.subpassCount; } + uint32_t& subpassCount() + { + return m_renderPassCreateInfo.subpassCount; + } + RenderPassCreateInfo& subpassCount( uint32_t subpassCount ) { m_renderPassCreateInfo.subpassCount = subpassCount; @@ -15506,6 +18691,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 ); @@ -15517,6 +18707,11 @@ namespace vk return m_renderPassCreateInfo.dependencyCount; } + uint32_t& dependencyCount() + { + return m_renderPassCreateInfo.dependencyCount; + } + RenderPassCreateInfo& dependencyCount( uint32_t dependencyCount ) { m_renderPassCreateInfo.dependencyCount = dependencyCount; @@ -15528,6 +18723,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 ); @@ -15585,6 +18785,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 ); @@ -15596,6 +18801,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; @@ -15607,6 +18817,11 @@ namespace vk return m_submitInfo.waitSemaphoreCount; } + uint32_t& waitSemaphoreCount() + { + return m_submitInfo.waitSemaphoreCount; + } + SubmitInfo& waitSemaphoreCount( uint32_t waitSemaphoreCount ) { m_submitInfo.waitSemaphoreCount = waitSemaphoreCount; @@ -15618,6 +18833,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 ); @@ -15629,6 +18849,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 ); @@ -15640,6 +18865,11 @@ namespace vk return m_submitInfo.commandBufferCount; } + uint32_t& commandBufferCount() + { + return m_submitInfo.commandBufferCount; + } + SubmitInfo& commandBufferCount( uint32_t commandBufferCount ) { m_submitInfo.commandBufferCount = commandBufferCount; @@ -15651,6 +18881,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 ); @@ -15662,6 +18897,11 @@ namespace vk return m_submitInfo.signalSemaphoreCount; } + uint32_t& signalSemaphoreCount() + { + return m_submitInfo.signalSemaphoreCount; + } + SubmitInfo& signalSemaphoreCount( uint32_t signalSemaphoreCount ) { m_submitInfo.signalSemaphoreCount = signalSemaphoreCount; @@ -15673,6 +18913,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 ); @@ -15817,6 +19062,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 ); @@ -15828,6 +19078,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 ); @@ -15900,6 +19155,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 ); @@ -15911,6 +19171,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 ); @@ -15922,6 +19187,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 ); @@ -15933,6 +19203,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 ); @@ -15944,6 +19219,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 ); @@ -15955,6 +19235,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 ); @@ -15966,6 +19251,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 ); @@ -15977,6 +19267,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 ); @@ -15988,6 +19283,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 ); @@ -16078,6 +19378,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 ); @@ -16089,6 +19394,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; @@ -16100,6 +19410,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 ); @@ -16111,6 +19426,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 ); @@ -16122,6 +19442,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 ); @@ -16133,6 +19458,11 @@ namespace vk return m_displayPropertiesKHR.planeReorderPossible; } + Bool32& planeReorderPossible() + { + return m_displayPropertiesKHR.planeReorderPossible; + } + DisplayPropertiesKHR& planeReorderPossible( Bool32 planeReorderPossible ) { m_displayPropertiesKHR.planeReorderPossible = planeReorderPossible; @@ -16144,6 +19474,11 @@ namespace vk return m_displayPropertiesKHR.persistentContent; } + Bool32& persistentContent() + { + return m_displayPropertiesKHR.persistentContent; + } + DisplayPropertiesKHR& persistentContent( Bool32 persistentContent ) { m_displayPropertiesKHR.persistentContent = persistentContent; @@ -16202,6 +19537,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 ); @@ -16213,6 +19553,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; @@ -16224,6 +19569,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 ); @@ -16235,6 +19585,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 ); @@ -16246,6 +19601,11 @@ namespace vk return m_displaySurfaceCreateInfoKHR.planeIndex; } + uint32_t& planeIndex() + { + return m_displaySurfaceCreateInfoKHR.planeIndex; + } + DisplaySurfaceCreateInfoKHR& planeIndex( uint32_t planeIndex ) { m_displaySurfaceCreateInfoKHR.planeIndex = planeIndex; @@ -16257,6 +19617,11 @@ namespace vk return m_displaySurfaceCreateInfoKHR.planeStackIndex; } + uint32_t& planeStackIndex() + { + return m_displaySurfaceCreateInfoKHR.planeStackIndex; + } + DisplaySurfaceCreateInfoKHR& planeStackIndex( uint32_t planeStackIndex ) { m_displaySurfaceCreateInfoKHR.planeStackIndex = planeStackIndex; @@ -16268,6 +19633,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 ); @@ -16279,6 +19649,11 @@ namespace vk return m_displaySurfaceCreateInfoKHR.globalAlpha; } + float& globalAlpha() + { + return m_displaySurfaceCreateInfoKHR.globalAlpha; + } + DisplaySurfaceCreateInfoKHR& globalAlpha( float globalAlpha ) { m_displaySurfaceCreateInfoKHR.globalAlpha = globalAlpha; @@ -16290,6 +19665,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 ); @@ -16301,6 +19681,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 ); @@ -16359,6 +19744,11 @@ namespace vk return m_surfaceCapabilitiesKHR.minImageCount; } + uint32_t& minImageCount() + { + return m_surfaceCapabilitiesKHR.minImageCount; + } + SurfaceCapabilitiesKHR& minImageCount( uint32_t minImageCount ) { m_surfaceCapabilitiesKHR.minImageCount = minImageCount; @@ -16370,6 +19760,11 @@ namespace vk return m_surfaceCapabilitiesKHR.maxImageCount; } + uint32_t& maxImageCount() + { + return m_surfaceCapabilitiesKHR.maxImageCount; + } + SurfaceCapabilitiesKHR& maxImageCount( uint32_t maxImageCount ) { m_surfaceCapabilitiesKHR.maxImageCount = maxImageCount; @@ -16381,6 +19776,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 ); @@ -16392,6 +19792,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 ); @@ -16403,6 +19808,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 ); @@ -16414,6 +19824,11 @@ namespace vk return m_surfaceCapabilitiesKHR.maxImageArrayLayers; } + uint32_t& maxImageArrayLayers() + { + return m_surfaceCapabilitiesKHR.maxImageArrayLayers; + } + SurfaceCapabilitiesKHR& maxImageArrayLayers( uint32_t maxImageArrayLayers ) { m_surfaceCapabilitiesKHR.maxImageArrayLayers = maxImageArrayLayers; @@ -16425,6 +19840,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 ); @@ -16436,6 +19856,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 ); @@ -16447,6 +19872,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 ); @@ -16458,6 +19888,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 ); @@ -16524,6 +19959,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 ); @@ -16535,6 +19975,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; @@ -16546,6 +19991,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 ); @@ -16557,6 +20007,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 ); @@ -16568,6 +20023,11 @@ namespace vk return m_swapchainCreateInfoKHR.minImageCount; } + uint32_t& minImageCount() + { + return m_swapchainCreateInfoKHR.minImageCount; + } + SwapchainCreateInfoKHR& minImageCount( uint32_t minImageCount ) { m_swapchainCreateInfoKHR.minImageCount = minImageCount; @@ -16579,6 +20039,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 ); @@ -16590,6 +20055,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 ); @@ -16601,6 +20071,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 ); @@ -16612,6 +20087,11 @@ namespace vk return m_swapchainCreateInfoKHR.imageArrayLayers; } + uint32_t& imageArrayLayers() + { + return m_swapchainCreateInfoKHR.imageArrayLayers; + } + SwapchainCreateInfoKHR& imageArrayLayers( uint32_t imageArrayLayers ) { m_swapchainCreateInfoKHR.imageArrayLayers = imageArrayLayers; @@ -16623,6 +20103,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 ); @@ -16634,6 +20119,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 ); @@ -16645,6 +20135,11 @@ namespace vk return m_swapchainCreateInfoKHR.queueFamilyIndexCount; } + uint32_t& queueFamilyIndexCount() + { + return m_swapchainCreateInfoKHR.queueFamilyIndexCount; + } + SwapchainCreateInfoKHR& queueFamilyIndexCount( uint32_t queueFamilyIndexCount ) { m_swapchainCreateInfoKHR.queueFamilyIndexCount = queueFamilyIndexCount; @@ -16656,6 +20151,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; @@ -16667,6 +20167,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 ); @@ -16678,6 +20183,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 ); @@ -16689,6 +20199,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 ); @@ -16700,6 +20215,11 @@ namespace vk return m_swapchainCreateInfoKHR.clipped; } + Bool32& clipped() + { + return m_swapchainCreateInfoKHR.clipped; + } + SwapchainCreateInfoKHR& clipped( Bool32 clipped ) { m_swapchainCreateInfoKHR.clipped = clipped; @@ -16711,6 +20231,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 ); @@ -17794,6 +21319,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 ); @@ -17805,6 +21335,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; @@ -17816,6 +21351,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 ); @@ -17827,6 +21367,11 @@ namespace vk return m_debugReportCallbackCreateInfoEXT.pfnCallback; } + PFN_vkDebugReportCallbackEXT& pfnCallback() + { + return m_debugReportCallbackCreateInfoEXT.pfnCallback; + } + DebugReportCallbackCreateInfoEXT& pfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback ) { m_debugReportCallbackCreateInfoEXT.pfnCallback = pfnCallback; @@ -17834,6 +21379,11 @@ namespace vk } const void* pUserData() const + { + return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.pUserData ); + } + + void* pUserData() { return reinterpret_cast( m_debugReportCallbackCreateInfoEXT.pUserData ); }