Lines Matching refs:pNext

198       : pNext( pNext_ )
229       pNext = pNext_;
306       return std::tie( sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData );
312     const void *                                      pNext         = {};
339       : pNext( pNext_ )
364       pNext = pNext_;
403       return std::tie( sType, pNext, data, stride );
409     const void *                                      pNext  = {};
431       : pNext( pNext_ )
457       pNext = pNext_;
497       return std::tie( sType, pNext, arrayOfPointers, data );
503     const void *                                      pNext           = {};
589       : pNext( pNext_ )
615       pNext = pNext_;
661       return std::tie( sType, pNext, geometryType, geometry, flags );
667     const void *                                               pNext        = {};
741       : pNext( pNext_ )
772       : pNext( pNext_ )
808       pNext = pNext_;
924         sType, pNext, type, flags, mode, srcAccelerationStructure, dstAccelerationStructure, geometryCount, pGeometries, ppGeometries, scratchData );
930     const void *                                                           pNext = {};
1066       : pNext( pNext_ )
1092       pNext = pNext_;
1140       return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize );
1152       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureSize == rhs.accelerationStructureSize ) &&
1165     const void *                        pNext                     = {};
1188       : pNext( pNext_ )
1215       pNext = pNext_;
1255       return std::tie( sType, pNext, accelerationStructure, accelerationStructureNV );
1267       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) &&
1280     const void *                                   pNext                   = {};
1307       : pNext( pNext_ )
1336       pNext = pNext_;
1403       return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress );
1415       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) &&
1428     const void *                                              pNext         = {};
1463       : pNext( pNext_ )
1496       pNext = pNext_;
1598                        pNext,
1621       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexData == rhs.vertexData ) && ( vertexOffset == rhs.vertexOffset ) &&
1636     const void *                        pNext           = {};
1669       : pNext( pNext_ )
1693       pNext = pNext_;
1745       return std::tie( sType, pNext, aabbData, numAABBs, stride, offset );
1757       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) && ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) &&
1770     const void *                        pNext    = {};
1879       : pNext( pNext_ )
1902       pNext = pNext_;
1947       return std::tie( sType, pNext, geometryType, geometry, flags );
1959       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) && ( geometry == rhs.geometry ) && ( flags == rhs.flags );
1971     const void *                           pNext        = {};
1997       : pNext( pNext_ )
2019       : pNext( pNext_ )
2041       pNext = pNext_;
2110       return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries );
2122       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) && ( instanceCount == rhs.instanceCount ) &&
2135     const void *                                            pNext         = {};
2160       : pNext( pNext_ )
2185       pNext = pNext_;
2223       return std::tie( sType, pNext, compactedSize, info );
2235       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) && ( info == rhs.info );
2247     const void *                                      pNext         = {};
2268       : pNext( pNext_ )
2292       pNext = pNext_;
2322       return std::tie( sType, pNext, accelerationStructure );
2334       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure );
2346     const void *                                   pNext                 = {};
2366       : pNext( pNext_ )
2392       pNext = pNext_;
2422       return std::tie( sType, pNext, vertexData );
2428     const void *                                      pNext      = {};
2802       : pNext( pNext_ )
2828       pNext = pNext_;
2868       return std::tie( sType, pNext, type, accelerationStructure );
2880       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( accelerationStructure == rhs.accelerationStructure );
2892     const void *                                                        pNext = {};
2914       : pNext( pNext_ )
2939       pNext = pNext_;
2978       return std::tie( sType, pNext, maxInstances, flags );
2990       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) && ( flags == rhs.flags );
3002     const void *                                                 pNext        = {};
3651       : pNext( pNext_ )
3697       : pNext( pNext_ )
3741       pNext = pNext_;
3912                        pNext,
3934     void *                                                 pNext = {};
3978       : pNext( pNext_ )
4008       : pNext( pNext_ )
4043       pNext = pNext_;
4147       return std::tie( sType, pNext, indexType, indexBuffer, indexStride, baseTriangle, usageCountsCount, pUsageCounts, ppUsageCounts, micromap );
4153     void *                                                 pNext            = {};
4179       : pNext( pNext_ )
4203       pNext = pNext_;
4232       return std::tie( sType, pNext, pVersionData );
4244       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData );
4256     const void *                        pNext        = {};
4280       : pNext( pNext_ )
4308       pNext = pNext_;
4367       return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask );
4379       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( timeout == rhs.timeout ) &&
4392     const void *                        pNext      = {};
4417       : pNext( pNext_ )
4442       pNext = pNext_;
4477       return std::tie( sType, pNext, flags, timeout );
4489       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout );
4501     const void *                                       pNext   = {};
4646       : pNext( pNext_ )
4671       pNext = pNext_;
4706       return std::tie( sType, pNext, firstDrawTimestamp, swapBufferTimestamp );
4718       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( firstDrawTimestamp == rhs.firstDrawTimestamp ) &&
4731     const void *                        pNext               = {};
4866       : pNext( pNext_ )
4923                        pNext,
4943       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) &&
4958     void *                                            pNext                            = {};
4995       : pNext( pNext_ )
5051                        pNext,
5071       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) &&
5086     void *                                            pNext                            = {};
5116       : pNext( pNext_ )
5157       return std::tie( sType, pNext, colorAttachmentFormat );
5169       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentFormat == rhs.colorAttachmentFormat );
5181     void *                              pNext                 = {};
5204       : pNext( pNext_ )
5244       return std::tie( sType, pNext, allocationSize, memoryTypeBits );
5256       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeBits == rhs.memoryTypeBits );
5268     void *                              pNext          = {};
5290       : pNext( pNext_ )
5329       return std::tie( sType, pNext, androidHardwareBufferUsage );
5341       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage );
5353     void *                              pNext                      = {};
5376       : pNext( pNext_ )
5401       pNext = pNext_;
5439       return std::tie( sType, pNext, flags, window );
5451       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window );
5463     const void *                                       pNext  = {};
5489       : pNext( pNext_ )
5514       pNext = pNext_;
5573       return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion );
5582       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
5603       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
5616     const void *                        pNext              = {};
5809       : pNext( pNext_ )
5841       pNext = pNext_;
5928       return std::tie( sType, pNext, flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout );
5940       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) &&
5954     const void *                                     pNext          = {};
5986       : pNext( pNext_ )
6011       pNext = pNext_;
6049       return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout );
6061       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) &&
6074     void *                              pNext                = {};
6185       : pNext( pNext_ )
6211       pNext = pNext_;
6256       return std::tie( sType, pNext, attachment, layout, aspectMask );
6268       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) && ( layout == rhs.layout ) &&
6281     const void *                           pNext      = {};
6305       : pNext( pNext_ )
6329       pNext = pNext_;
6358       return std::tie( sType, pNext, stencilLayout );
6370       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout );
6382     void *                              pNext         = {};
6407       : pNext( pNext_ )
6426       : pNext( pNext_ )
6446       pNext = pNext_;
6503       return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples );
6515       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
6528     const void *                                      pNext                         = {};
6722       : pNext( pNext_ )
6742       : pNext( pNext_ )
6763       pNext = pNext_;
6828       return std::tie( sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations );
6840       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) &&
6854     const void *                                    pNext                   = {};
6963       , pNext( pNext_ )
6983       pNext = pNext_;
7006       return std::tie( sType, pNext );
7018       return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
7030     const struct VULKAN_HPP_NAMESPACE::BaseInStructure * pNext = {};
7041       , pNext( pNext_ )
7061       pNext = pNext_;
7084       return std::tie( sType, pNext );
7096       return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
7108     struct VULKAN_HPP_NAMESPACE::BaseOutStructure * pNext = {};
7125       : pNext( pNext_ )
7147       : pNext( pNext_ )
7169       pNext = pNext_;
7239       return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices );
7251       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) &&
7264     const void *                                  pNext                 = {};
7289       : pNext( pNext_ )
7304       : pNext( pNext_ ), deviceIndexCount( static_cast<uint32_t>( deviceIndices_.size() ) ), pDeviceIndices( deviceIndices_.data() )
7321       pNext = pNext_;
7366       return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices );
7378       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices );
7390     const void *                        pNext            = {};
7415       : pNext( pNext_ )
7441       pNext = pNext_;
7486       return std::tie( sType, pNext, buffer, memory, memoryOffset );
7498       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset );
7510     const void *                        pNext        = {};
7536       : pNext( pNext_ )
7562       pNext = pNext_;
7608       return std::tie( sType, pNext, stageFlags, layout, set );
7620       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( set == rhs.set );
7632     const void *                           pNext      = {};
7660       : pNext( pNext_ )
7685       : pNext( pNext_ )
7709       pNext = pNext_;
7801       return std::tie( sType, pNext, stageFlags, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
7813       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( firstSet == rhs.firstSet ) &&
7827     const void *                                pNext              = {};
8022       : pNext( pNext_ )
8041       : pNext( pNext_ )
8062       pNext = pNext_;
8135       return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions );
8147       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices ) &&
8160     const void *                         pNext                        = {};
8187       : pNext( pNext_ )
8212       pNext = pNext_;
8257       return std::tie( sType, pNext, image, memory, memoryOffset );
8269       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset );
8281     const void *                        pNext        = {};
8306       : pNext( pNext_ )
8331       pNext = pNext_;
8366       return std::tie( sType, pNext, swapchain, imageIndex );
8378       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( imageIndex == rhs.imageIndex );
8390     const void *                        pNext      = {};
8411       : pNext( pNext_ )
8435       pNext = pNext_;
8464       return std::tie( sType, pNext, planeAspect );
8476       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect );
8488     const void *                              pNext       = {};
8606       : pNext( pNext_ )
8629       pNext = pNext_;
8658       return std::tie( sType, pNext, pResult );
8670       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pResult == rhs.pResult );
8682     const void *                        pNext   = {};
9729       : pNext( pNext_ )
9754       : pNext( pNext_ )
9781       pNext = pNext_;
9927                        pNext,
9949       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
9965     const void *                                                  pNext                = {};
10093       : pNext( pNext_ )
10120       pNext = pNext_;
10172       return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize );
10184       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && ( memory == rhs.memory ) &&
10197     const void *                        pNext           = {};
10221       : pNext( pNext_ )
10245       pNext = pNext_;
10274       return std::tie( sType, pNext, cubicWeights );
10286       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicWeights == rhs.cubicWeights );
10298     const void *                                 pNext        = {};
10426       : pNext( pNext_ )
10450       pNext = pNext_;
10502       return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets );
10514       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) &&
10527     const void *                                                            pNext          = {};
10558       : pNext( pNext_ )
10581       : pNext( pNext_ )
10605       pNext = pNext_;
10687       return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
10699       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) &&
10713     const void *                             pNext          = {};
10740       : pNext( pNext_ )
10764       pNext = pNext_;
10793       return std::tie( sType, pNext, buffer );
10805       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
10817     const void *                        pNext  = {};
10839       : pNext( pNext_ )
10864       pNext = pNext_;
10900       return std::tie( sType, pNext, collection, index );
10912       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index );
10924     const void *                                  pNext      = {};
10951       : pNext( pNext_ )
10979       pNext = pNext_;
11040       return std::tie( sType, pNext, minBufferCount, maxBufferCount, minBufferCountForCamping, minBufferCountForDedicatedSlack, minBufferCountForSharedSlack );
11052       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) && ( maxBufferCount == rhs.maxBufferCount ) &&
11066     const void *                        pNext                           = {};
11091       : pNext( pNext_ )
11115       pNext = pNext_;
11144       return std::tie( sType, pNext, collectionToken );
11153       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
11164       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 );
11174     const void *                        pNext           = {};
11197       : pNext( pNext_ )
11222       pNext = pNext_;
11258       return std::tie( sType, pNext, collection, index );
11270       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index );
11282     const void *                                  pNext      = {};
11304       : pNext( pNext_ )
11328       pNext = pNext_;
11357       return std::tie( sType, pNext, colorSpace );
11369       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace );
11381     const void *                        pNext      = {};
11414       : pNext( pNext_ )
11448       pNext = pNext_;
11557                        pNext,
11580       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ) && ( bufferCount == rhs.bufferCount ) &&
11596     void *                                            pNext                            = {};
11632       : pNext( pNext_ )
11653       : pNext( pNext_ )
11676       pNext = pNext_;
11751       return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices );
11763       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( size == rhs.size ) && ( usage == rhs.usage ) &&
11776     const void *                            pNext                 = {};
11804       : pNext( pNext_ )
11830       pNext = pNext_;
11877       return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints );
11889       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) && ( requiredFormatFeatures == rhs.requiredFormatFeatures ) &&
11902     const void *                                                 pNext                       = {};
12020       : pNext( pNext_ )
12043       pNext = pNext_;
12088       return std::tie( sType, pNext, srcOffset, dstOffset, size );
12100       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size );
12112     const void *                        pNext     = {};
12136       : pNext( pNext_ )
12160       pNext = pNext_;
12189       return std::tie( sType, pNext, deviceAddress );
12201       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress );
12213     const void *                        pNext         = {};
12232       : pNext( pNext_ )
12256       pNext = pNext_;
12285       return std::tie( sType, pNext, buffer );
12297       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
12309     const void *                        pNext  = {};
12463       : pNext( pNext_ )
12489       pNext = pNext_;
12555       return std::tie( sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
12567       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) &&
12581     const void *                                 pNext             = {};
12614       : pNext( pNext_ )
12643       pNext = pNext_;
12716       return std::tie( sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size );
12728       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) &&
12742     const void *                        pNext               = {};
12776       : pNext( pNext_ )
12808       pNext = pNext_;
12895       return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size );
12907       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) &&
12921     const void *                              pNext               = {};
12950       : pNext( pNext_ )
12974       pNext = pNext_;
13003       return std::tie( sType, pNext, buffer );
13015       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
13027     const void *                        pNext  = {};
13048       : pNext( pNext_ )
13072       pNext = pNext_;
13101       return std::tie( sType, pNext, opaqueCaptureAddress );
13113       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress );
13125     const void *                        pNext                = {};
13147       : pNext( pNext_ )
13171       pNext = pNext_;
13200       return std::tie( sType, pNext, usage );
13212       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage );
13224     const void *                               pNext = {};
13248       : pNext( pNext_ )
13276       pNext = pNext_;
13335       return std::tie( sType, pNext, flags, buffer, format, offset, range );
13347       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) && ( format == rhs.format ) &&
13360     const void *                                pNext  = {};
13384       : pNext( pNext_ )
13408       pNext = pNext_;
13437       return std::tie( sType, pNext, timeDomain );
13449       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain );
13461     const void *                        pNext      = {};
13483       : pNext( pNext_ )
13520       return std::tie( sType, pNext, stage, pCheckpointMarker );
13532       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( pCheckpointMarker == rhs.pCheckpointMarker );
13544     void *                                    pNext             = {};
13566       : pNext( pNext_ )
13603       return std::tie( sType, pNext, stage, pCheckpointMarker );
13615       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( pCheckpointMarker == rhs.pCheckpointMarker );
13627     void *                                      pNext             = {};
14482       : pNext( pNext_ )
14508       pNext = pNext_;
14553       return std::tie( sType, pNext, commandPool, level, commandBufferCount );
14565       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) && ( level == rhs.level ) &&
14578     const void *                             pNext              = {};
14605       : pNext( pNext_ )
14634       pNext = pNext_;
14701       return std::tie( sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics );
14713       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( subpass == rhs.subpass ) &&
14727     const void *                                      pNext                = {};
14753       : pNext( pNext_ )
14778       pNext = pNext_;
14817       return std::tie( sType, pNext, flags, pInheritanceInfo );
14829       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pInheritanceInfo == rhs.pInheritanceInfo );
14841     const void *                                               pNext            = {};
14862       : pNext( pNext_ )
14888       pNext = pNext_;
14918       return std::tie( sType, pNext, conditionalRenderingEnable );
14930       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRenderingEnable == rhs.conditionalRenderingEnable );
14942     const void *                        pNext                      = {};
14964       : pNext( pNext_ )
14991       pNext = pNext_;
15031       return std::tie( sType, pNext, transform, renderArea );
15043       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) && ( renderArea == rhs.renderArea );
15055     void *                                            pNext      = {};
15083       : pNext( pNext_ )
15109       : pNext( pNext_ )
15133       pNext = pNext_;
15221         sType, pNext, flags, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat, rasterizationSamples );
15233       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewMask == rhs.viewMask ) &&
15248     const void *                              pNext                   = {};
15395       : pNext( pNext_ )
15422       pNext = pNext_;
15469       return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths );
15481       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) &&
15494     const void *                           pNext              = {};
15517       : pNext( pNext_ )
15542       pNext = pNext_;
15577       return std::tie( sType, pNext, commandBuffer, deviceMask );
15589       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) && ( deviceMask == rhs.deviceMask );
15601     const void *                        pNext         = {};
15625       : pNext( pNext_ )
15650       pNext = pNext_;
15685       return std::tie( sType, pNext, flags, queueFamilyIndex );
15697       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex );
15709     const void *                                 pNext            = {};
15962       : pNext( pNext_ )
15990       pNext = pNext_;
16050       return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo );
16059       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
16079       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( module == rhs.module ) &&
16090     const void *                                         pNext               = {};
16118       : pNext( pNext_ )
16146       pNext = pNext_;
16205       return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex );
16217       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( layout == rhs.layout ) &&
16230     const void *                                        pNext              = {};
16256       : pNext( pNext_ )
16282       pNext = pNext_;
16328       return std::tie( sType, pNext, deviceAddress, size, pipelineDeviceAddressCaptureReplay );
16340       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && ( size == rhs.size ) &&
16353     const void *                        pNext                              = {};
16377       : pNext( pNext_ )
16403       pNext = pNext_;
16448       return std::tie( sType, pNext, buffer, offset, flags );
16460       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( flags == rhs.flags );
16472     const void *                                       pNext  = {};
16603       : pNext( pNext_ )
16635       pNext = pNext_;
16723       return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, ResultType, saturatingAccumulation, scope );
16735       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && ( KSize == rhs.KSize ) &&
16749     void *                                 pNext                  = {};
16784       : pNext( pNext_ )
16815       pNext = pNext_;
16895       return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope );
16907       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && ( KSize == rhs.KSize ) &&
16920     void *                                pNext = {};
16950       : pNext( pNext_ )
16976       pNext = pNext_;
17021       return std::tie( sType, pNext, src, dst, mode );
17033       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && ( mode == rhs.mode );
17045     const void *                                           pNext = {};
17070       : pNext( pNext_ )
17096       pNext = pNext_;
17142       return std::tie( sType, pNext, src, dst, mode );
17148     const void *                                           pNext = {};
17173       : pNext( pNext_ )
17190       : pNext( pNext_ ), srcBuffer( srcBuffer_ ), dstBuffer( dstBuffer_ ), regionCount( static_cast<uint32_t>( regions_.size() ) ), pRegions( regions_.data() )
17207       pNext = pNext_;
17268       return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions );
17280       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && ( dstBuffer == rhs.dstBuffer ) &&
17293     const void *                              pNext       = {};
17322       : pNext( pNext_ )
17344       : pNext( pNext_ )
17366       pNext = pNext_;
17435       return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
17447       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && ( dstImage == rhs.dstImage ) &&
17460     const void *                                   pNext          = {};
17487       : pNext( pNext_ )
17511       pNext = pNext_;
17540       return std::tie( sType, pNext, transform );
17552       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform );
17564     const void *                                      pNext     = {};
17590       : pNext( pNext_ )
17617       pNext = pNext_;
17690       return std::tie( sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount );
17702       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSet == rhs.srcSet ) && ( srcBinding == rhs.srcBinding ) &&
17716     const void *                        pNext           = {};
17746       : pNext( pNext_ )
17771       pNext = pNext_;
17830       return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
17842       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) &&
17855     const void *                                 pNext          = {};
17886       : pNext( pNext_ )
17907       : pNext( pNext_ )
17930       pNext = pNext_;
18005       return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
18017       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) &&
18030     const void *                             pNext          = {};
18061       : pNext( pNext_ )
18083       : pNext( pNext_ )
18105       pNext = pNext_;
18174       return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
18186       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) &&
18199     const void *                                   pNext          = {};
18231       : pNext( pNext_ )
18257       : pNext( pNext_ )
18281       pNext = pNext_;
18364       return std::tie( sType, pNext, flags, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
18376       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcImage == rhs.srcImage ) &&
18390     const void *                                pNext          = {};
18421       : pNext( pNext_ )
18450       pNext = pNext_;
18517       return std::tie( sType, pNext, pHostPointer, memoryRowLength, memoryImageHeight, imageSubresource, imageOffset, imageExtent );
18529       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pHostPointer == rhs.pHostPointer ) && ( memoryRowLength == rhs.memoryRowLength ) &&
18543     const void *                                 pNext             = {};
18572       : pNext( pNext_ )
18594       : pNext( pNext_ )
18616       pNext = pNext_;
18685       return std::tie( sType, pNext, flags, srcImage, srcImageLayout, regionCount, pRegions );
18697       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcImage == rhs.srcImage ) &&
18710     const void *                                       pNext          = {};
18833       : pNext( pNext_ )
18859       pNext = pNext_;
18906       return std::tie( sType, pNext, src, dst, mode );
18912     const void *                                           pNext = {};
19069       : pNext( pNext_ )
19098       pNext = pNext_;
19165       return std::tie( sType, pNext, pHostPointer, memoryRowLength, memoryImageHeight, imageSubresource, imageOffset, imageExtent );
19177       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pHostPointer == rhs.pHostPointer ) && ( memoryRowLength == rhs.memoryRowLength ) &&
19191     const void *                                 pNext             = {};
19220       : pNext( pNext_ )
19242       : pNext( pNext_ )
19264       pNext = pNext_;
19333       return std::tie( sType, pNext, flags, dstImage, dstImageLayout, regionCount, pRegions );
19345       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dstImage == rhs.dstImage ) &&
19358     const void *                                       pNext          = {};
19384       : pNext( pNext_ )
19410       pNext = pNext_;
19455       return std::tie( sType, pNext, src, dst, mode );
19461     const void *                                      pNext = {};
19485       : pNext( pNext_ )
19510       pNext = pNext_;
19555       return std::tie( sType, pNext, src, dst, mode );
19567       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && ( mode == rhs.mode );
19579     const void *                              pNext = {};
19603       : pNext( pNext_ )
19629       pNext = pNext_;
19674       return std::tie( sType, pNext, src, dst, mode );
19680     const void *                                 pNext = {};
19702       : pNext( pNext_ )
19727       pNext = pNext_;
19762       return std::tie( sType, pNext, module, pName );
19771       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
19785       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) );
19795     const void *                        pNext  = {};
19827       : pNext( pNext_ )
19859       : pNext( pNext_ )
19888       pNext = pNext_;
20015         sType, pNext, function, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, paramCount, pParams, extraCount, pExtras );
20027       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) &&
20042     const void *                        pNext          = {};
20072       : pNext( pNext_ )
20088       : pNext( pNext_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() )
20105       pNext = pNext_;
20150       return std::tie( sType, pNext, dataSize, pData );
20162       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
20174     const void *                        pNext    = {};
20196       : pNext( pNext_ )
20221       pNext = pNext_;
20256       return std::tie( sType, pNext, module, pName );
20265       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
20279       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) );
20289     const void *                        pNext  = {};
20323       : pNext( pNext_ )
20355       : pNext( pNext_ )
20384       pNext = pNext_;
20511         sType, pNext, function, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, paramCount, pParams, extraCount, pExtras );
20523       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) &&
20538     const void *                         pNext          = {};
20570       : pNext( pNext_ )
20586       : pNext( pNext_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() )
20603       pNext = pNext_;
20648       return std::tie( sType, pNext, dataSize, pData );
20660       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
20672     const void *                        pNext    = {};
20698       : pNext( pNext_ )
20717       : pNext( pNext_ )
20738       pNext = pNext_;
20810       return std::tie( sType, pNext, waitSemaphoreValuesCount, pWaitSemaphoreValues, signalSemaphoreValuesCount, pSignalSemaphoreValues );
20822       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) &&
20836     const void *                        pNext                      = {};
20860       : pNext( pNext_ )
20885       pNext = pNext_;
20920       return std::tie( sType, pNext, pMarkerName, color );
20929       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
20943       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pMarkerName == rhs.pMarkerName ) || ( strcmp( pMarkerName, rhs.pMarkerName ) == 0 ) ) &&
20954     const void *                                   pNext       = {};
20978       : pNext( pNext_ )
21004       pNext = pNext_;
21049       return std::tie( sType, pNext, objectType, object, pObjectName );
21058       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
21074       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( object == rhs.object ) &&
21085     const void *                                   pNext       = {};
21112       : pNext( pNext_ )
21135       : pNext( pNext_ ), objectType( objectType_ ), object( object_ ), tagName( tagName_ ), tagSize( tag_.size() * sizeof( T ) ), pTag( tag_.data() )
21152       pNext = pNext_;
21221       return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag );
21233       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( object == rhs.object ) && ( tagName == rhs.tagName ) &&
21246     const void *                                   pNext      = {};
21272       : pNext( pNext_ )
21298       pNext = pNext_;
21343       return std::tie( sType, pNext, flags, pfnCallback, pUserData );
21352       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData );
21363     const void *                              pNext       = {};
21385       : pNext( pNext_ )
21407       pNext = pNext_;
21442       return std::tie( sType, pNext, pLabelName, color );
21451       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
21465       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pLabelName == rhs.pLabelName ) || ( strcmp( pLabelName, rhs.pLabelName ) == 0 ) ) &&
21476     const void *                                   pNext      = {};
21499       : pNext( pNext_ )
21525       pNext = pNext_;
21567       return std::tie( sType, pNext, objectType, objectHandle, pObjectName );
21576       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
21592       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) &&
21603     const void *                        pNext        = {};
21634       : pNext( pNext_ )
21665       : pNext( pNext_ )
21692       pNext = pNext_;
21821         sType, pNext, flags, pMessageIdName, messageIdNumber, pMessage, queueLabelCount, pQueueLabels, cmdBufLabelCount, pCmdBufLabels, objectCount, pObjects );
21830       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
21861       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
21875     const void *                                                  pNext            = {};
21908       : pNext( pNext_ )
21936       pNext = pNext_;
21997       return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData );
22006       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( messageSeverity == rhs.messageSeverity ) &&
22018     const void *                                            pNext           = {};
22046       : pNext( pNext_ )
22069       : pNext( pNext_ )
22091       pNext = pNext_;
22160       return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag );
22172       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) &&
22185     const void *                        pNext        = {};
22329       : pNext( pNext_ )
22353       pNext = pNext_;
22383       return std::tie( sType, pNext, dedicatedAllocation );
22395       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
22407     const void *                        pNext               = {};
22427       : pNext( pNext_ )
22451       pNext = pNext_;
22481       return std::tie( sType, pNext, dedicatedAllocation );
22493       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
22505     const void *                        pNext               = {};
22526       : pNext( pNext_ )
22551       pNext = pNext_;
22586       return std::tie( sType, pNext, image, buffer );
22598       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer );
22610     const void *                        pNext  = {};
22634       : pNext( pNext_ )
22658       pNext = pNext_;
22710       return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask );
22722       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) &&
22735     const void *                              pNext         = {};
22884       : pNext( pNext_ )
22916       pNext = pNext_;
23012                        pNext,
23034       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) &&
23049     const void *                                pNext               = {};
23086       : pNext( pNext_ )
23107       : pNext( pNext_ )
23131       pNext = pNext_;
23237                        pNext,
23256       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dependencyFlags == rhs.dependencyFlags ) &&
23271     const void *                                       pNext                    = {};
23301       : pNext( pNext_ )
23324       pNext = pNext_;
23365       return std::tie( sType, pNext, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
23377       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) &&
23390     const void *                        pNext                   = {};
23414       : pNext( pNext_ )
23439       pNext = pNext_;
23478       return std::tie( sType, pNext, depthBiasRepresentation, depthBiasExact );
23490       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasRepresentation == rhs.depthBiasRepresentation ) &&
23503     const void *                                     pNext                   = {};
23526       : pNext( pNext_ )
23552       pNext = pNext_;
23597       return std::tie( sType, pNext, address, range, format );
23609       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( address == rhs.address ) && ( range == rhs.range ) && ( format == rhs.format );
23621     void *                              pNext   = {};
23644       : pNext( pNext_ )
23669       pNext = pNext_;
23707       return std::tie( sType, pNext, address, usage );
23719       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( address == rhs.address ) && ( usage == rhs.usage );
23731     void *                                 pNext   = {};
23752       : pNext( pNext_ )
23778       pNext = pNext_;
23807       return std::tie( sType, pNext, buffer );
23819       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
23831     void *                              pNext  = {};
24165       : pNext( pNext_ )
24190       pNext = pNext_;
24228       return std::tie( sType, pNext, type, data );
24234     const void *                            pNext = {};
24342       : pNext( pNext_ )
24362       : pNext( pNext_ ), flags( flags_ ), maxSets( maxSets_ ), poolSizeCount( static_cast<uint32_t>( poolSizes_.size() ) ), pPoolSizes( poolSizes_.data() )
24379       pNext = pNext_;
24441       return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes );
24453       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) &&
24466     const void *                                     pNext         = {};
24489       : pNext( pNext_ )
24513       pNext = pNext_;
24543       return std::tie( sType, pNext, maxInlineUniformBlockBindings );
24555       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings );
24567     const void *                        pNext                         = {};
24591       : pNext( pNext_ )
24609       : pNext( pNext_ ), descriptorPool( descriptorPool_ ), descriptorSetCount( static_cast<uint32_t>( setLayouts_.size() ) ), pSetLayouts( setLayouts_.data() )
24626       pNext = pNext_;
24681       return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts );
24693       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) && ( descriptorSetCount == rhs.descriptorSetCount ) &&
24706     const void *                                      pNext              = {};
24729       : pNext( pNext_ )
24754       pNext = pNext_;
24790       return std::tie( sType, pNext, descriptorSetLayout, binding );
24802       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( binding == rhs.binding );
24814     const void *                              pNext               = {};
24979       : pNext( pNext_ )
24995       : pNext( pNext_ ), bindingCount( static_cast<uint32_t>( bindingFlags_.size() ) ), pBindingFlags( bindingFlags_.data() )
25012       pNext = pNext_;
25059       return std::tie( sType, pNext, bindingCount, pBindingFlags );
25071       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) && ( pBindingFlags == rhs.pBindingFlags );
25083     const void *                                         pNext         = {};
25108       : pNext( pNext_ )
25126       : pNext( pNext_ ), flags( flags_ ), bindingCount( static_cast<uint32_t>( bindings_.size() ) ), pBindings( bindings_.data() )
25143       pNext = pNext_;
25199       return std::tie( sType, pNext, flags, bindingCount, pBindings );
25211       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( bindingCount == rhs.bindingCount ) &&
25224     const void *                                             pNext        = {};
25246       : pNext( pNext_ )
25271       pNext = pNext_;
25306       return std::tie( sType, pNext, descriptorOffset, descriptorSize );
25318       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorOffset == rhs.descriptorOffset ) && ( descriptorSize == rhs.descriptorSize );
25330     void *                              pNext            = {};
25350       : pNext( pNext_ )
25389       return std::tie( sType, pNext, supported );
25401       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported );
25413     void *                              pNext     = {};
25436       : pNext( pNext_ )
25453       : pNext( pNext_ ), descriptorSetCount( static_cast<uint32_t>( descriptorCounts_.size() ) ), pDescriptorCounts( descriptorCounts_.data() )
25470       pNext = pNext_;
25515       return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts );
25527       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) &&
25540     const void *                        pNext              = {};
25563       : pNext( pNext_ )
25604       return std::tie( sType, pNext, maxVariableDescriptorCount );
25616       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount );
25628     void *                              pNext                      = {};
25784       : pNext( pNext_ )
25813       : pNext( pNext_ )
25838       pNext = pNext_;
25935         sType, pNext, flags, descriptorUpdateEntryCount, pDescriptorUpdateEntries, templateType, descriptorSetLayout, pipelineBindPoint, pipelineLayout, set );
25947       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) &&
25962     const void *                                                pNext                      = {};
25995       : pNext( pNext_ )
26022       pNext = pNext_;
26075       return std::tie( sType, pNext, flags, baseAddress, size, bindingType );
26087       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( baseAddress == rhs.baseAddress ) && ( size == rhs.size ) &&
26100     void *                                             pNext       = {};
26123       : pNext( pNext_ )
26147       pNext = pNext_;
26176       return std::tie( sType, pNext, pCreateInfo );
26188       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo );
26200     const void *                                   pNext       = {};
26225       : pNext( pNext_ )
26245       : pNext( pNext_ )
26266       pNext = pNext_;
26327       return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities );
26339       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
26352     const void *                                 pNext            = {};
27092       : pNext( pNext_ )
27115       : pNext( pNext_ )
27140       pNext = pNext_;
27252                        pNext,
27269       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
27302       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueCreateInfoCount == rhs.queueCreateInfoCount ) &&
27323     const void *                                         pNext                   = {};
27352       : pNext( pNext_ )
27378       pNext = pNext_;
27424       return std::tie( sType, pNext, flags, pfnUserCallback, pUserData );
27433       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnUserCallback == rhs.pfnUserCallback ) &&
27445     const void *                                     pNext           = {};
27467       : pNext( pNext_ )
27491       pNext = pNext_;
27520       return std::tie( sType, pNext, flags );
27532       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
27544     const void *                                         pNext = {};
27564       : pNext( pNext_ )
27585       pNext = pNext_;
27614       return std::tie( sType, pNext, deviceEvent );
27626       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceEvent == rhs.deviceEvent );
27638     const void *                             pNext       = {};
27757       : pNext( pNext_ )
27783       pNext = pNext_;
27824       return std::tie( sType, pNext, addressInfoCount, vendorInfoCount, vendorBinarySize );
27836       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( addressInfoCount == rhs.addressInfoCount ) && ( vendorInfoCount == rhs.vendorInfoCount ) &&
27849     void *                              pNext            = {};
27970       : pNext( pNext_ )
27994       pNext = pNext_;
28046       return std::tie( sType, pNext, description, pAddressInfos, pVendorInfos, pVendorBinaryData );
28058       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( description == rhs.description ) && ( pAddressInfos == rhs.pAddressInfos ) &&
28071     void *                                                              pNext             = {};
28288       : pNext( pNext_ )
28313       pNext = pNext_;
28348       return std::tie( sType, pNext, resourceDeviceIndex, memoryDeviceIndex );
28360       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) &&
28373     const void *                        pNext               = {};
28395       : pNext( pNext_ )
28419       pNext = pNext_;
28448       return std::tie( sType, pNext, deviceMask );
28460       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask );
28472     const void *                        pNext      = {};
28495       : pNext( pNext_ )
28511       : pNext( pNext_ ), physicalDeviceCount( static_cast<uint32_t>( physicalDevices_.size() ) ), pPhysicalDevices( physicalDevices_.data() )
28528       pNext = pNext_;
28574       return std::tie( sType, pNext, physicalDeviceCount, pPhysicalDevices );
28586       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) &&
28599     const void *                                 pNext               = {};
28623       : pNext( pNext_ )
28666       return std::tie( sType, pNext, presentMask, modes );
28678       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMask == rhs.presentMask ) && ( modes == rhs.modes );
28690     void *                                                                   pNext       = {};
28714       : pNext( pNext_ )
28732       : pNext( pNext_ ), swapchainCount( static_cast<uint32_t>( deviceMasks_.size() ) ), pDeviceMasks( deviceMasks_.data() ), mode( mode_ )
28749       pNext = pNext_;
28803       return std::tie( sType, pNext, swapchainCount, pDeviceMasks, mode );
28815       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pDeviceMasks == rhs.pDeviceMasks ) &&
28828     const void *                                            pNext          = {};
28852       : pNext( pNext_ )
28870       : pNext( pNext_ )
28890       pNext = pNext_;
28943       return std::tie( sType, pNext, deviceMask, deviceRenderAreaCount, pDeviceRenderAreas );
28955       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ) && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) &&
28968     const void *                         pNext                 = {};
28997       : pNext( pNext_ )
29019       : pNext( pNext_ )
29042       pNext = pNext_;
29139                        pNext,
29157       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
29172     const void *                        pNext                         = {};
29199       : pNext( pNext_ )
29223       pNext = pNext_;
29252       return std::tie( sType, pNext, modes );
29264       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( modes == rhs.modes );
29276     const void *                                         pNext = {};
29308       : pNext( pNext_ )
29343       : pNext( pNext_ )
29373       pNext = pNext_;
29498                        pNext,
29523       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( imageType == rhs.imageType ) && ( format == rhs.format ) &&
29539     const void *                              pNext                 = {};
29573       : pNext( pNext_ )
29598       pNext = pNext_;
29636       return std::tie( sType, pNext, pCreateInfo, planeAspect );
29648       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) && ( planeAspect == rhs.planeAspect );
29660     const void *                                  pNext       = {};
29682       : pNext( pNext_ )
29706       pNext = pNext_;
29735       return std::tie( sType, pNext, imageSubresource );
29747       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageSubresource == rhs.imageSubresource );
29759     void *                                 pNext            = {};
29782       : pNext( pNext_ )
29807       pNext = pNext_;
29846       return std::tie( sType, pNext, pCreateInfo, pSubresource );
29858       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) && ( pSubresource == rhs.pSubresource );
29870     const void *                                       pNext        = {};
29891       : pNext( pNext_ )
29915       pNext = pNext_;
29944       return std::tie( sType, pNext, memory );
29956       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory );
29968     const void *                        pNext  = {};
29991       : pNext( pNext_ )
30015       pNext = pNext_;
30045       return std::tie( sType, pNext, overallocationBehavior );
30057       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( overallocationBehavior == rhs.overallocationBehavior );
30069     const void *                                          pNext                  = {};
30096       : pNext( pNext_ )
30149       return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex );
30161       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) && ( memoryObjectId == rhs.memoryObjectId ) &&
30174     void *                                               pNext          = {};
30244       : pNext( pNext_ )
30268       pNext = pNext_;
30297       return std::tie( sType, pNext, privateDataSlotRequestCount );
30309       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateDataSlotRequestCount == rhs.privateDataSlotRequestCount );
30321     const void *                        pNext                       = {};
30344       : pNext( pNext_ )
30368       pNext = pNext_;
30398       return std::tie( sType, pNext, globalPriority );
30410       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriority == rhs.globalPriority );
30422     const void *                                 pNext          = {};
30446       : pNext( pNext_ )
30469       pNext = pNext_;
30514       return std::tie( sType, pNext, flags, queueFamilyIndex, queueIndex );
30526       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
30539     const void *                                 pNext            = {};
30560       : pNext( pNext_ )
30584       pNext = pNext_;
30613       return std::tie( sType, pNext, shaderCoreCount );
30625       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreCount == rhs.shaderCoreCount );
30637     void *                              pNext           = {};
30658       : pNext( pNext_ )
30683       pNext = pNext_;
30722       return std::tie( sType, pNext, flags, pfnGetInstanceProcAddr );
30731       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnGetInstanceProcAddr == rhs.pfnGetInstanceProcAddr );
30742     void *                                               pNext                  = {};
30766       : pNext( pNext_ )
30784       : pNext( pNext_ ), mode( mode_ ), driverCount( static_cast<uint32_t>( drivers_.size() ) ), pDrivers( drivers_.data() )
30801       pNext = pNext_;
30857       return std::tie( sType, pNext, mode, driverCount, pDrivers );
30866       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( driverCount == rhs.driverCount ) && ( pDrivers == rhs.pDrivers );
30877     const void *                                                pNext       = {};
30902       : pNext( pNext_ )
30928       pNext = pNext_;
30973       return std::tie( sType, pNext, flags, dfb, surface );
30985       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) && ( surface == rhs.surface );
30997     const void *                                        pNext   = {};
31284       : pNext( pNext_ )
31307       pNext = pNext_;
31336       return std::tie( sType, pNext, displayEvent );
31348       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayEvent == rhs.displayEvent );
31360     const void *                              pNext        = {};
31467       : pNext( pNext_ )
31492       pNext = pNext_;
31530       return std::tie( sType, pNext, flags, parameters );
31542       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( parameters == rhs.parameters );
31554     const void *                                    pNext      = {};
31648       : pNext( pNext_ )
31687       return std::tie( sType, pNext, displayModeProperties );
31699       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayModeProperties == rhs.displayModeProperties );
31711     void *                                         pNext                 = {};
31731       : pNext( pNext_ )
31770       return std::tie( sType, pNext, localDimmingSupport );
31782       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingSupport == rhs.localDimmingSupport );
31794     void *                              pNext               = {};
31918       : pNext( pNext_ )
31957       return std::tie( sType, pNext, capabilities );
31969       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilities == rhs.capabilities );
31981     void *                                            pNext        = {};
32001       : pNext( pNext_ )
32026       pNext = pNext_;
32061       return std::tie( sType, pNext, mode, planeIndex );
32073       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( planeIndex == rhs.planeIndex );
32085     const void *                         pNext      = {};
32179       : pNext( pNext_ )
32218       return std::tie( sType, pNext, displayPlaneProperties );
32230       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPlaneProperties == rhs.displayPlaneProperties );
32242     void *                                          pNext                  = {};
32262       : pNext( pNext_ )
32285       pNext = pNext_;
32314       return std::tie( sType, pNext, powerState );
32326       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( powerState == rhs.powerState );
32338     const void *                               pNext      = {};
32360       : pNext( pNext_ )
32386       pNext = pNext_;
32431       return std::tie( sType, pNext, srcRect, dstRect, persistent );
32443       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRect == rhs.srcRect ) && ( dstRect == rhs.dstRect ) && ( persistent == rhs.persistent );
32455     const void *                        pNext      = {};
32589       : pNext( pNext_ )
32628       return std::tie( sType, pNext, displayProperties );
32640       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayProperties == rhs.displayProperties );
32652     void *                                     pNext             = {};
32680       : pNext( pNext_ )
32711       pNext = pNext_;
32791       return std::tie( sType, pNext, flags, displayMode, planeIndex, planeStackIndex, transform, globalAlpha, alphaMode, imageExtent );
32803       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( displayMode == rhs.displayMode ) &&
32817     const void *                                       pNext           = {};
33400       : pNext( pNext_ )
33417       : pNext( pNext_ )
33451       return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties );
33463       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
33476     void *                                                  pNext                        = {};
33498       : pNext( pNext_ )
33515       : pNext( pNext_ )
33549       return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties );
33561       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
33574     void *                                                 pNext                        = {};
33594       : pNext( pNext_ )
33615       pNext = pNext_;
33644       return std::tie( sType, pNext, flags );
33656       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
33668     const void *                           pNext = {};
33689       : pNext( pNext_ )
33705       : pNext( pNext_ ), libraryCount( static_cast<uint32_t>( libraries_.size() ) ), pLibraries( libraries_.data() )
33722       pNext = pNext_;
33767       return std::tie( sType, pNext, libraryCount, pLibraries );
33779       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( libraryCount == rhs.libraryCount ) && ( pLibraries == rhs.pLibraries );
33791     const void *                           pNext        = {};
33819       : pNext( pNext_ )
33846       : pNext( pNext_ )
33870       pNext = pNext_;
33956       return std::tie( sType, pNext, flags, stageCount, pStages, pLibraryInfo, layout, basePipelineHandle, basePipelineIndex );
33968       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) &&
33982     const void *                                                pNext              = {};
34009       : pNext( pNext_ )
34033       pNext = pNext_;
34062       return std::tie( sType, pNext, size );
34074       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( size == rhs.size );
34086     void *                              pNext = {};
34107       : pNext( pNext_ )
34131       pNext = pNext_;
34160       return std::tie( sType, pNext, handleTypes );
34172       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
34184     const void *                                       pNext       = {};
34209       : pNext( pNext_ )
34235       pNext = pNext_;
34276       return std::tie( sType, pNext, pAttributes, dwAccess, name );
34288       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
34300     const void *                        pNext       = {};
34323       : pNext( pNext_ )
34347       pNext = pNext_;
34376       return std::tie( sType, pNext, handleTypes );
34388       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
34400     const void *                                        pNext       = {};
34422       : pNext( pNext_ )
34446       pNext = pNext_;
34476       return std::tie( sType, pNext, handleTypes );
34488       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
34500     const void *                                          pNext       = {};
34523       : pNext( pNext_ )
34549       pNext = pNext_;
34590       return std::tie( sType, pNext, pAttributes, dwAccess, name );
34602       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
34614     const void *                        pNext       = {};
34638       : pNext( pNext_ )
34663       pNext = pNext_;
34698       return std::tie( sType, pNext, pAttributes, dwAccess );
34710       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess );
34722     const void *                        pNext       = {};
34746       : pNext( pNext_ )
34771       pNext = pNext_;
34806       return std::tie( sType, pNext, memory, mtlBuffer );
34818       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( mtlBuffer == rhs.mtlBuffer );
34830     const void *                        pNext     = {};
34854       : pNext( pNext_ )
34879       pNext = pNext_;
34914       return std::tie( sType, pNext, queue, mtlCommandQueue );
34926       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queue == rhs.queue ) && ( mtlCommandQueue == rhs.mtlCommandQueue );
34938     const void *                        pNext           = {};
34960       : pNext( pNext_ )
34984       pNext = pNext_;
35013       return std::tie( sType, pNext, mtlDevice );
35025       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mtlDevice == rhs.mtlDevice );
35037     const void *                        pNext     = {};
35059       : pNext( pNext_ )
35084       pNext = pNext_;
35119       return std::tie( sType, pNext, image, ioSurface );
35131       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( ioSurface == rhs.ioSurface );
35143     const void *                        pNext     = {};
35167       : pNext( pNext_ )
35191       pNext = pNext_;
35221       return std::tie( sType, pNext, exportObjectType );
35233       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exportObjectType == rhs.exportObjectType );
35245     const void *                                           pNext            = {};
35265     VULKAN_HPP_CONSTEXPR ExportMetalObjectsInfoEXT( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) {}
35286       pNext = pNext_;
35309       return std::tie( sType, pNext );
35321       return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
35333     const void *                        pNext = {};
35356       : pNext( pNext_ )
35382       pNext = pNext_;
35427       return std::tie( sType, pNext, semaphore, event, mtlSharedEvent );
35439       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( event == rhs.event ) &&
35452     const void *                        pNext          = {};
35480       : pNext( pNext_ )
35508       pNext = pNext_;
35567       return std::tie( sType, pNext, image, imageView, bufferView, plane, mtlTexture );
35579       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( imageView == rhs.imageView ) && ( bufferView == rhs.bufferView ) &&
35592     const void *                              pNext      = {};
35617       : pNext( pNext_ )
35641       pNext = pNext_;
35671       return std::tie( sType, pNext, handleTypes );
35683       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
35695     const void *                                           pNext       = {};
35720       : pNext( pNext_ )
35746       pNext = pNext_;
35787       return std::tie( sType, pNext, pAttributes, dwAccess, name );
35799       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
35811     const void *                        pNext       = {};
35987       : pNext( pNext_ )
36026       return std::tie( sType, pNext, externalMemoryProperties );
36038       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties );
36050     void *                                         pNext                    = {};
36074       : pNext( pNext_ )
36119       return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalFenceFeatures );
36131       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
36144     void *                                             pNext                         = {};
36168       : pNext( pNext_ )
36192       pNext = pNext_;
36221       return std::tie( sType, pNext, externalFormat );
36233       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat );
36245     void *                              pNext          = {};
36266       : pNext( pNext_ )
36287       pNext = pNext_;
36316       return std::tie( sType, pNext, externalFormat );
36328       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat );
36340     void *                              pNext          = {};
36361       : pNext( pNext_ )
36400       return std::tie( sType, pNext, externalMemoryProperties );
36412       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties );
36424     void *                                         pNext                    = {};
36617       : pNext( pNext_ )
36641       pNext = pNext_;
36671       return std::tie( sType, pNext, acquireUnmodifiedMemory );
36683       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireUnmodifiedMemory == rhs.acquireUnmodifiedMemory );
36695     const void *                        pNext                   = {};
36715       : pNext( pNext_ )
36739       pNext = pNext_;
36769       return std::tie( sType, pNext, handleTypes );
36781       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
36793     const void *                                        pNext       = {};
36815       : pNext( pNext_ )
36839       pNext = pNext_;
36869       return std::tie( sType, pNext, handleTypes );
36881       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
36893     const void *                                        pNext       = {};
36915       : pNext( pNext_ )
36939       pNext = pNext_;
36969       return std::tie( sType, pNext, handleTypes );
36981       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
36993     const void *                                          pNext       = {};
37015       : pNext( pNext_ )
37060       return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalSemaphoreFeatures );
37072       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
37085     void *                                                 pNext                         = {};
37108       : pNext( pNext_ )
37129       pNext = pNext_;
37158       return std::tie( sType, pNext, flags );
37170       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
37182     const void *                           pNext = {};
37204       : pNext( pNext_ )
37226       pNext = pNext_;
37264       return std::tie( sType, pNext, fence, handleType );
37276       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( handleType == rhs.handleType );
37288     const void *                                          pNext      = {};
37312       : pNext( pNext_ )
37337       pNext = pNext_;
37375       return std::tie( sType, pNext, fence, handleType );
37387       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( handleType == rhs.handleType );
37399     const void *                                          pNext      = {};
37422       : pNext( pNext_ )
37462       return std::tie( sType, pNext, filterCubic, filterCubicMinmax );
37474       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCubic == rhs.filterCubic ) && ( filterCubicMinmax == rhs.filterCubicMinmax );
37486     void *                              pNext             = {};
37582       : pNext( pNext_ )
37618       return std::tie( sType, pNext, formatProperties );
37630       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatProperties == rhs.formatProperties );
37642     void *                                 pNext            = {};
37666       : pNext( pNext_ )
37708       return std::tie( sType, pNext, linearTilingFeatures, optimalTilingFeatures, bufferFeatures );
37720       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearTilingFeatures == rhs.linearTilingFeatures ) &&
37733     void *                                    pNext                 = {};
37758       : pNext( pNext_ )
37783       pNext = pNext_;
37823       return std::tie( sType, pNext, pFragmentShadingRateAttachment, shadingRateAttachmentTexelSize );
37835       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pFragmentShadingRateAttachment == rhs.pFragmentShadingRateAttachment ) &&
37848     const void *                                       pNext                          = {};
37877       : pNext( pNext_ )
37903       : pNext( pNext_ )
37929       pNext = pNext_;
38044       return std::tie( sType, pNext, flags, frameID, imageCount, pImages, bufferCount, pBuffers, tagName, tagSize, pTag );
38056       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( frameID == rhs.frameID ) && ( imageCount == rhs.imageCount ) &&
38070     const void *                                pNext       = {};
38104       : pNext( pNext_ )
38130       : pNext( pNext_ )
38154       pNext = pNext_;
38237       return std::tie( sType, pNext, flags, usage, width, height, layerCount, viewFormatCount, pViewFormats );
38249       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && ( width == rhs.width ) &&
38262     const void *                           pNext           = {};
38291       : pNext( pNext_ )
38308       : pNext( pNext_ )
38327       pNext = pNext_;
38377       return std::tie( sType, pNext, attachmentImageInfoCount, pAttachmentImageInfos );
38389       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentImageInfoCount == rhs.attachmentImageInfoCount ) &&
38402     const void *                                                 pNext                    = {};
38431       : pNext( pNext_ )
38457       : pNext( pNext_ )
38481       pNext = pNext_;
38564       return std::tie( sType, pNext, flags, renderPass, attachmentCount, pAttachments, width, height, layers );
38576       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( renderPass == rhs.renderPass ) &&
38590     const void *                                 pNext           = {};
38620       : pNext( pNext_ )
38667       return std::tie( sType, pNext, coverageReductionMode, rasterizationSamples, depthStencilSamples, colorSamples );
38679       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode ) &&
38692     void *                                        pNext                 = {};
38815       : pNext( pNext_ )
38853       : pNext( pNext_ )
38883       pNext = pNext_;
39010                        pNext,
39035       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipeline == rhs.pipeline ) &&
39052     const void *                                           pNext                  = {};
39088       : pNext( pNext_ )
39115       pNext = pNext_;
39169       return std::tie( sType, pNext, pipelineBindPoint, pipeline, indirectCommandsLayout, maxSequencesCount );
39181       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipeline == rhs.pipeline ) &&
39194     const void *                                   pNext                  = {};
39230       : pNext( pNext_ )
39267       pNext = pNext_;
39390                        pNext,
39416       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ) && ( inputSampleTimeUs == rhs.inputSampleTimeUs ) &&
39433     const void *                        pNext                    = {};
39467       : pNext( pNext_ )
39483       : pNext( pNext_ ), timingCount( static_cast<uint32_t>( timings_.size() ) ), pTimings( timings_.data() )
39500       pNext = pNext_;
39545       return std::tie( sType, pNext, timingCount, pTimings );
39557       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timingCount == rhs.timingCount ) && ( pTimings == rhs.pTimings );
39569     const void *                                        pNext       = {};
39796       : pNext( pNext_ )
39818       : pNext( pNext_ )
39840       pNext = pNext_;
39926         sType, pNext, flags, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
39938       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
39952     const void *                                                  pNext                           = {};
39979       : pNext( pNext_ )
40005       pNext = pNext_;
40052       return std::tie( sType, pNext, flags, topology, primitiveRestartEnable );
40064       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( topology == rhs.topology ) &&
40077     const void *                                                pNext                  = {};
40100       : pNext( pNext_ )
40125       pNext = pNext_;
40164       return std::tie( sType, pNext, flags, patchControlPoints );
40176       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( patchControlPoints == rhs.patchControlPoints );
40188     const void *                                               pNext              = {};
40213       : pNext( pNext_ )
40234       : pNext( pNext_ )
40256       pNext = pNext_;
40335       return std::tie( sType, pNext, flags, viewportCount, pViewports, scissorCount, pScissors );
40347       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewportCount == rhs.viewportCount ) &&
40360     const void *                                           pNext         = {};
40394       : pNext( pNext_ )
40428       pNext = pNext_;
40532                        pNext,
40555       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( depthClampEnable == rhs.depthClampEnable ) &&
40570     const void *                                                pNext                   = {};
40607       : pNext( pNext_ )
40637       pNext = pNext_;
40713       return std::tie( sType, pNext, flags, rasterizationSamples, sampleShadingEnable, minSampleShading, pSampleMask, alphaToCoverageEnable, alphaToOneEnable );
40725       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rasterizationSamples == rhs.rasterizationSamples ) &&
40739     const void *                                              pNext                 = {};
40910       : pNext( pNext_ )
40943       pNext = pNext_;
41040                        pNext,
41062       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( depthTestEnable == rhs.depthTestEnable ) &&
41077     const void *                                               pNext                 = {};
41267       : pNext( pNext_ )
41292       : pNext( pNext_ )
41315       pNext = pNext_;
41392       return std::tie( sType, pNext, flags, logicOpEnable, logicOp, attachmentCount, pAttachments, blendConstants );
41404       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( logicOpEnable == rhs.logicOpEnable ) &&
41418     const void *                                                    pNext           = {};
41445       : pNext( pNext_ )
41463       : pNext( pNext_ ), flags( flags_ ), dynamicStateCount( static_cast<uint32_t>( dynamicStates_.size() ) ), pDynamicStates( dynamicStates_.data() )
41480       pNext = pNext_;
41535       return std::tie( sType, pNext, flags, dynamicStateCount, pDynamicStates );
41547       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dynamicStateCount == rhs.dynamicStateCount ) &&
41560     const void *                                          pNext             = {};
41598       : pNext( pNext_ )
41644       : pNext( pNext_ )
41678       pNext = pNext_;
41841                        pNext,
41870       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) &&
41888     const void *                                                       pNext               = {};
41924       : pNext( pNext_ )
41948       pNext = pNext_;
41977       return std::tie( sType, pNext, flags );
41989       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
42001     const void *                                          pNext = {};
42024       : pNext( pNext_ )
42044       : pNext( pNext_ )
42065       pNext = pNext_;
42130       return std::tie( sType, pNext, stageCount, pStages, pVertexInputState, pTessellationState );
42142       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) &&
42155     const void *                                                      pNext              = {};
42181       : pNext( pNext_ )
42201       : pNext( pNext_ )
42222       pNext = pNext_;
42295       return std::tie( sType, pNext, groupCount, pGroups, pipelineCount, pPipelines );
42307       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( groupCount == rhs.groupCount ) && ( pGroups == rhs.pGroups ) &&
42320     const void *                                                  pNext         = {};
42433       : pNext( pNext_ )
42461       pNext = pNext_;
42542                        pNext,
42562       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPrimaryRed == rhs.displayPrimaryRed ) &&
42577     const void *                        pNext                     = {};
42604       : pNext( pNext_ )
42628       pNext = pNext_;
42657       return std::tie( sType, pNext, flags );
42669       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
42681     const void *                                        pNext = {};
42702       : pNext( pNext_ )
42742       return std::tie( sType, pNext, optimalDeviceAccess, identicalMemoryLayout );
42754       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimalDeviceAccess == rhs.optimalDeviceAccess ) &&
42767     void *                              pNext                 = {};
42791       : pNext( pNext_ )
42818       pNext = pNext_;
42871       return std::tie( sType, pNext, image, oldLayout, newLayout, subresourceRange );
42883       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( oldLayout == rhs.oldLayout ) && ( newLayout == rhs.newLayout ) &&
42896     const void *                                pNext            = {};
42921       : pNext( pNext_ )
42946       pNext = pNext_;
42981       return std::tie( sType, pNext, flags, pView );
42993       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView );
43005     const void *                                   pNext = {};
43132       : pNext( pNext_ )
43156       pNext = pNext_;
43185       return std::tie( sType, pNext, image );
43197       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image );
43209     const void *                        pNext = {};
43231       : pNext( pNext_ )
43249       : pNext( pNext_ )
43269       pNext = pNext_;
43325       return std::tie( sType, pNext, flags, compressionControlPlaneCount, pFixedRateFlags );
43337       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
43350     const void *                                              pNext                        = {};
43373       : pNext( pNext_ )
43416       return std::tie( sType, pNext, imageCompressionFlags, imageCompressionFixedRateFlags );
43428       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCompressionFlags == rhs.imageCompressionFlags ) &&
43441     void *                                                  pNext                          = {};
43468       : pNext( pNext_ )
43492       : pNext( pNext_ )
43515       pNext = pNext_;
43594       return std::tie( sType, pNext, imageCreateInfo, requiredFormatFeatures, flags, sysmemPixelFormat, colorSpaceCount, pColorSpaces );
43606       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCreateInfo == rhs.imageCreateInfo ) &&
43620     const void *                                             pNext                  = {};
43650       : pNext( pNext_ )
43671       : pNext( pNext_ )
43692       pNext = pNext_;
43757       return std::tie( sType, pNext, formatConstraintsCount, pFormatConstraints, bufferCollectionConstraints, flags );
43769       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatConstraintsCount == rhs.formatConstraintsCount ) &&
43782     const void *                                                    pNext                       = {};
44040       : pNext( pNext_ )
44059       : pNext( pNext_ )
44079       pNext = pNext_;
44136       return std::tie( sType, pNext, drmFormatModifier, drmFormatModifierPlaneCount, pPlaneLayouts );
44148       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) &&
44161     const void *                                    pNext                       = {};
44184       : pNext( pNext_ )
44200       : pNext( pNext_ ), drmFormatModifierCount( static_cast<uint32_t>( drmFormatModifiers_.size() ) ), pDrmFormatModifiers( drmFormatModifiers_.data() )
44217       pNext = pNext_;
44262       return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifiers );
44274       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
44287     const void *                        pNext                  = {};
44307       : pNext( pNext_ )
44346       return std::tie( sType, pNext, drmFormatModifier );
44358       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier );
44370     void *                              pNext             = {};
44391       : pNext( pNext_ )
44407       : pNext( pNext_ ), viewFormatCount( static_cast<uint32_t>( viewFormats_.size() ) ), pViewFormats( viewFormats_.data() )
44424       pNext = pNext_;
44469       return std::tie( sType, pNext, viewFormatCount, pViewFormats );
44481       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats );
44493     const void *                         pNext           = {};
44516       : pNext( pNext_ )
44555       return std::tie( sType, pNext, imageFormatProperties );
44567       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFormatProperties == rhs.imageFormatProperties );
44579     void *                                      pNext                 = {};
44608       : pNext( pNext_ )
44636       pNext = pNext_;
44717       return std::tie( sType, pNext, srcAccessMask, dstAccessMask, oldLayout, newLayout, srcQueueFamilyIndex, dstQueueFamilyIndex, image, subresourceRange );
44729       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) &&
44743     const void *                                pNext               = {};
44769       : pNext( pNext_ )
44793       pNext = pNext_;
44822       return std::tie( sType, pNext, image );
44834       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image );
44846     const void *                        pNext = {};
44870       : pNext( pNext_ )
44895       pNext = pNext_;
44933       return std::tie( sType, pNext, flags, imagePipeHandle );
44942       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
44955       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
44966     const void *                                             pNext           = {};
44989       : pNext( pNext_ )
45013       pNext = pNext_;
45042       return std::tie( sType, pNext, planeAspect );
45054       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect );
45066     const void *                              pNext       = {};
45208       : pNext( pNext_ )
45233       pNext = pNext_;
45292       return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
45304       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) &&
45317     const void *                                 pNext          = {};
45342       : pNext( pNext_ )
45366       pNext = pNext_;
45395       return std::tie( sType, pNext, image );
45407       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image );
45419     const void *                        pNext = {};
45441       : pNext( pNext_ )
45465       pNext = pNext_;
45494       return std::tie( sType, pNext, stencilUsage );
45506       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilUsage == rhs.stencilUsage );
45518     const void *                          pNext        = {};
45539       : pNext( pNext_ )
45563       pNext = pNext_;
45592       return std::tie( sType, pNext, swapchain );
45604       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain );
45616     const void *                        pNext     = {};
45636       : pNext( pNext_ )
45660       pNext = pNext_;
45689       return std::tie( sType, pNext, decodeMode );
45701       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeMode == rhs.decodeMode );
45713     const void *                        pNext      = {};
45734       : pNext( pNext_ )
45775       return std::tie( sType, pNext, deviceAddress, size );
45787       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && ( size == rhs.size );
45799     void *                              pNext         = {};
45820       : pNext( pNext_ )
45844       pNext = pNext_;
45873       return std::tie( sType, pNext, imageView );
45885       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView );
45897     const void *                        pNext     = {};
45922       : pNext( pNext_ )
45950       pNext = pNext_;
46017       return std::tie( sType, pNext, flags, image, viewType, format, components, subresourceRange );
46029       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( image == rhs.image ) && ( viewType == rhs.viewType ) &&
46042     const void *                                pNext            = {};
46069       : pNext( pNext_ )
46095       pNext = pNext_;
46140       return std::tie( sType, pNext, imageView, descriptorType, sampler );
46152       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && ( descriptorType == rhs.descriptorType ) &&
46165     const void *                         pNext          = {};
46186       : pNext( pNext_ )
46210       pNext = pNext_;
46239       return std::tie( sType, pNext, minLod );
46251       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod );
46263     const void *                        pNext  = {};
46285       : pNext( pNext_ )
46311       pNext = pNext_;
46356       return std::tie( sType, pNext, filterCenter, filterSize, numPhases );
46368       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCenter == rhs.filterCenter ) && ( filterSize == rhs.filterSize ) &&
46381     const void *                        pNext        = {};
46403       : pNext( pNext_ )
46428       pNext = pNext_;
46463       return std::tie( sType, pNext, sliceOffset, sliceCount );
46475       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sliceOffset == rhs.sliceOffset ) && ( sliceCount == rhs.sliceCount );
46487     const void *                        pNext       = {};
46507       : pNext( pNext_ )
46531       pNext = pNext_;
46560       return std::tie( sType, pNext, usage );
46572       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage );
46584     const void *                          pNext = {};
46606       : pNext( pNext_ )
46630       pNext = pNext_;
46659       return std::tie( sType, pNext, buffer );
46671       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
46683     const void *                        pNext  = {};
46708       : pNext( pNext_ )
46735       pNext = pNext_;
46787       return std::tie( sType, pNext, fence, flags, handleType, fd );
46799       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) &&
46812     const void *                                          pNext      = {};
46841       : pNext( pNext_ )
46869       pNext = pNext_;
46929       return std::tie( sType, pNext, fence, flags, handleType, handle, name );
46941       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) &&
46954     const void *                                          pNext      = {};
46981       : pNext( pNext_ )
47006       pNext = pNext_;
47041       return std::tie( sType, pNext, collection, index );
47053       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index );
47065     const void *                                  pNext      = {};
47089       : pNext( pNext_ )
47114       pNext = pNext_;
47149       return std::tie( sType, pNext, handleType, fd );
47161       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd );
47173     const void *                                           pNext      = {};
47196       : pNext( pNext_ )
47221       pNext = pNext_;
47258       return std::tie( sType, pNext, handleType, pHostPointer );
47270       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( pHostPointer == rhs.pHostPointer );
47282     const void *                                           pNext        = {};
47307       : pNext( pNext_ )
47333       pNext = pNext_;
47379       return std::tie( sType, pNext, handleType, handle, name );
47391       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && ( name == rhs.name );
47403     const void *                                           pNext      = {};
47428       : pNext( pNext_ )
47453       pNext = pNext_;
47489       return std::tie( sType, pNext, handleType, handle );
47501       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle );
47513     const void *                                          pNext      = {};
47538       : pNext( pNext_ )
47563       pNext = pNext_;
47602       return std::tie( sType, pNext, handleType, handle );
47611       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
47624       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
47635     const void *                                           pNext      = {};
47657       : pNext( pNext_ )
47681       pNext = pNext_;
47710       return std::tie( sType, pNext, mtlBuffer );
47722       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mtlBuffer == rhs.mtlBuffer );
47734     const void *                        pNext     = {};
47755       : pNext( pNext_ )
47779       pNext = pNext_;
47808       return std::tie( sType, pNext, ioSurface );
47820       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ioSurface == rhs.ioSurface );
47832     const void *                        pNext     = {};
47853       : pNext( pNext_ )
47877       pNext = pNext_;
47906       return std::tie( sType, pNext, mtlSharedEvent );
47918       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mtlSharedEvent == rhs.mtlSharedEvent );
47930     const void *                        pNext          = {};
47953       : pNext( pNext_ )
47978       pNext = pNext_;
48013       return std::tie( sType, pNext, plane, mtlTexture );
48025       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( plane == rhs.plane ) && ( mtlTexture == rhs.mtlTexture );
48037     const void *                              pNext      = {};
48059       : pNext( pNext_ )
48083       pNext = pNext_;
48112       return std::tie( sType, pNext, buffer );
48124       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
48136     const void *                        pNext  = {};
48161       : pNext( pNext_ )
48188       pNext = pNext_;
48241       return std::tie( sType, pNext, semaphore, flags, handleType, fd );
48253       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) &&
48266     const void *                                              pNext      = {};
48295       : pNext( pNext_ )
48323       pNext = pNext_;
48383       return std::tie( sType, pNext, semaphore, flags, handleType, handle, name );
48395       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) &&
48408     const void *                                              pNext      = {};
48438       : pNext( pNext_ )
48465       pNext = pNext_;
48518       return std::tie( sType, pNext, semaphore, flags, handleType, zirconHandle );
48527       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
48544       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) &&
48555     const void *                                              pNext        = {};
48592       : pNext( pNext_ )
48630       : pNext( pNext_ )
48669       pNext = pNext_;
48808                        pNext,
48833       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tokenType == rhs.tokenType ) && ( stream == rhs.stream ) && ( offset == rhs.offset ) &&
48850     const void *                                      pNext                        = {};
48888       : pNext( pNext_ )
48912       : pNext( pNext_ )
48935       pNext = pNext_;
49023       return std::tie( sType, pNext, flags, pipelineBindPoint, tokenCount, pTokens, streamCount, pStreamStrides );
49035       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
49048     const void *                                                pNext             = {};
49072       : pNext( pNext_ )
49096       pNext = pNext_;
49125       return std::tie( sType, pNext, pUserData );
49137       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pUserData == rhs.pUserData );
49149     const void *                        pNext     = {};
49272       : pNext( pNext_ )
49292       : pNext( pNext_ )
49315       pNext = pNext_;
49401       return std::tie( sType, pNext, flags, pApplicationInfo, enabledLayerCount, ppEnabledLayerNames, enabledExtensionCount, ppEnabledExtensionNames );
49410       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
49439       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pApplicationInfo == rhs.pApplicationInfo ) &&
49459     const void *                                  pNext                   = {};
49484       : pNext( pNext_ )
49506       pNext = pNext_;
49541       return std::tie( sType, pNext, signalSemaphore, value );
49553       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( signalSemaphore == rhs.signalSemaphore ) && ( value == rhs.value );
49565     const void *                        pNext           = {};
49588       : pNext( pNext_ )
49614       pNext = pNext_;
49659       return std::tie( sType, pNext, lowLatencyMode, lowLatencyBoost, minimumIntervalUs );
49671       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lowLatencyMode == rhs.lowLatencyMode ) && ( lowLatencyBoost == rhs.lowLatencyBoost ) &&
49684     const void *                        pNext             = {};
49705       : pNext( pNext_ )
49729       pNext = pNext_;
49758       return std::tie( sType, pNext, presentID );
49770       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID );
49782     const void *                        pNext     = {};
49803       : pNext( pNext_ )
49819       : pNext( pNext_ ), presentModeCount( static_cast<uint32_t>( presentModes_.size() ) ), pPresentModes( presentModes_.data() )
49836       pNext = pNext_;
49881       return std::tie( sType, pNext, presentModeCount, pPresentModes );
49893       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes );
49905     const void *                           pNext            = {};
50157       : pNext( pNext_ )
50173       : pNext( pNext_ ), settingCount( static_cast<uint32_t>( settings_.size() ) ), pSettings( settings_.data() )
50190       pNext = pNext_;
50235       return std::tie( sType, pNext, settingCount, pSettings );
50247       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( settingCount == rhs.settingCount ) && ( pSettings == rhs.pSettings );
50259     const void *                                  pNext        = {};
50282       : pNext( pNext_ )
50307       pNext = pNext_;
50343       return std::tie( sType, pNext, flags, pView );
50355       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView );
50367     const void *                                     pNext = {};
50391       : pNext( pNext_ )
50414       pNext = pNext_;
50459       return std::tie( sType, pNext, memory, offset, size );
50471       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) && ( size == rhs.size );
50483     const void *                        pNext  = {};
50506       : pNext( pNext_ )
50531       pNext = pNext_;
50566       return std::tie( sType, pNext, flags, deviceMask );
50578       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( deviceMask == rhs.deviceMask );
50590     const void *                              pNext      = {};
50614       : pNext( pNext_ )
50636       pNext = pNext_;
50671       return std::tie( sType, pNext, allocationSize, memoryTypeIndex );
50683       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeIndex == rhs.memoryTypeIndex );
50695     const void *                        pNext           = {};
50717       : pNext( pNext_ )
50739       pNext = pNext_;
50777       return std::tie( sType, pNext, srcAccessMask, dstAccessMask );
50789       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask );
50801     const void *                        pNext         = {};
50823       : pNext( pNext_ )
50848       pNext = pNext_;
50883       return std::tie( sType, pNext, image, buffer );
50895       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer );
50907     const void *                        pNext  = {};
50931       : pNext( pNext_ )
50971       return std::tie( sType, pNext, prefersDedicatedAllocation, requiresDedicatedAllocation );
50983       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) &&
50996     void *                              pNext                       = {};
51018       : pNext( pNext_ )
51057       return std::tie( sType, pNext, memoryTypeBits );
51069       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
51081     void *                              pNext          = {};
51102       : pNext( pNext_ )
51126       pNext = pNext_;
51155       return std::tie( sType, pNext, memory );
51167       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory );
51179     const void *                        pNext  = {};
51202       : pNext( pNext_ )
51224       pNext = pNext_;
51262       return std::tie( sType, pNext, memory, handleType );
51274       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType );
51286     const void *                                           pNext      = {};
51309       : pNext( pNext_ )
51334       pNext = pNext_;
51373       return std::tie( sType, pNext, memory, handleType );
51385       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType );
51397     const void *                                           pNext      = {};
51421       : pNext( pNext_ )
51446       pNext = pNext_;
51485       return std::tie( sType, pNext, memory, handleType );
51497       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType );
51509     const void *                                           pNext      = {};
51534       : pNext( pNext_ )
51559       pNext = pNext_;
51598       return std::tie( sType, pNext, memory, handleType );
51610       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType );
51622     const void *                                           pNext      = {};
51712       : pNext( pNext_ )
51751       return std::tie( sType, pNext, memoryTypeBits );
51763       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
51775     void *                              pNext          = {};
51798       : pNext( pNext_ )
51822       pNext = pNext_;
51874       return std::tie( sType, pNext, flags, memory, offset, size );
51886       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) &&
51899     const void *                         pNext  = {};
51921       : pNext( pNext_ )
51945       pNext = pNext_;
51974       return std::tie( sType, pNext, opaqueCaptureAddress );
51986       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress );
51998     const void *                        pNext                = {};
52019       : pNext( pNext_ )
52043       pNext = pNext_;
52072       return std::tie( sType, pNext, priority );
52084       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priority == rhs.priority );
52096     const void *                        pNext    = {};
52188       : pNext( pNext_ )
52226       return std::tie( sType, pNext, memoryRequirements );
52238       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements );
52250     void *                                   pNext              = {};
52342       : pNext( pNext_ )
52364       pNext = pNext_;
52402       return std::tie( sType, pNext, flags, memory );
52414       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( memory == rhs.memory );
52426     const void *                              pNext  = {};
52447       : pNext( pNext_ )
52486       return std::tie( sType, pNext, memoryTypeBits );
52498       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
52510     void *                              pNext          = {};
52531       : pNext( pNext_ )
52570       return std::tie( sType, pNext, memoryTypeBits );
52582       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
52594     void *                              pNext          = {};
52617       : pNext( pNext_ )
52642       pNext = pNext_;
52680       return std::tie( sType, pNext, flags, pLayer );
52692       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pLayer == rhs.pLayer );
52704     const void *                                     pNext  = {};
52736       : pNext( pNext_ )
52770       : pNext( pNext_ )
52806       pNext = pNext_;
52929         sType, pNext, type, flags, mode, dstMicromap, usageCountsCount, pUsageCounts, ppUsageCounts, data, scratchData, triangleArray, triangleArrayStride );
52935     const void *                                           pNext               = {};
52967       : pNext( pNext_ )
52993       pNext = pNext_;
53038       return std::tie( sType, pNext, micromapSize, buildScratchSize, discardable );
53050       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( micromapSize == rhs.micromapSize ) && ( buildScratchSize == rhs.buildScratchSize ) &&
53063     const void *                        pNext            = {};
53090       : pNext( pNext_ )
53119       pNext = pNext_;
53185       return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress );
53197       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) &&
53210     const void *                                 pNext         = {};
53327       : pNext( pNext_ )
53351       pNext = pNext_;
53380       return std::tie( sType, pNext, pVersionData );
53392       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData );
53404     const void *                        pNext        = {};
53600       : pNext( pNext_ )
53639       return std::tie( sType, pNext, maxSampleLocationGridSize );
53651       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize );
53663     void *                              pNext                     = {};
53685       : pNext( pNext_ )
53710       pNext = pNext_;
53750       return std::tie( sType, pNext, multisampledRenderToSingleSampledEnable, rasterizationSamples );
53762       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multisampledRenderToSingleSampledEnable == rhs.multisampledRenderToSingleSampledEnable ) &&
53775     const void *                              pNext                                   = {};
53797       : pNext( pNext_ )
53822       pNext = pNext_;
53858       return std::tie( sType, pNext, perViewAttributes, perViewAttributesPositionXOnly );
53870       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewAttributes == rhs.perViewAttributes ) &&
53883     const void *                        pNext                          = {};
53905       : pNext( pNext_ )
53922       : pNext( pNext_ ), perViewRenderAreaCount( static_cast<uint32_t>( perViewRenderAreas_.size() ) ), pPerViewRenderAreas( perViewRenderAreas_.data() )
53940       pNext = pNext_;
53987       return std::tie( sType, pNext, perViewRenderAreaCount, pPerViewRenderAreas );
53999       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewRenderAreaCount == rhs.perViewRenderAreaCount ) &&
54012     const void *                         pNext                  = {};
54141       : pNext( pNext_ )
54158       : pNext( pNext_ )
54177       pNext = pNext_;
54228       return std::tie( sType, pNext, mutableDescriptorTypeListCount, pMutableDescriptorTypeLists );
54240       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) &&
54253     const void *                                               pNext                          = {};
54276       : pNext( pNext_ )
54300       pNext = pNext_;
54330       return std::tie( sType, pNext, opaqueCaptureDescriptorData );
54342       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureDescriptorData == rhs.opaqueCaptureDescriptorData );
54354     const void *                        pNext                       = {};
54376       : pNext( pNext_ )
54394       : pNext( pNext_ ), flags( flags_ ), regionCount( static_cast<uint32_t>( regions_.size() ) ), pRegions( regions_.data() )
54411       pNext = pNext_;
54466       return std::tie( sType, pNext, flags, regionCount, pRegions );
54478       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
54490     void *                                          pNext       = {};
54512       : pNext( pNext_ )
54536       pNext = pNext_;
54565       return std::tie( sType, pNext, usage );
54577       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage );
54589     const void *                                  pNext = {};
54609       : pNext( pNext_ )
54648       return std::tie( sType, pNext, format );
54660       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format );
54672     const void *                        pNext  = {};
54701       : pNext( pNext_ )
54733       pNext = pNext_;
54823       return std::tie( sType, pNext, width, height, imageFormat, flowVectorFormat, costFormat, outputGridSize, hintGridSize, performanceLevel, flags );
54835       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( width == rhs.width ) && ( height == rhs.height ) && ( imageFormat == rhs.imageFormat ) &&
54849     void *                                                pNext            = {};
54879       : pNext( pNext_ )
54905       pNext = pNext_;
54946       return std::tie( sType, pNext, id, size, pPrivateData );
54958       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( id == rhs.id ) && ( size == rhs.size ) && ( pPrivateData == rhs.pPrivateData );
54970     void *                              pNext        = {};
54992       : pNext( pNext_ )
55016       pNext = pNext_;
55045       return std::tie( sType, pNext, queueType );
55057       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueType == rhs.queueType );
55069     const void *                               pNext     = {};
55174       : pNext( pNext_ )
55198       pNext = pNext_;
55228       return std::tie( sType, pNext, type );
55240       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type );
55252     const void *                                            pNext = {};
55276       : pNext( pNext_ )
55323       return std::tie( sType, pNext, flags, name, category, description );
55335       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( name == rhs.name ) && ( category == rhs.category ) &&
55348     void *                                                              pNext       = {};
55375       : pNext( pNext_ )
55422       return std::tie( sType, pNext, unit, scope, storage, uuid );
55434       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unit == rhs.unit ) && ( scope == rhs.scope ) && ( storage == rhs.storage ) &&
55447     void *                                                      pNext   = {};
55543       : pNext( pNext_ )
55567       pNext = pNext_;
55596       return std::tie( sType, pNext, marker );
55608       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker );
55620     const void *                        pNext  = {};
55643       : pNext( pNext_ )
55669       pNext = pNext_;
55714       return std::tie( sType, pNext, type, enable, parameter );
55726       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( enable == rhs.enable ) && ( parameter == rhs.parameter );
55738     const void *                                       pNext     = {};
55759       : pNext( pNext_ )
55783       pNext = pNext_;
55812       return std::tie( sType, pNext, counterPassIndex );
55824       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterPassIndex == rhs.counterPassIndex );
55836     const void *                        pNext            = {};
55855       : pNext( pNext_ )
55879       pNext = pNext_;
55908       return std::tie( sType, pNext, marker );
55920       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker );
55932     const void *                        pNext  = {};
56096       : pNext( pNext_ )
56123       pNext = pNext_;
56179       return std::tie( sType, pNext, storageBuffer16BitAccess, uniformAndStorageBuffer16BitAccess, storagePushConstant16, storageInputOutput16 );
56191       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) &&
56205     void *                              pNext                              = {};
56231       : pNext( pNext_ )
56256       pNext = pNext_;
56291       return std::tie( sType, pNext, formatA4R4G4B4, formatA4B4G4R4 );
56303       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatA4R4G4B4 == rhs.formatA4R4G4B4 ) && ( formatA4B4G4R4 == rhs.formatA4B4G4R4 );
56315     void *                              pNext          = {};
56338       : pNext( pNext_ )
56364       pNext = pNext_;
56412       return std::tie( sType, pNext, storageBuffer8BitAccess, uniformAndStorageBuffer8BitAccess, storagePushConstant8 );
56424       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) &&
56437     void *                              pNext                             = {};
56461       : pNext( pNext_ )
56485       pNext = pNext_;
56515       return std::tie( sType, pNext, decodeModeSharedExponent );
56527       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeModeSharedExponent == rhs.decodeModeSharedExponent );
56539     void *                              pNext                    = {};
56564       : pNext( pNext_ )
56593       pNext = pNext_;
56658                        pNext,
56675       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) &&
56691     void *                              pNext                                                 = {};
56722       : pNext( pNext_ )
56779                        pNext,
56799       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGeometryCount == rhs.maxGeometryCount ) && ( maxInstanceCount == rhs.maxInstanceCount ) &&
56817     void *                              pNext                                       = {};
56844       : pNext( pNext_ )
56869       pNext = pNext_;
56899       return std::tie( sType, pNext, reportAddressBinding );
56911       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reportAddressBinding == rhs.reportAddressBinding );
56923     void *                              pNext                = {};
56943       : pNext( pNext_ )
56967       pNext = pNext_;
56996       return std::tie( sType, pNext, amigoProfiling );
57008       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( amigoProfiling == rhs.amigoProfiling );
57020     void *                              pNext          = {};
57040       : pNext( pNext_ )
57068       pNext = pNext_;
57098       return std::tie( sType, pNext, attachmentFeedbackLoopDynamicState );
57110       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentFeedbackLoopDynamicState == rhs.attachmentFeedbackLoopDynamicState );
57122     void *                              pNext                              = {};
57142       : pNext( pNext_ )
57168       pNext = pNext_;
57198       return std::tie( sType, pNext, attachmentFeedbackLoopLayout );
57210       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentFeedbackLoopLayout == rhs.attachmentFeedbackLoopLayout );
57222     void *                              pNext                        = {};
57242       : pNext( pNext_ )
57267       pNext = pNext_;
57297       return std::tie( sType, pNext, advancedBlendCoherentOperations );
57309       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations );
57321     void *                              pNext                           = {};
57346       : pNext( pNext_ )
57400                        pNext,
57418       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) &&
57434     void *                              pNext                                 = {};
57460       : pNext( pNext_ )
57485       pNext = pNext_;
57522       return std::tie( sType, pNext, borderColorSwizzle, borderColorSwizzleFromImage );
57534       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( borderColorSwizzle == rhs.borderColorSwizzle ) &&
57547     void *                              pNext                       = {};
57570       : pNext( pNext_ )
57596       pNext = pNext_;
57644       return std::tie( sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice );
57656       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
57670     void *                              pNext                            = {};
57696       : pNext( pNext_ )
57722       pNext = pNext_;
57770       return std::tie( sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice );
57782       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
57796     void *                              pNext                            = {};
57821       : pNext( pNext_ )
57847       pNext = pNext_;
57884       return std::tie( sType, pNext, clustercullingShader, multiviewClusterCullingShader );
57896       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( clustercullingShader == rhs.clustercullingShader ) &&
57909     void *                              pNext                         = {};
57933       : pNext( pNext_ )
57982       return std::tie( sType, pNext, maxWorkGroupCount, maxWorkGroupSize, maxOutputClusterCount, indirectBufferOffsetAlignment );
57994       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxWorkGroupCount == rhs.maxWorkGroupCount ) &&
58008     void *                                            pNext                         = {};
58031       : pNext( pNext_ )
58057       pNext = pNext_;
58087       return std::tie( sType, pNext, clusterShadingRate );
58099       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( clusterShadingRate == rhs.clusterShadingRate );
58111     void *                              pNext              = {};
58131       : pNext( pNext_ )
58155       pNext = pNext_;
58185       return std::tie( sType, pNext, deviceCoherentMemory );
58197       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceCoherentMemory == rhs.deviceCoherentMemory );
58209     void *                              pNext                = {};
58229       : pNext( pNext_ )
58253       pNext = pNext_;
58283       return std::tie( sType, pNext, colorWriteEnable );
58295       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorWriteEnable == rhs.colorWriteEnable );
58307     void *                              pNext            = {};
58328       : pNext( pNext_ )
58354       pNext = pNext_;
58391       return std::tie( sType, pNext, computeDerivativeGroupQuads, computeDerivativeGroupLinear );
58403       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) &&
58416     void *                              pNext                        = {};
58438       : pNext( pNext_ )
58464       pNext = pNext_;
58501       return std::tie( sType, pNext, conditionalRendering, inheritedConditionalRendering );
58513       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRendering == rhs.conditionalRendering ) &&
58526     void *                              pNext                         = {};
58555       : pNext( pNext_ )
58615                        pNext,
58636       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) &&
58655     void *                              pNext                                       = {};
58684       : pNext( pNext_ )
58709       pNext = pNext_;
58746       return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess );
58758       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) &&
58771     void *                              pNext                               = {};
58793       : pNext( pNext_ )
58818       pNext = pNext_;
58855       return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess );
58867       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) &&
58880     void *                              pNext                               = {};
58901       : pNext( pNext_ )
58940       return std::tie( sType, pNext, cooperativeMatrixSupportedStages );
58952       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages );
58964     void *                                 pNext                            = {};
58984       : pNext( pNext_ )
59023       return std::tie( sType, pNext, cooperativeMatrixSupportedStages );
59035       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages );
59047     void *                                 pNext                            = {};
59067       : pNext( pNext_ )
59091       pNext = pNext_;
59120       return std::tie( sType, pNext, indirectCopy );
59132       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indirectCopy == rhs.indirectCopy );
59144     void *                              pNext        = {};
59164       : pNext( pNext_ )
59203       return std::tie( sType, pNext, supportedQueues );
59215       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedQueues == rhs.supportedQueues );
59227     void *                              pNext           = {};
59247       : pNext( pNext_ )
59271       pNext = pNext_;
59301       return std::tie( sType, pNext, cornerSampledImage );
59313       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cornerSampledImage == rhs.cornerSampledImage );
59325     void *                              pNext              = {};
59345       : pNext( pNext_ )
59370       pNext = pNext_;
59400       return std::tie( sType, pNext, coverageReductionMode );
59412       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode );
59424     void *                              pNext                 = {};
59443       : pNext( pNext_ )
59467       pNext = pNext_;
59496       return std::tie( sType, pNext, cubicRangeClamp );
59508       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicRangeClamp == rhs.cubicRangeClamp );
59520     void *                              pNext           = {};
59540       : pNext( pNext_ )
59564       pNext = pNext_;
59594       return std::tie( sType, pNext, selectableCubicWeights );
59606       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( selectableCubicWeights == rhs.selectableCubicWeights );
59618     void *                              pNext                  = {};
59639       : pNext( pNext_ )
59663       pNext = pNext_;
59693       return std::tie( sType, pNext, cudaKernelLaunchFeatures );
59705       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cudaKernelLaunchFeatures == rhs.cudaKernelLaunchFeatures );
59717     void *                              pNext                    = {};
59740       : pNext( pNext_ )
59780       return std::tie( sType, pNext, computeCapabilityMinor, computeCapabilityMajor );
59792       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( computeCapabilityMinor == rhs.computeCapabilityMinor ) &&
59805     void *                              pNext                  = {};
59828       : pNext( pNext_ )
59853       pNext = pNext_;
59890       return std::tie( sType, pNext, customBorderColors, customBorderColorWithoutFormat );
59902       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customBorderColors == rhs.customBorderColors ) &&
59915     void *                              pNext                          = {};
59936       : pNext( pNext_ )
59975       return std::tie( sType, pNext, maxCustomBorderColorSamplers );
59987       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxCustomBorderColorSamplers == rhs.maxCustomBorderColorSamplers );
59999     void *                              pNext                        = {};
60019       : pNext( pNext_ )
60046       pNext = pNext_;
60076       return std::tie( sType, pNext, dedicatedAllocationImageAliasing );
60088       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing );
60100     void *                              pNext                            = {};
60123       : pNext( pNext_ )
60150       pNext = pNext_;
60205       return std::tie( sType, pNext, depthBiasControl, leastRepresentableValueForceUnormRepresentation, floatRepresentation, depthBiasExact );
60217       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasControl == rhs.depthBiasControl ) &&
60231     void *                              pNext                                           = {};
60254       : pNext( pNext_ )
60278       pNext = pNext_;
60308       return std::tie( sType, pNext, depthClampZeroOne );
60320       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClampZeroOne == rhs.depthClampZeroOne );
60332     void *                              pNext             = {};
60352       : pNext( pNext_ )
60376       pNext = pNext_;
60406       return std::tie( sType, pNext, depthClipControl );
60418       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipControl == rhs.depthClipControl );
60430     void *                              pNext            = {};
60450       : pNext( pNext_ )
60474       pNext = pNext_;
60503       return std::tie( sType, pNext, depthClipEnable );
60515       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipEnable == rhs.depthClipEnable );
60527     void *                              pNext           = {};
60550       : pNext( pNext_ )
60597       return std::tie( sType, pNext, supportedDepthResolveModes, supportedStencilResolveModes, independentResolveNone, independentResolve );
60609       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) &&
60623     void *                                 pNext                        = {};
60648       : pNext( pNext_ )
60689       return std::tie( sType, pNext, combinedImageSamplerDensityMapDescriptorSize );
60701       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
60714     void *                              pNext                                        = {};
60737       : pNext( pNext_ )
60764       pNext = pNext_;
60820       return std::tie( sType, pNext, descriptorBuffer, descriptorBufferCaptureReplay, descriptorBufferImageLayoutIgnored, descriptorBufferPushDescriptors );
60832       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorBuffer == rhs.descriptorBuffer ) &&
60847     void *                              pNext                              = {};
60902       : pNext( pNext_ )
61008                        pNext,
61053       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
61095     void *                              pNext                                                = {};
61166       : pNext( pNext_ )
61209       pNext = pNext_;
61394                        pNext,
61426       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
61458     void *                              pNext                                              = {};
61521       : pNext( pNext_ )
61607                        pNext,
61642       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) &&
61675     void *                              pNext                                                = {};
61719       : pNext( pNext_ )
61745       pNext = pNext_;
61775       return std::tie( sType, pNext, descriptorPoolOverallocation );
61787       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPoolOverallocation == rhs.descriptorPoolOverallocation );
61799     void *                              pNext                        = {};
61819       : pNext( pNext_ )
61845       pNext = pNext_;
61875       return std::tie( sType, pNext, descriptorSetHostMapping );
61887       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetHostMapping == rhs.descriptorSetHostMapping );
61899     void *                              pNext                    = {};
61921       : pNext( pNext_ )
61950       pNext = pNext_;
61998       return std::tie( sType, pNext, deviceGeneratedCompute, deviceGeneratedComputePipelines, deviceGeneratedComputeCaptureReplay );
62010       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceGeneratedCompute == rhs.deviceGeneratedCompute ) &&
62024     void *                              pNext                               = {};
62046       : pNext( pNext_ )
62071       pNext = pNext_;
62101       return std::tie( sType, pNext, deviceGeneratedCommands );
62113       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceGeneratedCommands == rhs.deviceGeneratedCommands );
62125     void *                              pNext                   = {};
62153       : pNext( pNext_ )
62213                        pNext,
62234       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGraphicsShaderGroupCount == rhs.maxGraphicsShaderGroupCount ) &&
62253     void *                              pNext                                    = {};
62281       : pNext( pNext_ )
62305       pNext = pNext_;
62335       return std::tie( sType, pNext, deviceMemoryReport );
62347       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMemoryReport == rhs.deviceMemoryReport );
62359     void *                              pNext              = {};
62379       : pNext( pNext_ )
62403       pNext = pNext_;
62433       return std::tie( sType, pNext, diagnosticsConfig );
62445       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( diagnosticsConfig == rhs.diagnosticsConfig );
62457     void *                              pNext             = {};
62476       : pNext( pNext_ )
62515       return std::tie( sType, pNext, maxDiscardRectangles );
62527       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDiscardRectangles == rhs.maxDiscardRectangles );
62539     void *                              pNext                = {};
62560       : pNext( pNext_ )
62584       pNext = pNext_;
62614       return std::tie( sType, pNext, displacementMicromap );
62626       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displacementMicromap == rhs.displacementMicromap );
62638     void *                              pNext                = {};
62660       : pNext( pNext_ )
62700       return std::tie( sType, pNext, maxDisplacementMicromapSubdivisionLevel );
62712       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDisplacementMicromapSubdivisionLevel == rhs.maxDisplacementMicromapSubdivisionLevel );
62724     void *                              pNext                                   = {};
62748       : pNext( pNext_ )
62795       return std::tie( sType, pNext, driverID, driverName, driverInfo, conformanceVersion );
62807       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( driverName == rhs.driverName ) &&
62820     void *                                                              pNext              = {};
62850       : pNext( pNext_ )
62901       return std::tie( sType, pNext, hasPrimary, hasRender, primaryMajor, primaryMinor, renderMajor, renderMinor );
62913       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasPrimary == rhs.hasPrimary ) && ( hasRender == rhs.hasRender ) &&
62927     void *                              pNext        = {};
62952       : pNext( pNext_ )
62976       pNext = pNext_;
63005       return std::tie( sType, pNext, dynamicRendering );
63017       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRendering == rhs.dynamicRendering );
63029     void *                              pNext            = {};
63051       : pNext( pNext_ )
63079       pNext = pNext_;
63109       return std::tie( sType, pNext, dynamicRenderingUnusedAttachments );
63121       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRenderingUnusedAttachments == rhs.dynamicRenderingUnusedAttachments );
63133     void *                              pNext                             = {};
63153       : pNext( pNext_ )
63177       pNext = pNext_;
63206       return std::tie( sType, pNext, exclusiveScissor );
63218       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissor == rhs.exclusiveScissor );
63230     void *                              pNext            = {};
63252       : pNext( pNext_ )
63279       pNext = pNext_;
63327       return std::tie( sType, pNext, extendedDynamicState2, extendedDynamicState2LogicOp, extendedDynamicState2PatchControlPoints );
63339       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState2 == rhs.extendedDynamicState2 ) &&
63353     void *                              pNext                                   = {};
63406       : pNext( pNext_ )
63461       pNext = pNext_;
63734                        pNext,
63777       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
63820     void *                              pNext                                                 = {};
63870       : pNext( pNext_ )
63895       pNext = pNext_;
63925       return std::tie( sType, pNext, dynamicPrimitiveTopologyUnrestricted );
63937       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicPrimitiveTopologyUnrestricted == rhs.dynamicPrimitiveTopologyUnrestricted );
63949     void *                              pNext                                = {};
63969       : pNext( pNext_ )
63994       pNext = pNext_;
64024       return std::tie( sType, pNext, extendedDynamicState );
64036       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState );
64048     void *                              pNext                = {};
64068       : pNext( pNext_ )
64094       pNext = pNext_;
64124       return std::tie( sType, pNext, extendedSparseAddressSpace );
64136       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedSparseAddressSpace == rhs.extendedSparseAddressSpace );
64148     void *                              pNext                      = {};
64170       : pNext( pNext_ )
64217       return std::tie( sType, pNext, extendedSparseAddressSpaceSize, extendedSparseImageUsageFlags, extendedSparseBufferUsageFlags );
64229       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedSparseAddressSpaceSize == rhs.extendedSparseAddressSpaceSize ) &&
64242     void *                                 pNext                          = {};
64267       : pNext( pNext_ )
64293       pNext = pNext_;
64339       return std::tie( sType, pNext, flags, usage, handleType );
64351       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && ( handleType == rhs.handleType );
64363     const void *                                           pNext      = {};
64388       : pNext( pNext_ )
64412       pNext = pNext_;
64442       return std::tie( sType, pNext, handleType );
64454       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
64466     const void *                                          pNext      = {};
64489       : pNext( pNext_ )
64515       pNext = pNext_;
64545       return std::tie( sType, pNext, externalFormatResolve );
64557       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormatResolve == rhs.externalFormatResolve );
64569     void *                              pNext                 = {};
64594       : pNext( pNext_ )
64641       return std::tie( sType, pNext, nullColorAttachmentWithExternalFormatResolve, externalFormatResolveChromaOffsetX, externalFormatResolveChromaOffsetY );
64653       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
64668     void *                               pNext                                        = {};
64692       : pNext( pNext_ )
64716       pNext = pNext_;
64746       return std::tie( sType, pNext, handleType );
64758       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
64770     const void *                                           pNext      = {};
64792       : pNext( pNext_ )
64832       return std::tie( sType, pNext, minImportedHostPointerAlignment );
64844       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment );
64856     void *                              pNext                           = {};
64876       : pNext( pNext_ )
64900       pNext = pNext_;
64930       return std::tie( sType, pNext, externalMemoryRDMA );
64942       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryRDMA == rhs.externalMemoryRDMA );
64954     void *                              pNext              = {};
64975       : pNext( pNext_ )
65001       pNext = pNext_;
65031       return std::tie( sType, pNext, screenBufferImport );
65043       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( screenBufferImport == rhs.screenBufferImport );
65055     void *                              pNext              = {};
65077       : pNext( pNext_ )
65101       pNext = pNext_;
65131       return std::tie( sType, pNext, handleType );
65143       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
65155     const void *                                              pNext      = {};
65178       : pNext( pNext_ )
65203       pNext = pNext_;
65239       return std::tie( sType, pNext, deviceFault, deviceFaultVendorBinary );
65251       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceFault == rhs.deviceFault ) &&
65264     void *                              pNext                   = {};
65284       : pNext( pNext_ )
65308       pNext = pNext_;
65337       return std::tie( sType, pNext, features );
65349       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( features == rhs.features );
65361     void *                                       pNext    = {};
65400       : pNext( pNext_ )
65474                        pNext,
65503       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) &&
65526     void *                                                pNext                      = {};
65564       : pNext( pNext_ )
65588       pNext = pNext_;
65618       return std::tie( sType, pNext, fragmentDensityMapDeferred );
65630       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred );
65642     void *                              pNext                      = {};
65665       : pNext( pNext_ )
65713       return std::tie( sType, pNext, subsampledLoads, subsampledCoarseReconstructionEarlyAccess, maxSubsampledArrayLayers, maxDescriptorSetSubsampledSamplers );
65725       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) &&
65739     void *                              pNext                                     = {};
65764       : pNext( pNext_ )
65790       pNext = pNext_;
65838       return std::tie( sType, pNext, fragmentDensityMap, fragmentDensityMapDynamic, fragmentDensityMapNonSubsampledImages );
65850       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMap == rhs.fragmentDensityMap ) &&
65864     void *                              pNext                                 = {};
65886       : pNext( pNext_ )
65912       pNext = pNext_;
65942       return std::tie( sType, pNext, fragmentDensityMapOffset );
65954       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapOffset == rhs.fragmentDensityMapOffset );
65966     void *                              pNext                    = {};
65986       : pNext( pNext_ )
66027       return std::tie( sType, pNext, fragmentDensityOffsetGranularity );
66039       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityOffsetGranularity == rhs.fragmentDensityOffsetGranularity );
66051     void *                              pNext                            = {};
66073       : pNext( pNext_ )
66119       return std::tie( sType, pNext, minFragmentDensityTexelSize, maxFragmentDensityTexelSize, fragmentDensityInvocations );
66131       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) &&
66144     void *                              pNext                       = {};
66166       : pNext( pNext_ )
66192       pNext = pNext_;
66222       return std::tie( sType, pNext, fragmentShaderBarycentric );
66234       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric );
66246     void *                              pNext                     = {};
66269       : pNext( pNext_ )
66310       return std::tie( sType, pNext, triStripVertexOrderIndependentOfProvokingVertex );
66322       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
66335     void *                              pNext                                           = {};
66357       : pNext( pNext_ )
66384       pNext = pNext_;
66432       return std::tie( sType, pNext, fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, fragmentShaderShadingRateInterlock );
66444       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentShaderSampleInterlock == rhs.fragmentShaderSampleInterlock ) &&
66458     void *                              pNext                              = {};
66482       : pNext( pNext_ )
66509       pNext = pNext_;
66557       return std::tie( sType, pNext, fragmentShadingRateEnums, supersampleFragmentShadingRates, noInvocationFragmentShadingRates );
66569       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentShadingRateEnums == rhs.fragmentShadingRateEnums ) &&
66583     void *                              pNext                            = {};
66606       : pNext( pNext_ )
66632       pNext = pNext_;
66662       return std::tie( sType, pNext, maxFragmentShadingRateInvocationCount );
66674       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxFragmentShadingRateInvocationCount == rhs.maxFragmentShadingRateInvocationCount );
66686     void *                                    pNext                                 = {};
66708       : pNext( pNext_ )
66734       pNext = pNext_;
66782       return std::tie( sType, pNext, pipelineFragmentShadingRate, primitiveFragmentShadingRate, attachmentFragmentShadingRate );
66794       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineFragmentShadingRate == rhs.pipelineFragmentShadingRate ) &&
66807     void *                              pNext                         = {};
66830       : pNext( pNext_ )
66871       return std::tie( sType, pNext, sampleCounts, fragmentSize );
66883       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleCounts == rhs.sampleCounts ) && ( fragmentSize == rhs.fragmentSize );
66895     void *                                 pNext        = {};
66933       : pNext( pNext_ )
67008                        pNext,
67037       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
67065     void *                                    pNext                                     = {};
67100       : pNext( pNext_ )
67124       pNext = pNext_;
67153       return std::tie( sType, pNext, frameBoundary );
67165       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( frameBoundary == rhs.frameBoundary );
67177     void *                              pNext         = {};
67197       : pNext( pNext_ )
67221       pNext = pNext_;
67251       return std::tie( sType, pNext, globalPriorityQuery );
67263       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery );
67275     void *                              pNext               = {};
67297       : pNext( pNext_ )
67322       pNext = pNext_;
67352       return std::tie( sType, pNext, graphicsPipelineLibrary );
67364       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( graphicsPipelineLibrary == rhs.graphicsPipelineLibrary );
67376     void *                              pNext                   = {};
67398       : pNext( pNext_ )
67425       pNext = pNext_;
67462       return std::tie( sType, pNext, graphicsPipelineLibraryFastLinking, graphicsPipelineLibraryIndependentInterpolationDecoration );
67474       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( graphicsPipelineLibraryFastLinking == rhs.graphicsPipelineLibraryFastLinking ) &&
67487     void *                              pNext                              = {};
67511       : pNext( pNext_ )
67556       return std::tie( sType, pNext, physicalDeviceCount, physicalDevices, subsetAllocation );
67568       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) &&
67581     void *                                                                                               pNext = {};
67604       : pNext( pNext_ )
67628       pNext = pNext_;
67657       return std::tie( sType, pNext, hostImageCopy );
67669       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostImageCopy == rhs.hostImageCopy );
67681     void *                              pNext         = {};
67706       : pNext( pNext_ )
67729       : pNext( pNext_ )
67752       pNext = pNext_;
67843         sType, pNext, copySrcLayoutCount, pCopySrcLayouts, copyDstLayoutCount, pCopyDstLayouts, optimalTilingLayoutUUID, identicalMemoryTypeRequirements );
67855       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( copySrcLayoutCount == rhs.copySrcLayoutCount ) &&
67869     void *                                                      pNext                           = {};
67893       : pNext( pNext_ )
67917       pNext = pNext_;
67946       return std::tie( sType, pNext, hostQueryReset );
67958       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostQueryReset == rhs.hostQueryReset );
67970     void *                              pNext          = {};
67996       : pNext( pNext_ )
68045       return std::tie( sType, pNext, deviceUUID, driverUUID, deviceLUID, deviceNodeMask, deviceLUIDValid );
68057       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && ( driverUUID == rhs.driverUUID ) &&
68070     void *                                                      pNext           = {};
68097       : pNext( pNext_ )
68122       pNext = pNext_;
68158       return std::tie( sType, pNext, image2DViewOf3D, sampler2DViewOf3D );
68170       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image2DViewOf3D == rhs.image2DViewOf3D ) && ( sampler2DViewOf3D == rhs.sampler2DViewOf3D );
68182     void *                              pNext             = {};
68203       : pNext( pNext_ )
68228       pNext = pNext_;
68258       return std::tie( sType, pNext, imageCompressionControl );
68270       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCompressionControl == rhs.imageCompressionControl );
68282     void *                              pNext                   = {};
68302       : pNext( pNext_ )
68330       pNext = pNext_;
68360       return std::tie( sType, pNext, imageCompressionControlSwapchain );
68372       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCompressionControlSwapchain == rhs.imageCompressionControlSwapchain );
68384     void *                              pNext                            = {};
68408       : pNext( pNext_ )
68428       : pNext( pNext_ )
68449       pNext = pNext_;
68511       return std::tie( sType, pNext, drmFormatModifier, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices );
68523       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && ( sharingMode == rhs.sharingMode ) &&
68536     const void *                        pNext                 = {};
68563       : pNext( pNext_ )
68591       pNext = pNext_;
68650       return std::tie( sType, pNext, format, type, tiling, usage, flags );
68662       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && ( tiling == rhs.tiling ) &&
68675     const void *                           pNext  = {};
68701       : pNext( pNext_ )
68725       pNext = pNext_;
68755       return std::tie( sType, pNext, textureBlockMatch2 );
68767       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureBlockMatch2 == rhs.textureBlockMatch2 );
68779     void *                              pNext              = {};
68799       : pNext( pNext_ )
68838       return std::tie( sType, pNext, maxBlockMatchWindow );
68850       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBlockMatchWindow == rhs.maxBlockMatchWindow );
68862     void *                              pNext               = {};
68884       : pNext( pNext_ )
68910       pNext = pNext_;
68958       return std::tie( sType, pNext, textureSampleWeighted, textureBoxFilter, textureBlockMatch );
68970       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureSampleWeighted == rhs.textureSampleWeighted ) &&
68983     void *                              pNext                 = {};
69008       : pNext( pNext_ )
69055       return std::tie( sType, pNext, maxWeightFilterPhases, maxWeightFilterDimension, maxBlockMatchRegion, maxBoxFilterBlockSize );
69067       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxWeightFilterPhases == rhs.maxWeightFilterPhases ) &&
69081     void *                              pNext                    = {};
69104       : pNext( pNext_ )
69128       pNext = pNext_;
69157       return std::tie( sType, pNext, robustImageAccess );
69169       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess );
69181     void *                              pNext             = {};
69203       : pNext( pNext_ )
69227       pNext = pNext_;
69257       return std::tie( sType, pNext, imageSlicedViewOf3D );
69269       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageSlicedViewOf3D == rhs.imageSlicedViewOf3D );
69281     void *                              pNext               = {};
69302       : pNext( pNext_ )
69326       pNext = pNext_;
69356       return std::tie( sType, pNext, imageViewType );
69368       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageViewType == rhs.imageViewType );
69380     void *                              pNext         = {};
69399       : pNext( pNext_ )
69423       pNext = pNext_;
69452       return std::tie( sType, pNext, minLod );
69464       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod );
69476     void *                              pNext  = {};
69496       : pNext( pNext_ )
69520       pNext = pNext_;
69550       return std::tie( sType, pNext, imagelessFramebuffer );
69562       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer );
69574     void *                              pNext                = {};
69596       : pNext( pNext_ )
69620       pNext = pNext_;
69649       return std::tie( sType, pNext, indexTypeUint8 );
69661       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexTypeUint8 == rhs.indexTypeUint8 );
69673     void *                              pNext          = {};
69693       : pNext( pNext_ )
69718       pNext = pNext_;
69748       return std::tie( sType, pNext, inheritedViewportScissor2D );
69760       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inheritedViewportScissor2D == rhs.inheritedViewportScissor2D );
69772     void *                              pNext                      = {};
69793       : pNext( pNext_ )
69818       pNext = pNext_;
69855       return std::tie( sType, pNext, inlineUniformBlock, descriptorBindingInlineUniformBlockUpdateAfterBind );
69867       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inlineUniformBlock == rhs.inlineUniformBlock ) &&
69880     void *                              pNext                                              = {};
69907       : pNext( pNext_ )
69957                        pNext,
69974       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) &&
69990     void *                              pNext                                                   = {};
70016       : pNext( pNext_ )
70040       pNext = pNext_;
70069       return std::tie( sType, pNext, invocationMask );
70081       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( invocationMask == rhs.invocationMask );
70093     void *                              pNext          = {};
70114       : pNext( pNext_ )
70153       return std::tie( sType, pNext, underlyingAPI );
70165       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( underlyingAPI == rhs.underlyingAPI );
70177     void *                                               pNext         = {};
70197       : pNext( pNext_ )
70221       pNext = pNext_;
70250       return std::tie( sType, pNext, legacyDithering );
70262       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( legacyDithering == rhs.legacyDithering );
70274     void *                              pNext           = {};
70955       : pNext( pNext_ )
70984       pNext = pNext_;
71054       return std::tie( sType, pNext, rectangularLines, bresenhamLines, smoothLines, stippledRectangularLines, stippledBresenhamLines, stippledSmoothLines );
71066       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rectangularLines == rhs.rectangularLines ) && ( bresenhamLines == rhs.bresenhamLines ) &&
71080     void *                              pNext                    = {};
71104       : pNext( pNext_ )
71143       return std::tie( sType, pNext, lineSubPixelPrecisionBits );
71155       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits );
71167     void *                              pNext                     = {};
71187       : pNext( pNext_ )
71212       pNext = pNext_;
71242       return std::tie( sType, pNext, linearColorAttachment );
71254       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearColorAttachment == rhs.linearColorAttachment );
71266     void *                              pNext                 = {};
71287       : pNext( pNext_ )
71327       return std::tie( sType, pNext, maxPerSetDescriptors, maxMemoryAllocationSize );
71339       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) &&
71352     void *                              pNext                   = {};
71374       : pNext( pNext_ )
71398       pNext = pNext_;
71427       return std::tie( sType, pNext, maintenance4 );
71439       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance4 == rhs.maintenance4 );
71451     void *                              pNext        = {};
71473       : pNext( pNext_ )
71512       return std::tie( sType, pNext, maxBufferSize );
71524       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBufferSize == rhs.maxBufferSize );
71536     void *                              pNext         = {};
71557       : pNext( pNext_ )
71581       pNext = pNext_;
71610       return std::tie( sType, pNext, maintenance5 );
71622       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance5 == rhs.maintenance5 );
71634     void *                              pNext        = {};
71659       : pNext( pNext_ )
71711                        pNext,
71729       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
71746     void *                              pNext                                               = {};
71770       : pNext( pNext_ )
71794       pNext = pNext_;
71823       return std::tie( sType, pNext, maintenance6 );
71835       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance6 == rhs.maintenance6 );
71847     void *                              pNext        = {};
71869       : pNext( pNext_ )
71914       return std::tie( sType, pNext, blockTexelViewCompatibleMultipleLayers, maxCombinedImageSamplerDescriptorCount, fragmentShadingRateClampCombinerInputs );
71926       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( blockTexelViewCompatibleMultipleLayers == rhs.blockTexelViewCompatibleMultipleLayers ) &&
71940     void *                              pNext                                  = {};
71963       : pNext( pNext_ )
72006       return std::tie( sType, pNext, heapBudget, heapUsage );
72018       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapBudget == rhs.heapBudget ) && ( heapUsage == rhs.heapUsage );
72030     void *                                                                                      pNext = {};
72051       : pNext( pNext_ )
72075       pNext = pNext_;
72105       return std::tie( sType, pNext, memoryDecompression );
72117       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryDecompression == rhs.memoryDecompression );
72129     void *                              pNext               = {};
72150       : pNext( pNext_ )
72191       return std::tie( sType, pNext, decompressionMethods, maxDecompressionIndirectCount );
72203       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decompressionMethods == rhs.decompressionMethods ) &&
72216     void *                                                 pNext                         = {};
72237       : pNext( pNext_ )
72261       pNext = pNext_;
72290       return std::tie( sType, pNext, memoryPriority );
72302       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryPriority == rhs.memoryPriority );
72314     void *                              pNext          = {};
72418       : pNext( pNext_ )
72457       return std::tie( sType, pNext, memoryProperties );
72469       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryProperties == rhs.memoryProperties );
72481     void *                                               pNext            = {};
72507       : pNext( pNext_ )
72535       pNext = pNext_;
72596       return std::tie( sType, pNext, taskShader, meshShader, multiviewMeshShader, primitiveFragmentShadingRateMeshShader, meshShaderQueries );
72608       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) && ( meshShader == rhs.meshShader ) &&
72622     void *                              pNext                                  = {};
72647       : pNext( pNext_ )
72672       pNext = pNext_;
72707       return std::tie( sType, pNext, taskShader, meshShader );
72719       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) && ( meshShader == rhs.meshShader );
72731     void *                              pNext      = {};
72779       : pNext( pNext_ )
72875                        pNext,
72915       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTaskWorkGroupTotalCount == rhs.maxTaskWorkGroupTotalCount ) &&
72943     void *                                            pNext                                 = {};
73002       : pNext( pNext_ )
73068                        pNext,
73093       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount ) &&
73112     void *                                            pNext                             = {};
73143       : pNext( pNext_ )
73167       pNext = pNext_;
73196       return std::tie( sType, pNext, multiDraw );
73208       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiDraw == rhs.multiDraw );
73220     void *                              pNext     = {};
73239       : pNext( pNext_ )
73278       return std::tie( sType, pNext, maxMultiDrawCount );
73290       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiDrawCount == rhs.maxMultiDrawCount );
73302     void *                              pNext             = {};
73322       : pNext( pNext_ )
73350       pNext = pNext_;
73380       return std::tie( sType, pNext, multisampledRenderToSingleSampled );
73392       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multisampledRenderToSingleSampled == rhs.multisampledRenderToSingleSampled );
73404     void *                              pNext                             = {};
73426       : pNext( pNext_ )
73452       pNext = pNext_;
73499       return std::tie( sType, pNext, multiview, multiviewGeometryShader, multiviewTessellationShader );
73511       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiview == rhs.multiview ) && ( multiviewGeometryShader == rhs.multiviewGeometryShader ) &&
73524     void *                              pNext                       = {};
73548       : pNext( pNext_ )
73589       return std::tie( sType, pNext, perViewPositionAllComponents );
73601       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents );
73613     void *                              pNext                        = {};
73633       : pNext( pNext_ )
73659       pNext = pNext_;
73689       return std::tie( sType, pNext, multiviewPerViewRenderAreas );
73701       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiviewPerViewRenderAreas == rhs.multiviewPerViewRenderAreas );
73713     void *                              pNext                       = {};
73733       : pNext( pNext_ )
73759       pNext = pNext_;
73789       return std::tie( sType, pNext, multiviewPerViewViewports );
73801       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiviewPerViewViewports == rhs.multiviewPerViewViewports );
73813     void *                              pNext                     = {};
73834       : pNext( pNext_ )
73874       return std::tie( sType, pNext, maxMultiviewViewCount, maxMultiviewInstanceIndex );
73886       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) &&
73899     void *                              pNext                     = {};
73922       : pNext( pNext_ )
73947       pNext = pNext_;
73977       return std::tie( sType, pNext, mutableDescriptorType );
73989       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType );
74001     void *                              pNext                 = {};
74025       : pNext( pNext_ )
74051       pNext = pNext_;
74099       return std::tie( sType, pNext, nestedCommandBuffer, nestedCommandBufferRendering, nestedCommandBufferSimultaneousUse );
74111       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( nestedCommandBuffer == rhs.nestedCommandBuffer ) &&
74125     void *                              pNext                              = {};
74147       : pNext( pNext_ )
74172       pNext = pNext_;
74202       return std::tie( sType, pNext, maxCommandBufferNestingLevel );
74214       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxCommandBufferNestingLevel == rhs.maxCommandBufferNestingLevel );
74226     void *                              pNext                        = {};
74246       : pNext( pNext_ )
74270       pNext = pNext_;
74300       return std::tie( sType, pNext, nonSeamlessCubeMap );
74312       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( nonSeamlessCubeMap == rhs.nonSeamlessCubeMap );
74324     void *                              pNext              = {};
74346       : pNext( pNext_ )
74372       pNext = pNext_;
74419       return std::tie( sType, pNext, micromap, micromapCaptureReplay, micromapHostCommands );
74431       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( micromap == rhs.micromap ) && ( micromapCaptureReplay == rhs.micromapCaptureReplay ) &&
74444     void *                              pNext                 = {};
74467       : pNext( pNext_ )
74507       return std::tie( sType, pNext, maxOpacity2StateSubdivisionLevel, maxOpacity4StateSubdivisionLevel );
74519       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxOpacity2StateSubdivisionLevel == rhs.maxOpacity2StateSubdivisionLevel ) &&
74532     void *                              pNext                            = {};
74552       : pNext( pNext_ )
74576       pNext = pNext_;
74605       return std::tie( sType, pNext, opticalFlow );
74617       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opticalFlow == rhs.opticalFlow );
74629     void *                              pNext       = {};
74659       : pNext( pNext_ )
74721                        pNext,
74744       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedOutputGridSizes == rhs.supportedOutputGridSizes ) &&
74760     void *                                           pNext                      = {};
74790       : pNext( pNext_ )
74832       return std::tie( sType, pNext, pciDomain, pciBus, pciDevice, pciFunction );
74844       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pciDomain == rhs.pciDomain ) && ( pciBus == rhs.pciBus ) && ( pciDevice == rhs.pciDevice ) &&
74857     void *                              pNext       = {};
74880       : pNext( pNext_ )
74906       pNext = pNext_;
74936       return std::tie( sType, pNext, pageableDeviceLocalMemory );
74948       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pageableDeviceLocalMemory == rhs.pageableDeviceLocalMemory );
74960     void *                              pNext                     = {};
74981       : pNext( pNext_ )
75007       pNext = pNext_;
75044       return std::tie( sType, pNext, perStageDescriptorSet, dynamicPipelineLayout );
75056       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perStageDescriptorSet == rhs.perStageDescriptorSet ) &&
75069     void *                              pNext                 = {};
75091       : pNext( pNext_ )
75116       pNext = pNext_;
75153       return std::tie( sType, pNext, performanceCounterQueryPools, performanceCounterMultipleQueryPools );
75165       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) &&
75178     void *                              pNext                                = {};
75199       : pNext( pNext_ )
75238       return std::tie( sType, pNext, allowCommandBufferQueryCopies );
75250       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies );
75262     void *                              pNext                         = {};
75282       : pNext( pNext_ )
75308       pNext = pNext_;
75338       return std::tie( sType, pNext, pipelineCreationCacheControl );
75350       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl );
75362     void *                              pNext                        = {};
75384       : pNext( pNext_ )
75410       pNext = pNext_;
75440       return std::tie( sType, pNext, pipelineExecutableInfo );
75452       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineExecutableInfo == rhs.pipelineExecutableInfo );
75464     void *                              pNext                  = {};
75484       : pNext( pNext_ )
75510       pNext = pNext_;
75540       return std::tie( sType, pNext, pipelineLibraryGroupHandles );
75552       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineLibraryGroupHandles == rhs.pipelineLibraryGroupHandles );
75564     void *                              pNext                       = {};
75584       : pNext( pNext_ )
75608       pNext = pNext_;
75638       return std::tie( sType, pNext, pipelinePropertiesIdentifier );
75650       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelinePropertiesIdentifier == rhs.pipelinePropertiesIdentifier );
75662     void *                              pNext                        = {};
75682       : pNext( pNext_ )
75707       pNext = pNext_;
75737       return std::tie( sType, pNext, pipelineProtectedAccess );
75749       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineProtectedAccess == rhs.pipelineProtectedAccess );
75761     void *                              pNext                   = {};
75781       : pNext( pNext_ )
75805       pNext = pNext_;
75835       return std::tie( sType, pNext, pipelineRobustness );
75847       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineRobustness == rhs.pipelineRobustness );
75859     void *                              pNext              = {};
75887       : pNext( pNext_ )
75935       return std::tie( sType, pNext, defaultRobustnessStorageBuffers, defaultRobustnessUniformBuffers, defaultRobustnessVertexInputs, defaultRobustnessImages );
75947       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( defaultRobustnessStorageBuffers == rhs.defaultRobustnessStorageBuffers ) &&
75961     void *                                                    pNext = {};
75988       : pNext( pNext_ )
76027       return std::tie( sType, pNext, pointClippingBehavior );
76039       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pointClippingBehavior == rhs.pointClippingBehavior );
76051     void *                                      pNext                 = {};
76088       : pNext( pNext_ )
76126       pNext = pNext_;
76268                        pNext,
76295       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantAlphaColorBlendFactors == rhs.constantAlphaColorBlendFactors ) &&
76315     void *                              pNext                                  = {};
76351       : pNext( pNext_ )
76375       pNext = pNext_;
76405       return std::tie( sType, pNext, minVertexInputBindingStrideAlignment );
76417       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minVertexInputBindingStrideAlignment == rhs.minVertexInputBindingStrideAlignment );
76429     void *                              pNext                                = {};
76450       : pNext( pNext_ )
76474       pNext = pNext_;
76503       return std::tie( sType, pNext, presentBarrier );
76515       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentBarrier == rhs.presentBarrier );
76527     void *                              pNext          = {};
76546       : pNext( pNext_ )
76570       pNext = pNext_;
76599       return std::tie( sType, pNext, presentId );
76611       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId );
76623     void *                              pNext     = {};
76642       : pNext( pNext_ )
76666       pNext = pNext_;
76695       return std::tie( sType, pNext, presentWait );
76707       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait == rhs.presentWait );
76719     void *                              pNext       = {};
76740       : pNext( pNext_ )
76767       pNext = pNext_;
76804       return std::tie( sType, pNext, primitiveTopologyListRestart, primitiveTopologyPatchListRestart );
76816       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( primitiveTopologyListRestart == rhs.primitiveTopologyListRestart ) &&
76829     void *                              pNext                             = {};
76852       : pNext( pNext_ )
76880       pNext = pNext_;
76928       return std::tie( sType, pNext, primitivesGeneratedQuery, primitivesGeneratedQueryWithRasterizerDiscard, primitivesGeneratedQueryWithNonZeroStreams );
76940       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( primitivesGeneratedQuery == rhs.primitivesGeneratedQuery ) &&
76954     void *                              pNext                                         = {};
76975       : pNext( pNext_ )
76999       pNext = pNext_;
77028       return std::tie( sType, pNext, privateData );
77040       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateData == rhs.privateData );
77052     void *                              pNext       = {};
77271       : pNext( pNext_ )
77310       return std::tie( sType, pNext, properties );
77322       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties );
77334     void *                                         pNext      = {};
77356       : pNext( pNext_ )
77380       pNext = pNext_;
77409       return std::tie( sType, pNext, protectedMemory );
77421       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedMemory == rhs.protectedMemory );
77433     void *                              pNext           = {};
77453       : pNext( pNext_ )
77492       return std::tie( sType, pNext, protectedNoFault );
77504       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedNoFault == rhs.protectedNoFault );
77516     void *                              pNext            = {};
77537       : pNext( pNext_ )
77562       pNext = pNext_;
77599       return std::tie( sType, pNext, provokingVertexLast, transformFeedbackPreservesProvokingVertex );
77611       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexLast == rhs.provokingVertexLast ) &&
77624     void *                              pNext                                     = {};
77646       : pNext( pNext_ )
77686       return std::tie( sType, pNext, provokingVertexModePerPipeline, transformFeedbackPreservesTriangleFanProvokingVertex );
77698       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexModePerPipeline == rhs.provokingVertexModePerPipeline ) &&
77711     void *                              pNext                                                = {};
77731       : pNext( pNext_ )
77770       return std::tie( sType, pNext, maxPushDescriptors );
77782       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPushDescriptors == rhs.maxPushDescriptors );
77794     void *                              pNext              = {};
77814       : pNext( pNext_ )
77838       pNext = pNext_;
77868       return std::tie( sType, pNext, formatRgba10x6WithoutYCbCrSampler );
77880       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatRgba10x6WithoutYCbCrSampler == rhs.formatRgba10x6WithoutYCbCrSampler );
77892     void *                              pNext                             = {};
77915       : pNext( pNext_ )
77945       pNext = pNext_;
77994         sType, pNext, rasterizationOrderColorAttachmentAccess, rasterizationOrderDepthAttachmentAccess, rasterizationOrderStencilAttachmentAccess );
78006       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrderColorAttachmentAccess == rhs.rasterizationOrderColorAttachmentAccess ) &&
78020     void *                              pNext                                     = {};
78043       : pNext( pNext_ )
78067       pNext = pNext_;
78096       return std::tie( sType, pNext, rayQuery );
78108       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayQuery == rhs.rayQuery );
78120     void *                              pNext    = {};
78140       : pNext( pNext_ )
78166       pNext = pNext_;
78196       return std::tie( sType, pNext, rayTracingInvocationReorder );
78208       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingInvocationReorder == rhs.rayTracingInvocationReorder );
78220     void *                              pNext                       = {};
78242       : pNext( pNext_ )
78283       return std::tie( sType, pNext, rayTracingInvocationReorderReorderingHint );
78295       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingInvocationReorderReorderingHint == rhs.rayTracingInvocationReorderReorderingHint );
78307     void *                                                  pNext = {};
78329       : pNext( pNext_ )
78355       pNext = pNext_;
78392       return std::tie( sType, pNext, rayTracingMaintenance1, rayTracingPipelineTraceRaysIndirect2 );
78404       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMaintenance1 == rhs.rayTracingMaintenance1 ) &&
78417     void *                              pNext                                = {};
78439       : pNext( pNext_ )
78464       pNext = pNext_;
78501       return std::tie( sType, pNext, rayTracingMotionBlur, rayTracingMotionBlurPipelineTraceRaysIndirect );
78513       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMotionBlur == rhs.rayTracingMotionBlur ) &&
78526     void *                              pNext                                         = {};
78551       : pNext( pNext_ )
78579       pNext = pNext_;
78644                        pNext,
78661       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPipeline == rhs.rayTracingPipeline ) &&
78677     void *                              pNext                                                 = {};
78708       : pNext( pNext_ )
78765                        pNext,
78785       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) &&
78801     void *                              pNext                              = {};
78828       : pNext( pNext_ )
78853       pNext = pNext_;
78883       return std::tie( sType, pNext, rayTracingPositionFetch );
78895       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPositionFetch == rhs.rayTracingPositionFetch );
78907     void *                              pNext                   = {};
78934       : pNext( pNext_ )
78990                        pNext,
79010       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) &&
79026     void *                              pNext                                  = {};
79053       : pNext( pNext_ )
79079       pNext = pNext_;
79109       return std::tie( sType, pNext, relaxedLineRasterization );
79121       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( relaxedLineRasterization == rhs.relaxedLineRasterization );
79133     void *                              pNext                    = {};
79153       : pNext( pNext_ )
79177       pNext = pNext_;
79207       return std::tie( sType, pNext, renderPassStriped );
79219       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPassStriped == rhs.renderPassStriped );
79231     void *                              pNext             = {};
79252       : pNext( pNext_ )
79292       return std::tie( sType, pNext, renderPassStripeGranularity, maxRenderPassStripes );
79304       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPassStripeGranularity == rhs.renderPassStripeGranularity ) &&
79317     void *                              pNext                       = {};
79338       : pNext( pNext_ )
79364       pNext = pNext_;
79394       return std::tie( sType, pNext, representativeFragmentTest );
79406       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( representativeFragmentTest == rhs.representativeFragmentTest );
79418     void *                              pNext                      = {};
79440       : pNext( pNext_ )
79466       pNext = pNext_;
79512       return std::tie( sType, pNext, robustBufferAccess2, robustImageAccess2, nullDescriptor );
79524       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) &&
79537     void *                              pNext               = {};
79560       : pNext( pNext_ )
79600       return std::tie( sType, pNext, robustStorageBufferAccessSizeAlignment, robustUniformBufferAccessSizeAlignment );
79612       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) &&
79625     void *                              pNext                                  = {};
79650       : pNext( pNext_ )
79700                        pNext,
79717       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) &&
79731     void *                                         pNext                         = {};
79756       : pNext( pNext_ )
79796       return std::tie( sType, pNext, filterMinmaxSingleComponentFormats, filterMinmaxImageComponentMapping );
79808       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) &&
79821     void *                              pNext                              = {};
79844       : pNext( pNext_ )
79868       pNext = pNext_;
79898       return std::tie( sType, pNext, samplerYcbcrConversion );
79910       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion );
79922     void *                              pNext                  = {};
79944       : pNext( pNext_ )
79968       pNext = pNext_;
79998       return std::tie( sType, pNext, scalarBlockLayout );
80010       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalarBlockLayout == rhs.scalarBlockLayout );
80022     void *                              pNext             = {};
80044       : pNext( pNext_ )
80068       pNext = pNext_;
80098       return std::tie( sType, pNext, schedulingControls );
80110       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( schedulingControls == rhs.schedulingControls );
80122     void *                              pNext              = {};
80143       : pNext( pNext_ )
80168       pNext = pNext_;
80198       return std::tie( sType, pNext, schedulingControlsFlags );
80210       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( schedulingControlsFlags == rhs.schedulingControlsFlags );
80222     void *                                                         pNext                   = {};
80242       : pNext( pNext_ )
80268       pNext = pNext_;
80298       return std::tie( sType, pNext, separateDepthStencilLayouts );
80310       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts );
80322     void *                              pNext                       = {};
80355       : pNext( pNext_ )
80390       pNext = pNext_;
80511                        pNext,
80535       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBufferFloat16Atomics == rhs.shaderBufferFloat16Atomics ) &&
80557     void *                              pNext                           = {};
80599       : pNext( pNext_ )
80634       pNext = pNext_;
80755                        pNext,
80779       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBufferFloat32Atomics == rhs.shaderBufferFloat32Atomics ) &&
80797     void *                              pNext                        = {};
80829       : pNext( pNext_ )
80854       pNext = pNext_;
80891       return std::tie( sType, pNext, shaderBufferInt64Atomics, shaderSharedInt64Atomics );
80903       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) &&
80916     void *                              pNext                    = {};
80940       : pNext( pNext_ )
80965       pNext = pNext_;
81001       return std::tie( sType, pNext, shaderSubgroupClock, shaderDeviceClock );
81013       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupClock == rhs.shaderSubgroupClock ) &&
81026     void *                              pNext               = {};
81047       : pNext( pNext_ )
81071       pNext = pNext_;
81101       return std::tie( sType, pNext, shaderCoreBuiltins );
81113       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreBuiltins == rhs.shaderCoreBuiltins );
81125     void *                              pNext              = {};
81147       : pNext( pNext_ )
81189       return std::tie( sType, pNext, shaderCoreMask, shaderCoreCount, shaderWarpsPerCore );
81201       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreMask == rhs.shaderCoreMask ) && ( shaderCoreCount == rhs.shaderCoreCount ) &&
81214     void *                              pNext              = {};
81237       : pNext( pNext_ )
81277       return std::tie( sType, pNext, shaderCoreFeatures, activeComputeUnitCount );
81289       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) &&
81302     void *                                             pNext                  = {};
81336       : pNext( pNext_ )
81404                        pNext,
81430       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEngineCount == rhs.shaderEngineCount ) &&
81448     void *                              pNext                      = {};
81483       : pNext( pNext_ )
81524       return std::tie( sType, pNext, pixelRate, texelRate, fmaRate );
81536       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pixelRate == rhs.pixelRate ) && ( texelRate == rhs.texelRate ) && ( fmaRate == rhs.fmaRate );
81548     void *                              pNext     = {};
81570       : pNext( pNext_ )
81596       pNext = pNext_;
81626       return std::tie( sType, pNext, shaderDemoteToHelperInvocation );
81638       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation );
81650     void *                              pNext                          = {};
81672       : pNext( pNext_ )
81696       pNext = pNext_;
81726       return std::tie( sType, pNext, shaderDrawParameters );
81738       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters );
81750     void *                              pNext                = {};
81772       : pNext( pNext_ )
81799       pNext = pNext_;
81829       return std::tie( sType, pNext, shaderEarlyAndLateFragmentTests );
81841       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEarlyAndLateFragmentTests == rhs.shaderEarlyAndLateFragmentTests );
81853     void *                              pNext                           = {};
81874       : pNext( pNext_ )
81898       pNext = pNext_;
81927       return std::tie( sType, pNext, shaderEnqueue );
81939       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEnqueue == rhs.shaderEnqueue );
81951     void *                              pNext         = {};
81977       : pNext( pNext_ )
82005       pNext = pNext_;
82069                        pNext,
82086       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxExecutionGraphDepth == rhs.maxExecutionGraphDepth ) &&
82102     void *                              pNext                                  = {};
82128       : pNext( pNext_ )
82153       pNext = pNext_;
82188       return std::tie( sType, pNext, shaderFloat16, shaderInt8 );
82200       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16 == rhs.shaderFloat16 ) && ( shaderInt8 == rhs.shaderInt8 );
82212     void *                              pNext         = {};
82237       : pNext( pNext_ )
82263       pNext = pNext_;
82300       return std::tie( sType, pNext, shaderImageInt64Atomics, sparseImageInt64Atomics );
82312       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderImageInt64Atomics == rhs.shaderImageInt64Atomics ) &&
82325     void *                              pNext                   = {};
82346       : pNext( pNext_ )
82370       pNext = pNext_;
82399       return std::tie( sType, pNext, imageFootprint );
82411       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFootprint == rhs.imageFootprint );
82423     void *                              pNext          = {};
82443       : pNext( pNext_ )
82468       pNext = pNext_;
82498       return std::tie( sType, pNext, shaderIntegerDotProduct );
82510       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct );
82522     void *                              pNext                   = {};
82574       : pNext( pNext_ )
82676                        pNext,
82718       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) &&
82766     void *                              pNext                                            = {};
82817       : pNext( pNext_ )
82843       pNext = pNext_;
82873       return std::tie( sType, pNext, shaderIntegerFunctions2 );
82885       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 );
82897     void *                              pNext                   = {};
82917       : pNext( pNext_ )
82942       pNext = pNext_;
82972       return std::tie( sType, pNext, shaderModuleIdentifier );
82984       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderModuleIdentifier == rhs.shaderModuleIdentifier );
82996     void *                              pNext                  = {};
83017       : pNext( pNext_ )
83058       return std::tie( sType, pNext, shaderModuleIdentifierAlgorithmUUID );
83070       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderModuleIdentifierAlgorithmUUID == rhs.shaderModuleIdentifierAlgorithmUUID );
83082     void *                                                      pNext = {};
83101       : pNext( pNext_ )
83125       pNext = pNext_;
83154       return std::tie( sType, pNext, shaderObject );
83166       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderObject == rhs.shaderObject );
83178     void *                              pNext        = {};
83199       : pNext( pNext_ )
83240       return std::tie( sType, pNext, shaderBinaryUUID, shaderBinaryVersion );
83252       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBinaryUUID == rhs.shaderBinaryUUID ) &&
83265     void *                                                      pNext               = {};
83286       : pNext( pNext_ )
83310       pNext = pNext_;
83339       return std::tie( sType, pNext, shaderSMBuiltins );
83351       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMBuiltins == rhs.shaderSMBuiltins );
83363     void *                              pNext            = {};
83383       : pNext( pNext_ )
83423       return std::tie( sType, pNext, shaderSMCount, shaderWarpsPerSM );
83435       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMCount == rhs.shaderSMCount ) && ( shaderWarpsPerSM == rhs.shaderWarpsPerSM );
83447     void *                              pNext            = {};
83468       : pNext( pNext_ )
83494       pNext = pNext_;
83524       return std::tie( sType, pNext, shaderSubgroupExtendedTypes );
83536       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes );
83548     void *                              pNext                       = {};
83570       : pNext( pNext_ )
83598       pNext = pNext_;
83628       return std::tie( sType, pNext, shaderSubgroupUniformControlFlow );
83640       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupUniformControlFlow == rhs.shaderSubgroupUniformControlFlow );
83652     void *                              pNext                            = {};
83672       : pNext( pNext_ )
83697       pNext = pNext_;
83727       return std::tie( sType, pNext, shaderTerminateInvocation );
83739       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderTerminateInvocation == rhs.shaderTerminateInvocation );
83751     void *                              pNext                     = {};
83775       : pNext( pNext_ )
83801       pNext = pNext_;
83849       return std::tie( sType, pNext, shaderTileImageColorReadAccess, shaderTileImageDepthReadAccess, shaderTileImageStencilReadAccess );
83861       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderTileImageColorReadAccess == rhs.shaderTileImageColorReadAccess ) &&
83875     void *                              pNext                            = {};
83899       : pNext( pNext_ )
83945         sType, pNext, shaderTileImageCoherentReadAccelerated, shaderTileImageReadSampleFromPixelRateInvocation, shaderTileImageReadFromHelperInvocation );
83957       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderTileImageCoherentReadAccelerated == rhs.shaderTileImageCoherentReadAccelerated ) &&
83971     void *                              pNext                                            = {};
83994       : pNext( pNext_ )
84019       pNext = pNext_;
84055       return std::tie( sType, pNext, shadingRateImage, shadingRateCoarseSampleOrder );
84067       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImage == rhs.shadingRateImage ) &&
84080     void *                              pNext                        = {};
84103       : pNext( pNext_ )
84144       return std::tie( sType, pNext, shadingRateTexelSize, shadingRatePaletteSize, shadingRateMaxCoarseSamples );
84156       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) &&
84169     void *                              pNext                       = {};
84196       : pNext( pNext_ )
84224       pNext = pNext_;
84283       return std::tie( sType, pNext, format, type, samples, usage, tiling );
84295       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && ( samples == rhs.samples ) &&
84308     const void *                              pNext   = {};
84337       : pNext( pNext_ )
84384       return std::tie( sType, pNext, subgroupSize, supportedStages, supportedOperations, quadOperationsInAllStages );
84396       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSize == rhs.subgroupSize ) && ( supportedStages == rhs.supportedStages ) &&
84409     void *                                     pNext                     = {};
84433       : pNext( pNext_ )
84458       pNext = pNext_;
84495       return std::tie( sType, pNext, subgroupSizeControl, computeFullSubgroups );
84507       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSizeControl == rhs.subgroupSizeControl ) &&
84520     void *                              pNext                = {};
84546       : pNext( pNext_ )
84593       return std::tie( sType, pNext, minSubgroupSize, maxSubgroupSize, maxComputeWorkgroupSubgroups, requiredSubgroupSizeStages );
84605       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) && ( maxSubgroupSize == rhs.maxSubgroupSize ) &&
84618     void *                                 pNext                        = {};
84643       : pNext( pNext_ )
84668       pNext = pNext_;
84698       return std::tie( sType, pNext, subpassMergeFeedback );
84710       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassMergeFeedback == rhs.subpassMergeFeedback );
84722     void *                              pNext                = {};
84742       : pNext( pNext_ )
84766       pNext = pNext_;
84795       return std::tie( sType, pNext, subpassShading );
84807       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassShading == rhs.subpassShading );
84819     void *                              pNext          = {};
84839       : pNext( pNext_ )
84878       return std::tie( sType, pNext, maxSubpassShadingWorkgroupSizeAspectRatio );
84890       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSubpassShadingWorkgroupSizeAspectRatio == rhs.maxSubpassShadingWorkgroupSizeAspectRatio );
84902     void *                              pNext                                     = {};
84921       : pNext( pNext_ )
84945       pNext = pNext_;
84974       return std::tie( sType, pNext, surface );
84986       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surface == rhs.surface );
84998     const void *                        pNext   = {};
85018       : pNext( pNext_ )
85043       pNext = pNext_;
85073       return std::tie( sType, pNext, swapchainMaintenance1 );
85085       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainMaintenance1 == rhs.swapchainMaintenance1 );
85097     void *                              pNext                 = {};
85117       : pNext( pNext_ )
85141       pNext = pNext_;
85170       return std::tie( sType, pNext, synchronization2 );
85182       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( synchronization2 == rhs.synchronization2 );
85194     void *                              pNext            = {};
85216       : pNext( pNext_ )
85241       pNext = pNext_;
85271       return std::tie( sType, pNext, texelBufferAlignment );
85283       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( texelBufferAlignment == rhs.texelBufferAlignment );
85295     void *                              pNext                = {};
85318       : pNext( pNext_ )
85366                        pNext,
85382       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) &&
85397     void *                              pNext                                        = {};
85422       : pNext( pNext_ )
85447       pNext = pNext_;
85477       return std::tie( sType, pNext, textureCompressionASTC_HDR );
85489       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR );
85501     void *                              pNext                      = {};
85523       : pNext( pNext_ )
85547       pNext = pNext_;
85576       return std::tie( sType, pNext, tileProperties );
85588       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileProperties == rhs.tileProperties );
85600     void *                              pNext          = {};
85620       : pNext( pNext_ )
85644       pNext = pNext_;
85674       return std::tie( sType, pNext, timelineSemaphore );
85686       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timelineSemaphore == rhs.timelineSemaphore );
85698     void *                              pNext             = {};
85720       : pNext( pNext_ )
85759       return std::tie( sType, pNext, maxTimelineSemaphoreValueDifference );
85771       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference );
85783     void *                              pNext                               = {};
85809       : pNext( pNext_ )
85858       return std::tie( sType, pNext, name, version, purposes, description, layer );
85870       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( version == rhs.version ) && ( purposes == rhs.purposes ) &&
85883     void *                                                                 pNext       = {};
85910       : pNext( pNext_ )
85935       pNext = pNext_;
85971       return std::tie( sType, pNext, transformFeedback, geometryStreams );
85983       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transformFeedback == rhs.transformFeedback ) && ( geometryStreams == rhs.geometryStreams );
85995     void *                              pNext             = {};
86025       : pNext( pNext_ )
86085                        pNext,
86107       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams ) &&
86127     void *                              pNext                                      = {};
86156       : pNext( pNext_ )
86182       pNext = pNext_;
86212       return std::tie( sType, pNext, uniformBufferStandardLayout );
86224       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout );
86236     void *                              pNext                       = {};
86259       : pNext( pNext_ )
86284       pNext = pNext_;
86320       return std::tie( sType, pNext, variablePointersStorageBuffer, variablePointers );
86332       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) &&
86345     void *                              pNext                         = {};
86371       : pNext( pNext_ )
86397       pNext = pNext_;
86434       return std::tie( sType, pNext, vertexAttributeInstanceRateDivisor, vertexAttributeInstanceRateZeroDivisor );
86446       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) &&
86459     void *                              pNext                                  = {};
86481       : pNext( pNext_ )
86522       return std::tie( sType, pNext, maxVertexAttribDivisor );
86534       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor );
86546     void *                              pNext                  = {};
86567       : pNext( pNext_ )
86609       return std::tie( sType, pNext, maxVertexAttribDivisor, supportsNonZeroFirstInstance );
86621       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ) &&
86634     void *                              pNext                        = {};
86655       : pNext( pNext_ )
86680       pNext = pNext_;
86710       return std::tie( sType, pNext, vertexInputDynamicState );
86722       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexInputDynamicState == rhs.vertexInputDynamicState );
86734     void *                              pNext                   = {};
86758       : pNext( pNext_ )
86784       pNext = pNext_;
86838       return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth );
86850       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) &&
86863     const void *                                         pNext               = {};
86887       : pNext( pNext_ )
86912       pNext = pNext_;
86948       return std::tie( sType, pNext, pVideoProfile, qualityLevel );
86960       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVideoProfile == rhs.pVideoProfile ) && ( qualityLevel == rhs.qualityLevel );
86972     const void *                                      pNext         = {};
86993       : pNext( pNext_ )
87017       pNext = pNext_;
87046       return std::tie( sType, pNext, imageUsage );
87058       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageUsage == rhs.imageUsage );
87070     const void *                          pNext      = {};
87090       : pNext( pNext_ )
87114       pNext = pNext_;
87144       return std::tie( sType, pNext, videoMaintenance1 );
87156       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoMaintenance1 == rhs.videoMaintenance1 );
87168     void *                              pNext             = {};
87199       : pNext( pNext_ )
87234       pNext = pNext_;
87349                        pNext,
87373       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) &&
87391     void *                              pNext                              = {};
87437       : pNext( pNext_ )
87507                        pNext,
87534       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && ( driverUUID == rhs.driverUUID ) &&
87553     void *                                                      pNext                             = {};
87633       : pNext( pNext_ )
87703       pNext = pNext_;
88091                        pNext,
88150       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( samplerMirrorClampToEdge == rhs.samplerMirrorClampToEdge ) &&
88196     void *                              pNext                                              = {};
88314       : pNext( pNext_ )
88458                        pNext,
88522       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( driverName == rhs.driverName ) &&
88574     void *                                                              pNext              = {};
88659       : pNext( pNext_ )
88697       pNext = pNext_;
88834                        pNext,
88861       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess ) &&
88881     void *                              pNext                                              = {};
88960       : pNext( pNext_ )
89091                        pNext,
89148       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) && ( maxSubgroupSize == rhs.maxSubgroupSize ) &&
89208     void *                                 pNext                                                          = {};
89274       : pNext( pNext_ )
89300       pNext = pNext_;
89348       return std::tie( sType, pNext, vulkanMemoryModel, vulkanMemoryModelDeviceScope, vulkanMemoryModelAvailabilityVisibilityChains );
89360       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) &&
89374     void *                              pNext                                         = {};
89402       : pNext( pNext_ )
89432       pNext = pNext_;
89489                        pNext,
89505       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( workgroupMemoryExplicitLayout == rhs.workgroupMemoryExplicitLayout ) &&
89520     void *                              pNext                                          = {};
89543       : pNext( pNext_ )
89568       pNext = pNext_;
89598       return std::tie( sType, pNext, ycbcr2plane444Formats );
89610       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcr2plane444Formats == rhs.ycbcr2plane444Formats );
89622     void *                              pNext                 = {};
89641       : pNext( pNext_ )
89665       pNext = pNext_;
89694       return std::tie( sType, pNext, ycbcrDegamma );
89706       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrDegamma == rhs.ycbcrDegamma );
89718     void *                              pNext        = {};
89738       : pNext( pNext_ )
89762       pNext = pNext_;
89792       return std::tie( sType, pNext, ycbcrImageArrays );
89804       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrImageArrays == rhs.ycbcrImageArrays );
89816     void *                              pNext            = {};
89836       : pNext( pNext_ )
89862       pNext = pNext_;
89892       return std::tie( sType, pNext, shaderZeroInitializeWorkgroupMemory );
89904       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory );
89916     void *                              pNext                               = {};
89940       : pNext( pNext_ )
89959       : pNext( pNext_ ), flags( flags_ ), initialDataSize( initialData_.size() * sizeof( T ) ), pInitialData( initialData_.data() )
89976       pNext = pNext_;
90031       return std::tie( sType, pNext, flags, initialDataSize, pInitialData );
90043       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( initialDataSize == rhs.initialDataSize ) &&
90056     const void *                                   pNext           = {};
90202       : pNext( pNext_ )
90228       pNext = pNext_;
90276       return std::tie( sType, pNext, srcPremultiplied, dstPremultiplied, blendOverlap );
90288       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcPremultiplied == rhs.srcPremultiplied ) && ( dstPremultiplied == rhs.dstPremultiplied ) &&
90301     const void *                          pNext            = {};
90324       : pNext( pNext_ )
90340       : pNext( pNext_ ), attachmentCount( static_cast<uint32_t>( colorWriteEnables_.size() ) ), pColorWriteEnables( colorWriteEnables_.data() )
90357       pNext = pNext_;
90403       return std::tie( sType, pNext, attachmentCount, pColorWriteEnables );
90415       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && ( pColorWriteEnables == rhs.pColorWriteEnables );
90427     const void *                         pNext              = {};
90448       : pNext( pNext_ )
90472       pNext = pNext_;
90502       return std::tie( sType, pNext, compilerControlFlags );
90514       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compilerControlFlags == rhs.compilerControlFlags );
90526     const void *                                          pNext                = {};
90551       : pNext( pNext_ )
90573       : pNext( pNext_ )
90595       pNext = pNext_;
90669       return std::tie( sType, pNext, flags, coverageModulationMode, coverageModulationTableEnable, coverageModulationTableCount, pCoverageModulationTable );
90681       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( coverageModulationMode == rhs.coverageModulationMode ) &&
90695     const void *                                                       pNext                  = {};
90721       : pNext( pNext_ )
90746       pNext = pNext_;
90786       return std::tie( sType, pNext, flags, coverageReductionMode );
90798       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( coverageReductionMode == rhs.coverageReductionMode );
90810     const void *                                                      pNext                 = {};
90833       : pNext( pNext_ )
90859       pNext = pNext_;
90906       return std::tie( sType, pNext, flags, coverageToColorEnable, coverageToColorLocation );
90918       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( coverageToColorEnable == rhs.coverageToColorEnable ) &&
90931     const void *                                                    pNext                   = {};
90953       : pNext( pNext_ )
90977       pNext = pNext_;
91006       return std::tie( sType, pNext, flags );
91018       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
91030     const void *                                  pNext = {};
91127       : pNext( pNext_ )
91146       : pNext( pNext_ )
91166       pNext = pNext_;
91225       return std::tie( sType, pNext, pPipelineCreationFeedback, pipelineStageCreationFeedbackCount, pPipelineStageCreationFeedbacks );
91237       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) &&
91251     const void *                                     pNext                              = {};
91279       : pNext( pNext_ )
91299       : pNext( pNext_ )
91320       pNext = pNext_;
91385       return std::tie( sType, pNext, flags, discardRectangleMode, discardRectangleCount, pDiscardRectangles );
91397       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( discardRectangleMode == rhs.discardRectangleMode ) &&
91410     const void *                                                      pNext                 = {};
91434       : pNext( pNext_ )
91459       pNext = pNext_;
91494       return std::tie( sType, pNext, pipeline, executableIndex );
91506       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ) && ( executableIndex == rhs.executableIndex );
91518     const void *                        pNext           = {};
91543       : pNext( pNext_ )
91567       : pNext( pNext_ ), name( name_ ), description( description_ ), isText( isText_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() )
91605       return std::tie( sType, pNext, name, description, isText, dataSize, pData );
91617       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( description == rhs.description ) && ( isText == rhs.isText ) &&
91630     void *                                                              pNext       = {};
91657       : pNext( pNext_ )
91704       return std::tie( sType, pNext, stages, name, description, subgroupSize );
91716       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( name == rhs.name ) && ( description == rhs.description ) &&
91729     void *                                                              pNext        = {};
91819       : pNext( pNext_ )
91866       return std::tie( sType, pNext, name, description, format, value );
91872     void *                                                              pNext       = {};
91899       : pNext( pNext_ )
91926       pNext = pNext_;
91974       return std::tie( sType, pNext, shadingRateType, shadingRate, combinerOps );
91986       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateType == rhs.shadingRateType ) && ( shadingRate == rhs.shadingRate ) &&
91999     const void *                                    pNext           = {};
92024       : pNext( pNext_ )
92050       pNext = pNext_;
92090       return std::tie( sType, pNext, fragmentSize, combinerOps );
92102       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentSize == rhs.fragmentSize ) && ( combinerOps == rhs.combinerOps );
92114     const void *                        pNext        = {};
92137       : pNext( pNext_ )
92162       pNext = pNext_;
92201       return std::tie( sType, pNext, pipelineBindPoint, pipeline );
92213       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipeline == rhs.pipeline );
92225     const void *                            pNext             = {};
92245       : pNext( pNext_ )
92266       pNext = pNext_;
92295       return std::tie( sType, pNext, pipeline );
92307       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline );
92319     const void *                        pNext    = {};
92437       : pNext( pNext_ )
92458       : pNext( pNext_ )
92480       pNext = pNext_;
92560       return std::tie( sType, pNext, flags, setLayoutCount, pSetLayouts, pushConstantRangeCount, pPushConstantRanges );
92572       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( setLayoutCount == rhs.setLayoutCount ) &&
92586     const void *                                      pNext                  = {};
92610       : pNext( pNext_ )
92634       pNext = pNext_;
92663       return std::tie( sType, pNext, pipelineIdentifier );
92675       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineIdentifier == rhs.pipelineIdentifier );
92687     void *                                                      pNext              = {};
92710       : pNext( pNext_ )
92738       pNext = pNext_;
92786       return std::tie( sType, pNext, flags, conservativeRasterizationMode, extraPrimitiveOverestimationSize );
92798       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
92812     const void *                                                               pNext     = {};
92835       : pNext( pNext_ )
92861       pNext = pNext_;
92901       return std::tie( sType, pNext, flags, depthClipEnable );
92913       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( depthClipEnable == rhs.depthClipEnable );
92925     const void *                                                            pNext           = {};
92950       : pNext( pNext_ )
92977       pNext = pNext_;
93031       return std::tie( sType, pNext, lineRasterizationMode, stippledLineEnable, lineStippleFactor, lineStipplePattern );
93043       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lineRasterizationMode == rhs.lineRasterizationMode ) &&
93057     const void *                                   pNext                 = {};
93081       : pNext( pNext_ )
93108       pNext = pNext_;
93138       return std::tie( sType, pNext, provokingVertexMode );
93150       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexMode == rhs.provokingVertexMode );
93162     const void *                                 pNext               = {};
93183       : pNext( pNext_ )
93208       pNext = pNext_;
93238       return std::tie( sType, pNext, rasterizationOrder );
93250       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrder == rhs.rasterizationOrder );
93262     const void *                                pNext              = {};
93283       : pNext( pNext_ )
93309       pNext = pNext_;
93348       return std::tie( sType, pNext, flags, rasterizationStream );
93360       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rasterizationStream == rhs.rasterizationStream );
93372     const void *                                                         pNext               = {};
93397       : pNext( pNext_ )
93419       : pNext( pNext_ )
93441       pNext = pNext_;
93512       return std::tie( sType, pNext, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat );
93524       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
93538     const void *                         pNext                   = {};
93564       : pNext( pNext_ )
93590       pNext = pNext_;
93620       return std::tie( sType, pNext, representativeFragmentTestEnable );
93632       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable );
93644     const void *                        pNext                            = {};
93668       : pNext( pNext_ )
93695       pNext = pNext_;
93750       return std::tie( sType, pNext, storageBuffers, uniformBuffers, vertexInputs, images );
93762       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffers == rhs.storageBuffers ) && ( uniformBuffers == rhs.uniformBuffers ) &&
93775     const void *                                              pNext          = {};
93799       : pNext( pNext_ )
93824       pNext = pNext_;
93864       return std::tie( sType, pNext, sampleLocationsEnable, sampleLocationsInfo );
93876       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationsEnable == rhs.sampleLocationsEnable ) &&
93889     const void *                                 pNext                 = {};
93911       : pNext( pNext_ )
93928       : pNext( pNext_ ), identifierSize( static_cast<uint32_t>( identifier_.size() ) ), pIdentifier( identifier_.data() )
93945       pNext = pNext_;
93990       return std::tie( sType, pNext, identifierSize, pIdentifier );
94002       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && ( pIdentifier == rhs.pIdentifier );
94014     const void *                        pNext          = {};
94036       : pNext( pNext_ )
94061       pNext = pNext_;
94096       return std::tie( sType, pNext, pName, index );
94105       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
94119       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( index == rhs.index );
94129     const void *                        pNext = {};
94150       : pNext( pNext_ )
94191       return std::tie( sType, pNext, requiredSubgroupSize );
94203       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( requiredSubgroupSize == rhs.requiredSubgroupSize );
94215     void *                              pNext                = {};
94239       : pNext( pNext_ )
94264       pNext = pNext_;
94294       return std::tie( sType, pNext, domainOrigin );
94306       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( domainOrigin == rhs.domainOrigin );
94318     const void *                                   pNext        = {};
94430       : pNext( pNext_ )
94447       : pNext( pNext_ )
94466       pNext = pNext_;
94517       return std::tie( sType, pNext, vertexBindingDivisorCount, pVertexBindingDivisors );
94529       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) &&
94542     const void *                                                          pNext = {};
94568       : pNext( pNext_ )
94588       : pNext( pNext_ )
94609       pNext = pNext_;
94667       return std::tie( sType, pNext, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
94679       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleOrderType == rhs.sampleOrderType ) &&
94692     const void *                                            pNext                  = {};
94714       : pNext( pNext_ )
94739       pNext = pNext_;
94769       return std::tie( sType, pNext, negativeOneToOne );
94781       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( negativeOneToOne == rhs.negativeOneToOne );
94793     const void *                        pNext            = {};
94814       : pNext( pNext_ )
94831       : pNext( pNext_ ), exclusiveScissorCount( static_cast<uint32_t>( exclusiveScissors_.size() ) ), pExclusiveScissors( exclusiveScissors_.data() )
94849       pNext = pNext_;
94895       return std::tie( sType, pNext, exclusiveScissorCount, pExclusiveScissors );
94907       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissorCount == rhs.exclusiveScissorCount ) &&
94920     const void *                         pNext                 = {};
95051       : pNext( pNext_ )
95071       : pNext( pNext_ )
95092       pNext = pNext_;
95149       return std::tie( sType, pNext, shadingRateImageEnable, viewportCount, pShadingRatePalettes );
95161       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImageEnable == rhs.shadingRateImageEnable ) &&
95174     const void *                                       pNext                  = {};
95304       : pNext( pNext_ )
95323       : pNext( pNext_ ), flags( flags_ ), viewportCount( static_cast<uint32_t>( viewportSwizzles_.size() ) ), pViewportSwizzles( viewportSwizzles_.data() )
95340       pNext = pNext_;
95397       return std::tie( sType, pNext, flags, viewportCount, pViewportSwizzles );
95409       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewportCount == rhs.viewportCount ) &&
95422     const void *                                                    pNext             = {};
95529       : pNext( pNext_ )
95548       : pNext( pNext_ )
95568       pNext = pNext_;
95625       return std::tie( sType, pNext, viewportWScalingEnable, viewportCount, pViewportWScalings );
95637       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportWScalingEnable == rhs.viewportWScalingEnable ) &&
95650     const void *                                     pNext                  = {};
95672       : pNext( pNext_ )
95696       pNext = pNext_;
95725       return std::tie( sType, pNext, frameToken );
95734       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
95745       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ) == 0 );
95755     const void *                        pNext      = {};
95775       : pNext( pNext_ )
95787       : pNext( pNext_ ), swapchainCount( static_cast<uint32_t>( presentIds_.size() ) ), pPresentIds( presentIds_.data() )
95804       pNext = pNext_;
95848       return std::tie( sType, pNext, swapchainCount, pPresentIds );
95860       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pPresentIds == rhs.pPresentIds );
95872     const void *                        pNext          = {};
95898       : pNext( pNext_ )
95918       : pNext( pNext_ )
95959       pNext = pNext_;
96063       return std::tie( sType, pNext, waitSemaphoreCount, pWaitSemaphores, swapchainCount, pSwapchains, pImageIndices, pResults );
96075       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
96089     const void *                               pNext              = {};
96309       : pNext( pNext_ )
96322       : pNext( pNext_ ), swapchainCount( static_cast<uint32_t>( regions_.size() ) ), pRegions( regions_.data() )
96339       pNext = pNext_;
96384       return std::tie( sType, pNext, swapchainCount, pRegions );
96396       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pRegions == rhs.pRegions );
96408     const void *                                   pNext          = {};
96513       : pNext( pNext_ )
96529       : pNext( pNext_ ), swapchainCount( static_cast<uint32_t>( times_.size() ) ), pTimes( times_.data() )
96546       pNext = pNext_;
96591       return std::tie( sType, pNext, swapchainCount, pTimes );
96603       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pTimes == rhs.pTimes );
96615     const void *                                    pNext          = {};
96636       : pNext( pNext_ )
96660       pNext = pNext_;
96689       return std::tie( sType, pNext, flags );
96701       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
96713     const void *                                     pNext = {};
96734       : pNext( pNext_ )
96757       pNext = pNext_;
96786       return std::tie( sType, pNext, protectedSubmit );
96798       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedSubmit == rhs.protectedSubmit );
96810     const void *                        pNext           = {};
96834       : pNext( pNext_ )
96857       : pNext( pNext_ )
96879       pNext = pNext_;
96948       return std::tie( sType, pNext, layout, stageFlags, offset, size, pValues );
96960       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( layout == rhs.layout ) && ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) &&
96973     const void *                           pNext      = {};
97004       : pNext( pNext_ )
97029       : pNext( pNext_ )
97065       pNext = pNext_;
97175       return std::tie( sType, pNext, dstSet, dstBinding, dstArrayElement, descriptorCount, descriptorType, pImageInfo, pBufferInfo, pTexelBufferView );
97187       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) &&
97201     const void *                                       pNext            = {};
97232       : pNext( pNext_ )
97254       : pNext( pNext_ )
97276       pNext = pNext_;
97346       return std::tie( sType, pNext, stageFlags, layout, set, descriptorWriteCount, pDescriptorWrites );
97358       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( set == rhs.set ) &&
97371     const void *                                     pNext                = {};
97398       : pNext( pNext_ )
97425       pNext = pNext_;
97478       return std::tie( sType, pNext, descriptorUpdateTemplate, layout, set, pData );
97490       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorUpdateTemplate == rhs.descriptorUpdateTemplate ) && ( layout == rhs.layout ) &&
97503     const void *                                   pNext                    = {};
97525       : pNext( pNext_ )
97549       pNext = pNext_;
97578       return std::tie( sType, pNext, pQueriedLowLatencyData );
97590       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pQueriedLowLatencyData == rhs.pQueriedLowLatencyData );
97602     const void *                        pNext                  = {};
97625       : pNext( pNext_ )
97651       pNext = pNext_;
97704       return std::tie( sType, pNext, flags, queryType, queryCount, pipelineStatistics );
97716       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queryType == rhs.queryType ) && ( queryCount == rhs.queryCount ) &&
97729     const void *                                      pNext              = {};
97754       : pNext( pNext_ )
97772       : pNext( pNext_ )
97792       pNext = pNext_;
97843       return std::tie( sType, pNext, queueFamilyIndex, counterIndexCount, pCounterIndices );
97855       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
97868     const void *                        pNext             = {};
97891       : pNext( pNext_ )
97915       pNext = pNext_;
97945       return std::tie( sType, pNext, performanceCountersSampling );
97957       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performanceCountersSampling == rhs.performanceCountersSampling );
97969     const void *                                     pNext                       = {};
97991       : pNext( pNext_ )
98015       pNext = pNext_;
98045       return std::tie( sType, pNext, encodeFeedbackFlags );
98057       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( encodeFeedbackFlags == rhs.encodeFeedbackFlags );
98069     const void *                                      pNext               = {};
98089       : pNext( pNext_ )
98128       return std::tie( sType, pNext, checkpointExecutionStageMask );
98140       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
98152     void *                                    pNext                        = {};
98172       : pNext( pNext_ )
98211       return std::tie( sType, pNext, checkpointExecutionStageMask );
98223       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
98235     void *                                   pNext                        = {};
98273       : pNext( pNext_ )
98298       pNext = pNext_;
98337       return std::tie( sType, pNext, priorityCount, priorities );
98349       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) && ( priorities == rhs.priorities );
98361     void *                              pNext         = {};
98464       : pNext( pNext_ )
98503       return std::tie( sType, pNext, queueFamilyProperties );
98515       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyProperties == rhs.queueFamilyProperties );
98527     void *                                      pNext                 = {};
98549       : pNext( pNext_ )
98588       return std::tie( sType, pNext, queryResultStatusSupport );
98600       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queryResultStatusSupport == rhs.queryResultStatusSupport );
98612     void *                              pNext                    = {};
98632       : pNext( pNext_ )
98671       return std::tie( sType, pNext, videoCodecOperations );
98683       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperations == rhs.videoCodecOperations );
98695     void *                                            pNext                = {};
98721       : pNext( pNext_ )
98750       pNext = pNext_;
98817       return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader, pShaderGroupCaptureReplayHandle );
98829       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( generalShader == rhs.generalShader ) &&
98843     const void *                                       pNext                           = {};
98869       : pNext( pNext_ )
98894       pNext = pNext_;
98930       return std::tie( sType, pNext, maxPipelineRayPayloadSize, maxPipelineRayHitAttributeSize );
98942       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPipelineRayPayloadSize == rhs.maxPipelineRayPayloadSize ) &&
98955     const void *                        pNext                          = {};
98987       : pNext( pNext_ )
99023       : pNext( pNext_ )
99052       pNext = pNext_;
99186                        pNext,
99210       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) &&
99225     const void *                                                           pNext                        = {};
99261       : pNext( pNext_ )
99289       pNext = pNext_;
99348       return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader );
99360       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( generalShader == rhs.generalShader ) &&
99373     const void *                                       pNext              = {};
99405       : pNext( pNext_ )
99435       : pNext( pNext_ )
99461       pNext = pNext_;
99570       return std::tie( sType, pNext, flags, stageCount, pStages, groupCount, pGroups, maxRecursionDepth, layout, basePipelineHandle, basePipelineIndex );
99582       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) &&
99596     const void *                                                    pNext              = {};
99693       : pNext( pNext_ )
99711       : pNext( pNext_ ), swapchain( swapchain_ ), imageIndexCount( static_cast<uint32_t>( imageIndices_.size() ) ), pImageIndices( imageIndices_.data() )
99728       pNext = pNext_;
99782       return std::tie( sType, pNext, swapchain, imageIndexCount, pImageIndices );
99794       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( imageIndexCount == rhs.imageIndexCount ) &&
99807     const void *                        pNext           = {};
99830       : pNext( pNext_ )
99846       : pNext( pNext_ ), attachmentCount( static_cast<uint32_t>( attachments_.size() ) ), pAttachments( attachments_.data() )
99863       pNext = pNext_;
99908       return std::tie( sType, pNext, attachmentCount, pAttachments );
99920       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments );
99932     const void *                            pNext           = {};
99959       : pNext( pNext_ )
99980       : pNext( pNext_ )
100002       pNext = pNext_;
100071       return std::tie( sType, pNext, renderPass, framebuffer, renderArea, clearValueCount, pClearValues );
100083       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( framebuffer == rhs.framebuffer ) &&
100096     const void *                             pNext           = {};
100517       : pNext( pNext_ )
100541       : pNext( pNext_ )
100565       pNext = pNext_;
100668       return std::tie( sType, pNext, flags, attachmentCount, pAttachments, subpassCount, pSubpasses, dependencyCount, pDependencies );
100680       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( attachmentCount == rhs.attachmentCount ) &&
100694     const void *                                        pNext           = {};
100730       : pNext( pNext_ )
100761       : pNext( pNext_ )
100799       pNext = pNext_;
100945                        pNext,
100968       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
100984     const void *                                       pNext                   = {};
101023       : pNext( pNext_ )
101051       pNext = pNext_;
101131       return std::tie( sType, pNext, srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags, viewOffset );
101143       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) &&
101157     const void *                             pNext           = {};
101194       : pNext( pNext_ )
101221       : pNext( pNext_ )
101247       pNext = pNext_;
101375                        pNext,
101396       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( attachmentCount == rhs.attachmentCount ) &&
101411     const void *                                         pNext                   = {};
101440       : pNext( pNext_ )
101464       pNext = pNext_;
101493       return std::tie( sType, pNext, disallowMerging );
101505       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( disallowMerging == rhs.disallowMerging );
101517     const void *                        pNext           = {};
101607       : pNext( pNext_ )
101631       pNext = pNext_;
101661       return std::tie( sType, pNext, pRenderPassFeedback );
101673       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pRenderPassFeedback == rhs.pRenderPassFeedback );
101685     const void *                                              pNext               = {};
101705       : pNext( pNext_ )
101729       pNext = pNext_;
101759       return std::tie( sType, pNext, fragmentDensityMapAttachment );
101771       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment );
101783     const void *                              pNext                        = {};
101804       : pNext( pNext_ )
101821       : pNext( pNext_ ), aspectReferenceCount( static_cast<uint32_t>( aspectReferences_.size() ) ), pAspectReferences( aspectReferences_.data() )
101838       pNext = pNext_;
101887       return std::tie( sType, pNext, aspectReferenceCount, pAspectReferences );
101899       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aspectReferenceCount == rhs.aspectReferenceCount ) &&
101912     const void *                                                 pNext                = {};
101940       : pNext( pNext_ )
101962       : pNext( pNext_ )
101985       pNext = pNext_;
102079       return std::tie( sType, pNext, subpassCount, pViewMasks, dependencyCount, pViewOffsets, correlationMaskCount, pCorrelationMasks );
102091       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassCount == rhs.subpassCount ) && ( pViewMasks == rhs.pViewMasks ) &&
102105     const void *                        pNext                = {};
102224       : pNext( pNext_ )
102244       : pNext( pNext_ )
102265       pNext = pNext_;
102344         sType, pNext, attachmentInitialSampleLocationsCount, pAttachmentInitialSampleLocations, postSubpassSampleLocationsCount, pPostSubpassSampleLocations );
102356       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) &&
102370     const void *                                               pNext                                 = {};
102392       : pNext( pNext_ )
102416       pNext = pNext_;
102445       return std::tie( sType, pNext, stripeArea );
102457       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stripeArea == rhs.stripeArea );
102469     const void *                        pNext      = {};
102490       : pNext( pNext_ )
102506       : pNext( pNext_ ), stripeInfoCount( static_cast<uint32_t>( stripeInfos_.size() ) ), pStripeInfos( stripeInfos_.data() )
102523       pNext = pNext_;
102570       return std::tie( sType, pNext, stripeInfoCount, pStripeInfos );
102582       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stripeInfoCount == rhs.stripeInfoCount ) && ( pStripeInfos == rhs.pStripeInfos );
102594     const void *                                          pNext           = {};
102618       : pNext( pNext_ )
102644       pNext = pNext_;
102696       return std::tie( sType, pNext, semaphore, value, stageMask, deviceIndex );
102708       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( value == rhs.value ) && ( stageMask == rhs.stageMask ) &&
102721     const void *                              pNext       = {};
102747       : pNext( pNext_ )
102763       : pNext( pNext_ )
102782       pNext = pNext_;
102828       return std::tie( sType, pNext, stripeSemaphoreInfoCount, pStripeSemaphoreInfos );
102840       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stripeSemaphoreInfoCount == rhs.stripeSemaphoreInfoCount ) &&
102853     const void *                                      pNext                    = {};
102952       : pNext( pNext_ )
102976       pNext = pNext_;
103006       return std::tie( sType, pNext, pSubpassFeedback );
103018       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSubpassFeedback == rhs.pSubpassFeedback );
103030     const void *                                             pNext            = {};
103051       : pNext( pNext_ )
103075       pNext = pNext_;
103104       return std::tie( sType, pNext, transform );
103116       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform );
103128     void *                                            pNext     = {};
103152       : pNext( pNext_ )
103174       : pNext( pNext_ )
103196       pNext = pNext_;
103266       return std::tie( sType, pNext, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat );
103278       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
103292     const void *                         pNext                   = {};
103323       : pNext( pNext_ )
103354       pNext = pNext_;
103434       return std::tie( sType, pNext, imageView, imageLayout, resolveMode, resolveImageView, resolveImageLayout, loadOp, storeOp, clearValue );
103440     const void *                              pNext              = {};
103471       : pNext( pNext_ )
103496       pNext = pNext_;
103534       return std::tie( sType, pNext, imageView, imageLayout );
103546       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout );
103558     const void *                        pNext       = {};
103582       : pNext( pNext_ )
103609       pNext = pNext_;
103655       return std::tie( sType, pNext, imageView, imageLayout, shadingRateAttachmentTexelSize );
103667       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ) &&
103680     const void *                        pNext                          = {};
103709       : pNext( pNext_ )
103734       : pNext( pNext_ )
103759       pNext = pNext_;
103850       return std::tie( sType, pNext, flags, renderArea, layerCount, viewMask, colorAttachmentCount, pColorAttachments, pDepthAttachment, pStencilAttachment );
103862       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( renderArea == rhs.renderArea ) &&
103876     const void *                                          pNext                = {};
103910       : pNext( pNext_ )
103931       : pNext( pNext_ )
103954       pNext = pNext_;
104030       return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
104042       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) &&
104055     const void *                                pNext          = {};
104084       : pNext( pNext_ )
104109       pNext = pNext_;
104148       return std::tie( sType, pNext, windowExtent, windowCompareMode );
104160       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( windowExtent == rhs.windowExtent ) && ( windowCompareMode == rhs.windowCompareMode );
104172     const void *                                          pNext             = {};
104194       : pNext( pNext_ )
104220       pNext = pNext_;
104259       return std::tie( sType, pNext, components, srgb );
104271       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( components == rhs.components ) && ( srgb == rhs.srgb );
104283     const void *                           pNext      = {};
104303       : pNext( pNext_ )
104327       pNext = pNext_;
104356       return std::tie( sType, pNext, sampler );
104368       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampler == rhs.sampler );
104380     const void *                        pNext   = {};
104415       : pNext( pNext_ )
104451       pNext = pNext_;
104588                        pNext,
104616       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( magFilter == rhs.magFilter ) && ( minFilter == rhs.minFilter ) &&
104632     const void *                             pNext                   = {};
104668       : pNext( pNext_ )
104692       pNext = pNext_;
104722       return std::tie( sType, pNext, cubicWeights );
104734       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicWeights == rhs.cubicWeights );
104746     const void *                                 pNext        = {};
104767       : pNext( pNext_ )
104792       pNext = pNext_;
104831       return std::tie( sType, pNext, customBorderColor, format );
104837     const void *                          pNext             = {};
104859       : pNext( pNext_ )
104883       pNext = pNext_;
104912       return std::tie( sType, pNext, reductionMode );
104924       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reductionMode == rhs.reductionMode );
104936     const void *                               pNext         = {};
104966       : pNext( pNext_ )
104997       pNext = pNext_;
105079       return std::tie( sType, pNext, format, ycbcrModel, ycbcrRange, components, xChromaOffset, yChromaOffset, chromaFilter, forceExplicitReconstruction );
105091       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( ycbcrModel == rhs.ycbcrModel ) &&
105106     const void *                                      pNext                       = {};
105135       : pNext( pNext_ )
105174       return std::tie( sType, pNext, combinedImageSamplerDescriptorCount );
105186       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount );
105198     void *                              pNext                               = {};
105220       : pNext( pNext_ )
105244       pNext = pNext_;
105273       return std::tie( sType, pNext, conversion );
105285       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conversion == rhs.conversion );
105297     const void *                                 pNext      = {};
105320       : pNext( pNext_ )
105346       pNext = pNext_;
105383       return std::tie( sType, pNext, enableYDegamma, enableCbCrDegamma );
105395       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( enableYDegamma == rhs.enableYDegamma ) && ( enableCbCrDegamma == rhs.enableCbCrDegamma );
105407     void *                              pNext             = {};
105438       : pNext( pNext_ )
105496                        pNext,
105517       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) &&
105533     void *                                            pNext                            = {};
105564       : pNext( pNext_ )
105604       return std::tie( sType, pNext, allocationSize, memoryTypeBits );
105616       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeBits == rhs.memoryTypeBits );
105628     void *                              pNext          = {};
105653       : pNext( pNext_ )
105679       pNext = pNext_;
105724       return std::tie( sType, pNext, flags, context, window );
105736       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) && ( window == rhs.window );
105748     const void *                                      pNext   = {};
105770       : pNext( pNext_ )
105793       pNext = pNext_;
105822       return std::tie( sType, pNext, flags );
105834       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
105846     const void *                               pNext = {};
105868       : pNext( pNext_ )
105893       pNext = pNext_;
105931       return std::tie( sType, pNext, semaphore, handleType );
105943       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( handleType == rhs.handleType );
105955     const void *                                              pNext      = {};
105979       : pNext( pNext_ )
106004       pNext = pNext_;
106043       return std::tie( sType, pNext, semaphore, handleType );
106055       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( handleType == rhs.handleType );
106067     const void *                                              pNext      = {};
106092       : pNext( pNext_ )
106117       pNext = pNext_;
106156       return std::tie( sType, pNext, semaphore, handleType );
106168       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( handleType == rhs.handleType );
106180     const void *                                              pNext      = {};
106202       : pNext( pNext_ )
106226       pNext = pNext_;
106261       return std::tie( sType, pNext, semaphore, value );
106273       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( value == rhs.value );
106285     const void *                        pNext     = {};
106309       : pNext( pNext_ )
106334       pNext = pNext_;
106369       return std::tie( sType, pNext, semaphoreType, initialValue );
106381       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphoreType == rhs.semaphoreType ) && ( initialValue == rhs.initialValue );
106393     const void *                        pNext         = {};
106419       : pNext( pNext_ )
106436       : pNext( pNext_ )
106465       pNext = pNext_;
106536       return std::tie( sType, pNext, flags, semaphoreCount, pSemaphores, pValues );
106548       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( semaphoreCount == rhs.semaphoreCount ) &&
106561     const void *                             pNext          = {};
106591       : pNext( pNext_ )
106615       : pNext( pNext_ )
106647       pNext = pNext_;
106733       return std::tie( sType, pNext, stageFlags, layout, firstSet, setCount, pBufferIndices, pOffsets );
106745       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( firstSet == rhs.firstSet ) &&
106758     const void *                             pNext          = {};
106784       : pNext( pNext_ )
106809       pNext = pNext_;
106844       return std::tie( sType, pNext, presentID, marker );
106856       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ) && ( marker == rhs.marker );
106868     const void *                          pNext     = {};
106975       : pNext( pNext_ )
107009       : pNext( pNext_ )
107038       pNext = pNext_;
107179                        pNext,
107200       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
107234       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( nextStage == rhs.nextStage ) &&
107248     const void *                                      pNext                  = {};
107281       : pNext( pNext_ )
107299       : pNext( pNext_ ), flags( flags_ ), codeSize( code_.size() * 4 ), pCode( code_.data() )
107316       pNext = pNext_;
107370       return std::tie( sType, pNext, flags, codeSize, pCode );
107382       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode );
107394     const void *                                  pNext    = {};
107417       : pNext( pNext_ )
107460       return std::tie( sType, pNext, identifierSize, identifier );
107472       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && ( identifier == rhs.identifier );
107484     void *                                                                                  pNext          = {};
107505       : pNext( pNext_ )
107529       pNext = pNext_;
107559       return std::tie( sType, pNext, validationCache );
107571       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( validationCache == rhs.validationCache );
107583     const void *                             pNext           = {};
107782       : pNext( pNext_ )
107821       return std::tie( sType, pNext, sharedPresentSupportedUsageFlags );
107833       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags );
107845     void *                                pNext                            = {};
107941       : pNext( pNext_ )
107980       return std::tie( sType, pNext, properties );
107992       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties );
108004     void *                                            pNext      = {};
108114       : pNext( pNext_ )
108153       return std::tie( sType, pNext, memoryRequirements );
108165       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements );
108177     void *                                              pNext              = {};
108201       : pNext( pNext_ )
108226       pNext = pNext_;
108265       return std::tie( sType, pNext, flags, streamDescriptor );
108274       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
108287       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
108298     const void *                                                pNext            = {};
108422       : pNext( pNext_ )
108443       : pNext( pNext_ )
108475       pNext = pNext_;
108589         sType, pNext, waitSemaphoreCount, pWaitSemaphores, pWaitDstStageMask, commandBufferCount, pCommandBuffers, signalSemaphoreCount, pSignalSemaphores );
108601       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
108616     const void *                                     pNext                = {};
108648       : pNext( pNext_ )
108669       : pNext( pNext_ )
108693       pNext = pNext_;
108799                        pNext,
108818       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( waitSemaphoreInfoCount == rhs.waitSemaphoreInfoCount ) &&
108833     const void *                                          pNext                    = {};
108861       : pNext( pNext_ )
108882       pNext = pNext_;
108911       return std::tie( sType, pNext, contents );
108923       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( contents == rhs.contents );
108935     const void *                          pNext    = {};
108960       : pNext( pNext_ )
108986       pNext = pNext_;
109034       return std::tie( sType, pNext, depthResolveMode, stencilResolveMode, pDepthStencilResolveAttachment );
109046       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthResolveMode == rhs.depthResolveMode ) &&
109059     const void *                                       pNext                          = {};
109081     VULKAN_HPP_CONSTEXPR SubpassEndInfo( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) {}
109099       pNext = pNext_;
109122       return std::tie( sType, pNext );
109134       return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
109146     const void *                        pNext = {};
109168       : pNext( pNext_ )
109184       : pNext( pNext_ )
109203       pNext = pNext_;
109250       return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets );
109262       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityOffsetCount == rhs.fragmentDensityOffsetCount ) &&
109275     const void *                           pNext                      = {};
109295       : pNext( pNext_ )
109334       return std::tie( sType, pNext, optimal );
109346       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimal == rhs.optimal );
109358     void *                              pNext   = {};
109379       : pNext( pNext_ )
109419       return std::tie( sType, pNext, renderPass, subpass );
109431       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( subpass == rhs.subpass );
109443     void *                              pNext      = {};
109463       : pNext( pNext_ )
109502       return std::tie( sType, pNext, size );
109514       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( size == rhs.size );
109526     void *                              pNext = {};
109545       : pNext( pNext_ )
109584       return std::tie( sType, pNext, subresourceLayout );
109596       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subresourceLayout == rhs.subresourceLayout );
109608     void *                                  pNext             = {};
109641       : pNext( pNext_ )
109703                        pNext,
109726       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) &&
109742     void *                                            pNext                    = {};
109891       : pNext( pNext_ )
109930       return std::tie( sType, pNext, surfaceCapabilities );
109942       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCapabilities == rhs.surfaceCapabilities );
109954     void *                                       pNext               = {};
109975       : pNext( pNext_ )
109999       pNext = pNext_;
110029       return std::tie( sType, pNext, fullScreenExclusiveSupported );
110041       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported );
110053     void *                              pNext                        = {};
110074       : pNext( pNext_ )
110098       pNext = pNext_;
110128       return std::tie( sType, pNext, presentBarrierSupported );
110140       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentBarrierSupported == rhs.presentBarrierSupported );
110152     void *                              pNext                   = {};
110242       : pNext( pNext_ )
110278       return std::tie( sType, pNext, surfaceFormat );
110290       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceFormat == rhs.surfaceFormat );
110302     void *                                 pNext         = {};
110324       : pNext( pNext_ )
110348       pNext = pNext_;
110378       return std::tie( sType, pNext, fullScreenExclusive );
110390       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusive == rhs.fullScreenExclusive );
110402     void *                                       pNext               = {};
110423       : pNext( pNext_ )
110447       pNext = pNext_;
110476       return std::tie( sType, pNext, hmonitor );
110488       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hmonitor == rhs.hmonitor );
110500     const void *                        pNext    = {};
110522       : pNext( pNext_ )
110538       : pNext( pNext_ ), presentModeCount( static_cast<uint32_t>( presentModes_.size() ) ), pPresentModes( presentModes_.data() )
110555       pNext = pNext_;
110600       return std::tie( sType, pNext, presentModeCount, pPresentModes );
110612       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes );
110624     void *                                 pNext            = {};
110645       : pNext( pNext_ )
110669       pNext = pNext_;
110698       return std::tie( sType, pNext, presentMode );
110710       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMode == rhs.presentMode );
110722     void *                               pNext       = {};
110746       : pNext( pNext_ )
110774       pNext = pNext_;
110838       return std::tie( sType, pNext, supportedPresentScaling, supportedPresentGravityX, supportedPresentGravityY, minScaledImageExtent, maxScaledImageExtent );
110850       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedPresentScaling == rhs.supportedPresentScaling ) &&
110864     void *                                       pNext                    = {};
110888       : pNext( pNext_ )
110912       pNext = pNext_;
110941       return std::tie( sType, pNext, supportsProtected );
110953       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsProtected == rhs.supportsProtected );
110965     const void *                        pNext             = {};
110985       : pNext( pNext_ )
111009       pNext = pNext_;
111039       return std::tie( sType, pNext, surfaceCounters );
111051       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCounters == rhs.surfaceCounters );
111063     const void *                                 pNext           = {};
111099       : pNext( pNext_ )
111143       : pNext( pNext_ )
111176       pNext = pNext_;
111323                        pNext,
111351       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( surface == rhs.surface ) &&
111368     const void *                                      pNext                 = {};
111403       : pNext( pNext_ )
111427       pNext = pNext_;
111457       return std::tie( sType, pNext, localDimmingEnable );
111469       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingEnable == rhs.localDimmingEnable );
111481     const void *                        pNext              = {};
111500       : pNext( pNext_ )
111524       pNext = pNext_;
111553       return std::tie( sType, pNext, latencyModeEnable );
111565       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( latencyModeEnable == rhs.latencyModeEnable );
111577     const void *                        pNext             = {};
111597       : pNext( pNext_ )
111621       pNext = pNext_;
111651       return std::tie( sType, pNext, presentBarrierEnable );
111663       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentBarrierEnable == rhs.presentBarrierEnable );
111675     void *                              pNext                = {};
111696       : pNext( pNext_ )
111712       : pNext( pNext_ ), swapchainCount( static_cast<uint32_t>( fences_.size() ) ), pFences( fences_.data() )
111729       pNext = pNext_;
111774       return std::tie( sType, pNext, swapchainCount, pFences );
111786       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pFences == rhs.pFences );
111798     const void *                        pNext          = {};
111820       : pNext( pNext_ )
111836       : pNext( pNext_ ), swapchainCount( static_cast<uint32_t>( presentModes_.size() ) ), pPresentModes( presentModes_.data() )
111853       pNext = pNext_;
111898       return std::tie( sType, pNext, swapchainCount, pPresentModes );
111910       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pPresentModes == rhs.pPresentModes );
111922     const void *                                 pNext          = {};
111944       : pNext( pNext_ )
111960       : pNext( pNext_ ), presentModeCount( static_cast<uint32_t>( presentModes_.size() ) ), pPresentModes( presentModes_.data() )
111977       pNext = pNext_;
112023       return std::tie( sType, pNext, presentModeCount, pPresentModes );
112035       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes );
112047     const void *                                 pNext            = {};
112070       : pNext( pNext_ )
112096       pNext = pNext_;
112144       return std::tie( sType, pNext, scalingBehavior, presentGravityX, presentGravityY );
112156       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalingBehavior == rhs.scalingBehavior ) && ( presentGravityX == rhs.presentGravityX ) &&
112169     const void *                                 pNext           = {};
112191       : pNext( pNext_ )
112230       return std::tie( sType, pNext, supportsTextureGatherLODBiasAMD );
112242       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD );
112254     void *                              pNext                           = {};
112276       : pNext( pNext_ )
112299       pNext = pNext_;
112344       return std::tie( sType, pNext, tileSize, apronSize, origin );
112356       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileSize == rhs.tileSize ) && ( apronSize == rhs.apronSize ) && ( origin == rhs.origin );
112368     void *                              pNext     = {};
112393       : pNext( pNext_ )
112412       : pNext( pNext_ )
112433       pNext = pNext_;
112505       return std::tie( sType, pNext, waitSemaphoreValueCount, pWaitSemaphoreValues, signalSemaphoreValueCount, pSignalSemaphoreValues );
112517       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount ) &&
112531     const void *                        pNext                     = {};
112896       : pNext( pNext_ )
112915       : pNext( pNext_ ), flags( flags_ ), initialDataSize( initialData_.size() * sizeof( T ) ), pInitialData( initialData_.data() )
112932       pNext = pNext_;
112987       return std::tie( sType, pNext, flags, initialDataSize, pInitialData );
112999       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( initialDataSize == rhs.initialDataSize ) &&
113012     const void *                                        pNext           = {};
113037       : pNext( pNext_ )
113057       : pNext( pNext_ )
113078       pNext = pNext_;
113154       return std::tie( sType, pNext, enabledValidationFeatureCount, pEnabledValidationFeatures, disabledValidationFeatureCount, pDisabledValidationFeatures );
113166       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) &&
113180     const void *                                              pNext                          = {};
113204       : pNext( pNext_ )
113217       : pNext( pNext_ )
113236       pNext = pNext_;
113282       return std::tie( sType, pNext, disabledValidationCheckCount, pDisabledValidationChecks );
113294       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) &&
113307     const void *                                     pNext                        = {};
113331       : pNext( pNext_ )
113358       pNext = pNext_;
113410       return std::tie( sType, pNext, location, binding, format, offset );
113422       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) &&
113435     void *                              pNext    = {};
113461       : pNext( pNext_ )
113488       pNext = pNext_;
113540       return std::tie( sType, pNext, binding, stride, inputRate, divisor );
113552       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ) &&
113565     void *                                pNext     = {};
113589       : pNext( pNext_ )
113614       pNext = pNext_;
113649       return std::tie( sType, pNext, flags, window );
113661       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window );
113673     const void *                                 pNext  = {};
113698       : pNext( pNext_ )
113725       pNext = pNext_;
113777       return std::tie( sType, pNext, codedOffset, codedExtent, baseArrayLayer, imageViewBinding );
113789       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( codedOffset == rhs.codedOffset ) && ( codedExtent == rhs.codedExtent ) &&
113802     const void *                        pNext            = {};
113826       : pNext( pNext_ )
113851       pNext = pNext_;
113890       return std::tie( sType, pNext, slotIndex, pPictureResource );
113902       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && ( pPictureResource == rhs.pPictureResource );
113914     const void *                                              pNext            = {};
113939       : pNext( pNext_ )
113961       : pNext( pNext_ )
113983       pNext = pNext_;
114054       return std::tie( sType, pNext, flags, videoSession, videoSessionParameters, referenceSlotCount, pReferenceSlots );
114066       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( videoSession == rhs.videoSession ) &&
114080     const void *                                            pNext                  = {};
114112       : pNext( pNext_ )
114170                        pNext,
114191       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
114207     void *                                        pNext                             = {};
114235       : pNext( pNext_ )
114259       pNext = pNext_;
114288       return std::tie( sType, pNext, flags );
114300       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
114312     const void *                                     pNext = {};
114332       : pNext( pNext_ )
114371       return std::tie( sType, pNext, flags );
114383       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
114395     void *                                              pNext = {};
114416       : pNext( pNext_ )
114456       return std::tie( sType, pNext, maxLevelIdc, fieldOffsetGranularity );
114465       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
114478       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ) &&
114489     void *                              pNext                  = {};
114510       : pNext( pNext_ )
114534       pNext = pNext_;
114564       return std::tie( sType, pNext, pStdReferenceInfo );
114576       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
114588     const void *                            pNext             = {};
114610       : pNext( pNext_ )
114628       : pNext( pNext_ ), pStdPictureInfo( pStdPictureInfo_ ), sliceCount( static_cast<uint32_t>( sliceOffsets_.size() ) ), pSliceOffsets( sliceOffsets_.data() )
114645       pNext = pNext_;
114699       return std::tie( sType, pNext, pStdPictureInfo, sliceCount, pSliceOffsets );
114711       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( sliceCount == rhs.sliceCount ) &&
114724     const void *                          pNext           = {};
114748       : pNext( pNext_ )
114773       pNext = pNext_;
114812       return std::tie( sType, pNext, stdProfileIdc, pictureLayout );
114821       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
114834       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) &&
114845     const void *                                                  pNext         = {};
114869       : pNext( pNext_ )
114888       : pNext( pNext_ )
114909       pNext = pNext_;
114981       return std::tie( sType, pNext, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs );
114993       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) &&
115006     const void *                             pNext       = {};
115032       : pNext( pNext_ )
115059       pNext = pNext_;
115105       return std::tie( sType, pNext, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo );
115117       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && ( maxStdPPSCount == rhs.maxStdPPSCount ) &&
115130     const void *                                                             pNext              = {};
115151       : pNext( pNext_ )
115190       return std::tie( sType, pNext, maxLevelIdc );
115199       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
115210       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 );
115220     void *                              pNext       = {};
115240       : pNext( pNext_ )
115264       pNext = pNext_;
115294       return std::tie( sType, pNext, pStdReferenceInfo );
115306       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
115318     const void *                            pNext             = {};
115340       : pNext( pNext_ )
115358       : pNext( pNext_ )
115378       pNext = pNext_;
115433       return std::tie( sType, pNext, pStdPictureInfo, sliceSegmentCount, pSliceSegmentOffsets );
115445       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( sliceSegmentCount == rhs.sliceSegmentCount ) &&
115458     const void *                          pNext                = {};
115479       : pNext( pNext_ )
115503       pNext = pNext_;
115532       return std::tie( sType, pNext, stdProfileIdc );
115541       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
115552       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
115562     const void *                        pNext         = {};
115587       : pNext( pNext_ )
115609       : pNext( pNext_ )
115632       pNext = pNext_;
115728       return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs );
115740       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) &&
115753     const void *                             pNext       = {};
115782       : pNext( pNext_ )
115810       pNext = pNext_;
115863       return std::tie( sType, pNext, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo );
115875       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) &&
115888     const void *                                                             pNext              = {};
115918       : pNext( pNext_ )
115943       : pNext( pNext_ )
115968       pNext = pNext_;
116062         sType, pNext, flags, srcBuffer, srcBufferOffset, srcBufferRange, dstPictureResource, pSetupReferenceSlot, referenceSlotCount, pReferenceSlots );
116074       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcBuffer == rhs.srcBuffer ) &&
116089     const void *                                            pNext               = {};
116116       : pNext( pNext_ )
116140       pNext = pNext_;
116169       return std::tie( sType, pNext, videoUsageHints );
116181       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoUsageHints == rhs.videoUsageHints );
116193     const void *                                   pNext           = {};
116219       : pNext( pNext_ )
116273                        pNext,
116292       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlModes == rhs.rateControlModes ) &&
116306     void *                                                   pNext                         = {};
116344       : pNext( pNext_ )
116410                        pNext,
116432       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
116467       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
116483     void *                                                  pNext                            = {};
116515       : pNext( pNext_ )
116539       pNext = pNext_;
116569       return std::tie( sType, pNext, pStdReferenceInfo );
116581       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
116593     const void *                            pNext             = {};
116710       : pNext( pNext_ )
116737       pNext = pNext_;
116790       return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB );
116802       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) &&
116815     const void *                        pNext                 = {};
116839       : pNext( pNext_ )
116864       pNext = pNext_;
116899       return std::tie( sType, pNext, constantQp, pStdSliceHeader );
116911       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceHeader == rhs.pStdSliceHeader );
116923     const void *                          pNext           = {};
116947       : pNext( pNext_ )
116968       : pNext( pNext_ )
116989       pNext = pNext_;
117052       return std::tie( sType, pNext, naluSliceEntryCount, pNaluSliceEntries, pStdPictureInfo, generatePrefixNalu );
117064       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceEntryCount == rhs.naluSliceEntryCount ) &&
117077     const void *                                                  pNext               = {};
117099       : pNext( pNext_ )
117123       pNext = pNext_;
117152       return std::tie( sType, pNext, stdProfileIdc );
117161       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
117172       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 );
117182     const void *                        pNext         = {};
117304       : pNext( pNext_ )
117362                        pNext,
117383       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) &&
117400     void *                                                   pNext                             = {};
117432       : pNext( pNext_ )
117460       pNext = pNext_;
117519       return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, temporalLayerCount );
117531       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) &&
117544     const void *                                             pNext                  = {};
117573       : pNext( pNext_ )
117602       pNext = pNext_;
117669       return std::tie( sType, pNext, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize );
117681       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
117694     const void *                                      pNext           = {};
117720       : pNext( pNext_ )
117745       pNext = pNext_;
117780       return std::tie( sType, pNext, useMaxLevelIdc, maxLevelIdc );
117789       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
117802       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) &&
117813     const void *                        pNext          = {};
117837       : pNext( pNext_ )
117856       : pNext( pNext_ )
117877       pNext = pNext_;
117949       return std::tie( sType, pNext, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs );
117961       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) &&
117974     const void *                             pNext       = {};
118000       : pNext( pNext_ )
118027       pNext = pNext_;
118073       return std::tie( sType, pNext, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo );
118085       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && ( maxStdPPSCount == rhs.maxStdPPSCount ) &&
118098     const void *                                                             pNext              = {};
118121       : pNext( pNext_ )
118162       return std::tie( sType, pNext, hasStdSPSOverrides, hasStdPPSOverrides );
118174       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdSPSOverrides == rhs.hasStdSPSOverrides ) &&
118187     void *                              pNext              = {};
118211       : pNext( pNext_ )
118238       pNext = pNext_;
118290       return std::tie( sType, pNext, writeStdSPS, writeStdPPS, stdSPSId, stdPPSId );
118302       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdSPS == rhs.writeStdSPS ) && ( writeStdPPS == rhs.writeStdPPS ) &&
118315     const void *                        pNext       = {};
118353       : pNext( pNext_ )
118425                        pNext,
118450       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
118491       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
118508     void *                                                          pNext                               = {};
118543       : pNext( pNext_ )
118567       pNext = pNext_;
118597       return std::tie( sType, pNext, pStdReferenceInfo );
118609       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
118621     const void *                            pNext             = {};
118738       : pNext( pNext_ )
118765       pNext = pNext_;
118818       return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB );
118830       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) &&
118843     const void *                        pNext                 = {};
118867       : pNext( pNext_ )
118892       pNext = pNext_;
118928       return std::tie( sType, pNext, constantQp, pStdSliceSegmentHeader );
118940       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceSegmentHeader == rhs.pStdSliceSegmentHeader );
118952     const void *                                 pNext                  = {};
118975       : pNext( pNext_ )
118994       : pNext( pNext_ )
119014       pNext = pNext_;
119071       return std::tie( sType, pNext, naluSliceSegmentEntryCount, pNaluSliceSegmentEntries, pStdPictureInfo );
119083       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceSegmentEntryCount == rhs.naluSliceSegmentEntryCount ) &&
119096     const void *                                                         pNext                      = {};
119117       : pNext( pNext_ )
119141       pNext = pNext_;
119170       return std::tie( sType, pNext, stdProfileIdc );
119179       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
119190       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
119200     const void *                        pNext         = {};
119321       : pNext( pNext_ )
119377                        pNext,
119397       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) &&
119413     void *                                                   pNext                           = {};
119444       : pNext( pNext_ )
119472       pNext = pNext_;
119531       return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, subLayerCount );
119543       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) &&
119556     const void *                                             pNext                  = {};
119585       : pNext( pNext_ )
119614       pNext = pNext_;
119681       return std::tie( sType, pNext, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize );
119693       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
119706     const void *                                      pNext           = {};
119732       : pNext( pNext_ )
119757       pNext = pNext_;
119792       return std::tie( sType, pNext, useMaxLevelIdc, maxLevelIdc );
119801       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
119814       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) &&
119825     const void *                        pNext          = {};
119851       : pNext( pNext_ )
119873       : pNext( pNext_ )
119896       pNext = pNext_;
119992       return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs );
120004       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) &&
120017     const void *                             pNext       = {};
120046       : pNext( pNext_ )
120074       pNext = pNext_;
120127       return std::tie( sType, pNext, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo );
120139       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) &&
120152     const void *                                                             pNext              = {};
120177       : pNext( pNext_ )
120223       return std::tie( sType, pNext, hasStdVPSOverrides, hasStdSPSOverrides, hasStdPPSOverrides );
120235       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdVPSOverrides == rhs.hasStdVPSOverrides ) &&
120248     void *                              pNext              = {};
120275       : pNext( pNext_ )
120304       pNext = pNext_;
120370       return std::tie( sType, pNext, writeStdVPS, writeStdSPS, writeStdPPS, stdVPSId, stdSPSId, stdPPSId );
120382       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdVPS == rhs.writeStdVPS ) && ( writeStdSPS == rhs.writeStdSPS ) &&
120395     const void *                        pNext       = {};
120428       : pNext( pNext_ )
120455       : pNext( pNext_ )
120481       pNext = pNext_;
120582                        pNext,
120603       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dstBuffer == rhs.dstBuffer ) &&
120618     const void *                                            pNext                           = {};
120645       : pNext( pNext_ )
120669       pNext = pNext_;
120698       return std::tie( sType, pNext, qualityLevel );
120710       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( qualityLevel == rhs.qualityLevel );
120722     const void *                        pNext        = {};
120744       : pNext( pNext_ )
120785       return std::tie( sType, pNext, preferredRateControlMode, preferredRateControlLayerCount );
120797       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlMode == rhs.preferredRateControlMode ) &&
120810     void *                                                      pNext = {};
120835       : pNext( pNext_ )
120862       pNext = pNext_;
120909       return std::tie( sType, pNext, averageBitrate, maxBitrate, frameRateNumerator, frameRateDenominator );
120921       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) && ( maxBitrate == rhs.maxBitrate ) &&
120934     const void *                        pNext                = {};
120963       : pNext( pNext_ )
120988       : pNext( pNext_ )
121011       pNext = pNext_;
121089       return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayers, virtualBufferSizeInMs, initialVirtualBufferSizeInMs );
121101       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlMode == rhs.rateControlMode ) &&
121115     const void *                                                     pNext           = {};
121140       : pNext( pNext_ )
121179       return std::tie( sType, pNext, hasOverrides );
121191       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasOverrides == rhs.hasOverrides );
121203     void *                              pNext        = {};
121223       : pNext( pNext_ )
121247       pNext = pNext_;
121277       return std::tie( sType, pNext, videoSessionParameters );
121289       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoSessionParameters == rhs.videoSessionParameters );
121301     const void *                                    pNext                  = {};
121324       : pNext( pNext_ )
121350       pNext = pNext_;
121396       return std::tie( sType, pNext, videoUsageHints, videoContentHints, tuningMode );
121408       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoUsageHints == rhs.videoUsageHints ) && ( videoContentHints == rhs.videoContentHints ) &&
121421     const void *                                     pNext             = {};
121442       : pNext( pNext_ )
121466       pNext = pNext_;
121495       return std::tie( sType, pNext, flags );
121507       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
121519     const void *                                 pNext = {};
121544       : pNext( pNext_ )
121595       return std::tie( sType, pNext, format, componentMapping, imageCreateFlags, imageType, imageTiling, imageUsageFlags );
121607       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( componentMapping == rhs.componentMapping ) &&
121621     void *                                 pNext            = {};
121648       : pNext( pNext_ )
121674       pNext = pNext_;
121715       return std::tie( sType, pNext, queryPool, firstQuery, queryCount );
121727       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queryPool == rhs.queryPool ) && ( firstQuery == rhs.firstQuery ) &&
121740     const void *                        pNext      = {};
121763       : pNext( pNext_ )
121779       : pNext( pNext_ ), profileCount( static_cast<uint32_t>( profiles_.size() ) ), pProfiles( profiles_.data() )
121796       pNext = pNext_;
121841       return std::tie( sType, pNext, profileCount, pProfiles );
121853       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( profileCount == rhs.profileCount ) && ( pProfiles == rhs.pProfiles );
121865     const void *                                      pNext        = {};
121894       : pNext( pNext_ )
121926       pNext = pNext_;
122015                        pNext,
122036       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( flags == rhs.flags ) &&
122051     const void *                                      pNext                      = {};
122080       : pNext( pNext_ )
122120       return std::tie( sType, pNext, memoryBindIndex, memoryRequirements );
122132       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && ( memoryRequirements == rhs.memoryRequirements );
122144     void *                                   pNext              = {};
122167       : pNext( pNext_ )
122193       pNext = pNext_;
122240       return std::tie( sType, pNext, flags, videoSessionParametersTemplate, videoSession );
122252       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
122265     const void *                                               pNext                          = {};
122286       : pNext( pNext_ )
122310       pNext = pNext_;
122339       return std::tie( sType, pNext, updateSequenceCount );
122351       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( updateSequenceCount == rhs.updateSequenceCount );
122363     const void *                        pNext               = {};
122386       : pNext( pNext_ )
122412       pNext = pNext_;
122457       return std::tie( sType, pNext, flags, display, surface );
122469       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( display == rhs.display ) && ( surface == rhs.surface );
122481     const void *                                       pNext   = {};
122511       : pNext( pNext_ )
122536       : pNext( pNext_ )
122591       pNext = pNext_;
122716       return std::tie( sType, pNext, acquireCount, pAcquireSyncs, pAcquireKeys, pAcquireTimeouts, releaseCount, pReleaseSyncs, pReleaseKeys );
122728       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && ( pAcquireSyncs == rhs.pAcquireSyncs ) &&
122742     const void *                               pNext            = {};
122776       : pNext( pNext_ )
122801       : pNext( pNext_ )
122858       pNext = pNext_;
122984       return std::tie( sType, pNext, acquireCount, pAcquireSyncs, pAcquireKeys, pAcquireTimeoutMilliseconds, releaseCount, pReleaseSyncs, pReleaseKeys );
122996       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && ( pAcquireSyncs == rhs.pAcquireSyncs ) &&
123010     const void *                               pNext                       = {};
123040       : pNext( pNext_ )
123066       pNext = pNext_;
123111       return std::tie( sType, pNext, flags, hinstance, hwnd );
123123       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( hinstance == rhs.hinstance ) && ( hwnd == rhs.hwnd );
123135     const void *                                     pNext     = {};
123159       : pNext( pNext_ )
123176       : pNext( pNext_ )
123195       pNext = pNext_;
123243       return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures );
123255       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureCount == rhs.accelerationStructureCount ) &&
123268     const void *                                           pNext                      = {};
123290       : pNext( pNext_ )
123307       : pNext( pNext_ )
123326       pNext = pNext_;
123374       return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures );
123386       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureCount == rhs.accelerationStructureCount ) &&
123399     const void *                                          pNext                      = {};
123420       : pNext( pNext_ )
123436       : pNext( pNext_ ), dataSize( static_cast<uint32_t>( data_.size() * sizeof( T ) ) ), pData( data_.data() )
123453       pNext = pNext_;
123498       return std::tie( sType, pNext, dataSize, pData );
123510       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
123522     const void *                        pNext    = {};
123548       : pNext( pNext_ )
123574       pNext = pNext_;
123619       return std::tie( sType, pNext, flags, connection, window );
123628       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
123643       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( connection == rhs.connection ) &&
123654     const void *                                   pNext      = {};
123680       : pNext( pNext_ )
123706       pNext = pNext_;
123751       return std::tie( sType, pNext, flags, dpy, window );
123760       if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
123775       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dpy == rhs.dpy ) &&
123786     const void *                                    pNext  = {};