text: // Copyright (c) 2015-2019 The Khronos Group Inc.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  //     http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  // 
  // ---- Exceptions to the Apache 2.0 License: ----
  // 
  // As an exception, if you use this Software to generate code and portions of
  // this Software are embedded into the generated code as a result, you may
  // redistribute such product without providing attribution as would otherwise
  // be required by Sections 4(a), 4(b) and 4(d) of the License.
  // 
  // In addition, if you combine or link code generated by this Software with
  // software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1
  // ("`Combined Software`") and if a court of competent jurisdiction determines
  // that the patent provision (Section 3), the indemnity provision (Section 9)
  // or other Section of the License conflicts with the conditions of the
  // applicable GPL or LGPL license, you may retroactively and prospectively
  // choose to deem waived or otherwise exclude such Section(s) of the License,
  // but only in their entirety and only with respect to the Combined Software.
  //     
  
  // This header is generated from the Khronos Vulkan XML API Registry.
  
  #pragma once
  
  #include "../handles.hpp"
  #include "VkAcquire.hpp"
  #include "VkAcceleration.hpp"
  #include "VkApplication.hpp"
  #include "VkAllocation.hpp"
  #include "VkExternal.hpp"
  #include "VkBind.hpp"
  #include "VkCooperative.hpp"
  #include "VkAndroid.hpp"
  #include "VkImport.hpp"
  #include "VkImage.hpp"
  #include "VkDescriptor.hpp"
  #include "VkBase.hpp"
  #include "VkAttachment.hpp"
  #include "VkBuffer.hpp"
  #include "VkFramebuffer.hpp"
  #include "VkCalibrated.hpp"
  #include "VkDevice.hpp"
  #include "VkCheckpoint.hpp"
  #include "VkConformance.hpp"
  #include "VkClear.hpp"
  #include "VkCmd.hpp"
  #include "VkExtension.hpp"
  #include "VkCoarse.hpp"
  #include "VkCommand.hpp"
  #include "VkFormat.hpp"
  #include "VkComponent.hpp"
  #include "VkCopy.hpp"
  #include "VkCompute.hpp"
  #include "VkConditional.hpp"
  #include "VkD3D.hpp"
  #include "VkDebug.hpp"
  #include "VkFence.hpp"
  #include "VkDedicated.hpp"
  #include "VkDraw.hpp"
  #include "VkDispatch.hpp"
  #include "VkDisplay.hpp"
  #include "VkDrm.hpp"
  #include "VkEvent.hpp"
  #include "VkExport.hpp"
  #include "VkExtent.hpp"
  #include "VkFilter.hpp"
  #include "VkGeometry.hpp"
  #include "VkGraphics.hpp"
  #include "VkHdr.hpp"
  #include "VkHeadless.hpp"
  #include "VkI.hpp"
  #include "VkIndirect.hpp"
  
  namespace VULKAN_HPP_NAMESPACE
  {
    struct IndirectCommandsLayoutTokenNVX
    {
      VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNVX( VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNVX tokenType_ = VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNVX::ePipeline,
                                                           uint32_t bindingUnit_ = {},
                                                           uint32_t dynamicCount_ = {},
                                                           uint32_t divisor_ = {} ) VULKAN_HPP_NOEXCEPT
        : tokenType( tokenType_ )
        , bindingUnit( bindingUnit_ )
        , dynamicCount( dynamicCount_ )
        , divisor( divisor_ )
      {}
  
      VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNVX( IndirectCommandsLayoutTokenNVX const& rhs ) VULKAN_HPP_NOEXCEPT
        : tokenType( rhs.tokenType )
        , bindingUnit( rhs.bindingUnit )
        , dynamicCount( rhs.dynamicCount )
        , divisor( rhs.divisor )
      {}
  
      IndirectCommandsLayoutTokenNVX & operator=( IndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
      {
        memcpy( static_cast<void*>(this), &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
        return *this;
      }
  
      IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
      {
        *this = rhs;
      }
  
      IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
      {
        *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNVX const *>(&rhs);
        return *this;
      }
  
      IndirectCommandsLayoutTokenNVX & setTokenType( VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNVX tokenType_ ) VULKAN_HPP_NOEXCEPT
      {
        tokenType = tokenType_;
        return *this;
      }
  
      IndirectCommandsLayoutTokenNVX & setBindingUnit( uint32_t bindingUnit_ ) VULKAN_HPP_NOEXCEPT
      {
        bindingUnit = bindingUnit_;
        return *this;
      }
  
      IndirectCommandsLayoutTokenNVX & setDynamicCount( uint32_t dynamicCount_ ) VULKAN_HPP_NOEXCEPT
      {
        dynamicCount = dynamicCount_;
        return *this;
      }
  
      IndirectCommandsLayoutTokenNVX & setDivisor( uint32_t divisor_ ) VULKAN_HPP_NOEXCEPT
      {
        divisor = divisor_;
        return *this;
      }
  
      operator VkIndirectCommandsLayoutTokenNVX const&() const VULKAN_HPP_NOEXCEPT
      {
        return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>( this );
      }
  
      operator VkIndirectCommandsLayoutTokenNVX &() VULKAN_HPP_NOEXCEPT
      {
        return *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>( this );
      }
  
  #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
      auto operator<=>( IndirectCommandsLayoutTokenNVX const& ) const = default;
  #else
      bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const VULKAN_HPP_NOEXCEPT
      {
        return ( tokenType == rhs.tokenType )
            && ( bindingUnit == rhs.bindingUnit )
            && ( dynamicCount == rhs.dynamicCount )
            && ( divisor == rhs.divisor );
      }
  
      bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const VULKAN_HPP_NOEXCEPT
      {
        return !operator==( rhs );
      }
  #endif
  
    public:
      VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNVX tokenType = VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNVX::ePipeline;
      uint32_t bindingUnit = {};
      uint32_t dynamicCount = {};
      uint32_t divisor = {};
    };
    static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
    static_assert( std::is_standard_layout<IndirectCommandsLayoutTokenNVX>::value, "struct wrapper is not a standard layout!" );
  
    struct IndirectCommandsLayoutCreateInfoNVX
    {
      VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics,
                                                                VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNVX flags_ = {},
                                                                uint32_t tokenCount_ = {},
                                                                const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNVX* pTokens_ = {} ) VULKAN_HPP_NOEXCEPT
        : pipelineBindPoint( pipelineBindPoint_ )
        , flags( flags_ )
        , tokenCount( tokenCount_ )
        , pTokens( pTokens_ )
      {}
  
      VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( IndirectCommandsLayoutCreateInfoNVX const& rhs ) VULKAN_HPP_NOEXCEPT
        : pNext( rhs.pNext )
        , pipelineBindPoint( rhs.pipelineBindPoint )
        , flags( rhs.flags )
        , tokenCount( rhs.tokenCount )
        , pTokens( rhs.pTokens )
      {}
  
      IndirectCommandsLayoutCreateInfoNVX & operator=( IndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
      {
        memcpy( &pNext, &rhs.pNext, sizeof( IndirectCommandsLayoutCreateInfoNVX ) - offsetof( IndirectCommandsLayoutCreateInfoNVX, pNext ) );
        return *this;
      }
  
      IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
      {
        *this = rhs;
      }
  
      IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
      {
        *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNVX const *>(&rhs);
        return *this;
      }
  
      IndirectCommandsLayoutCreateInfoNVX & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
      {
        pNext = pNext_;
        return *this;
      }
  
      IndirectCommandsLayoutCreateInfoNVX & setPipelineBindPoint( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ ) VULKAN_HPP_NOEXCEPT
      {
        pipelineBindPoint = pipelineBindPoint_;
        return *this;
      }
  
      IndirectCommandsLayoutCreateInfoNVX & setFlags( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNVX flags_ ) VULKAN_HPP_NOEXCEPT
      {
        flags = flags_;
        return *this;
      }
  
      IndirectCommandsLayoutCreateInfoNVX & setTokenCount( uint32_t tokenCount_ ) VULKAN_HPP_NOEXCEPT
      {
        tokenCount = tokenCount_;
        return *this;
      }
  
      IndirectCommandsLayoutCreateInfoNVX & setPTokens( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNVX* pTokens_ ) VULKAN_HPP_NOEXCEPT
      {
        pTokens = pTokens_;
        return *this;
      }
  
      operator VkIndirectCommandsLayoutCreateInfoNVX const&() const VULKAN_HPP_NOEXCEPT
      {
        return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( this );
      }
  
      operator VkIndirectCommandsLayoutCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
      {
        return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>( this );
      }
  
  #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
      auto operator<=>( IndirectCommandsLayoutCreateInfoNVX const& ) const = default;
  #else
      bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const VULKAN_HPP_NOEXCEPT
      {
        return ( sType == rhs.sType )
            && ( pNext == rhs.pNext )
            && ( pipelineBindPoint == rhs.pipelineBindPoint )
            && ( flags == rhs.flags )
            && ( tokenCount == rhs.tokenCount )
            && ( pTokens == rhs.pTokens );
      }
  
      bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const VULKAN_HPP_NOEXCEPT
      {
        return !operator==( rhs );
      }
  #endif
  
    public:
      const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
      const void* pNext = {};
      VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics;
      VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNVX flags = {};
      uint32_t tokenCount = {};
      const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNVX* pTokens = {};
    };
    static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
    static_assert( std::is_standard_layout<IndirectCommandsLayoutCreateInfoNVX>::value, "struct wrapper is not a standard layout!" );
  } // namespace VULKAN_HPP_NAMESPACE
  