mirror of
https://github.com/skyline-emu/skyline.git
synced 2024-11-17 08:39:16 +01:00
500b49d329
This commit adds Vulkan-Hpp as a library to the project. The headers are from a modified version of `VulkanHppGenerator`. They are broken into multiple files to avoid exceeding the Intellisense file size limit of Android Studio.
1352 lines
52 KiB
C++
1352 lines
52 KiB
C++
// 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 "VkBind.hpp"
|
|
#include "VkCooperative.hpp"
|
|
#include "VkAndroid.hpp"
|
|
#include "VkBase.hpp"
|
|
#include "VkAttachment.hpp"
|
|
#include "VkBuffer.hpp"
|
|
#include "VkCalibrated.hpp"
|
|
#include "VkCheckpoint.hpp"
|
|
#include "VkConformance.hpp"
|
|
#include "VkClear.hpp"
|
|
#include "VkCmd.hpp"
|
|
#include "VkCoarse.hpp"
|
|
#include "VkCommand.hpp"
|
|
#include "VkComponent.hpp"
|
|
#include "VkCopy.hpp"
|
|
#include "VkCompute.hpp"
|
|
#include "VkConditional.hpp"
|
|
#include "VkD3D.hpp"
|
|
#include "VkDebug.hpp"
|
|
#include "VkDedicated.hpp"
|
|
#include "VkDescriptor.hpp"
|
|
|
|
namespace VULKAN_HPP_NAMESPACE
|
|
{
|
|
struct DescriptorBufferInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {},
|
|
VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {},
|
|
VULKAN_HPP_NAMESPACE::DeviceSize range_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: buffer( buffer_ )
|
|
, offset( offset_ )
|
|
, range( range_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( DescriptorBufferInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: buffer( rhs.buffer )
|
|
, offset( rhs.offset )
|
|
, range( rhs.range )
|
|
{}
|
|
|
|
DescriptorBufferInfo & operator=( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorBufferInfo ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorBufferInfo & setBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
buffer = buffer_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorBufferInfo & setOffset( VULKAN_HPP_NAMESPACE::DeviceSize offset_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
offset = offset_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorBufferInfo & setRange( VULKAN_HPP_NAMESPACE::DeviceSize range_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
range = range_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorBufferInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorBufferInfo*>( this );
|
|
}
|
|
|
|
operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorBufferInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorBufferInfo const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorBufferInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( buffer == rhs.buffer )
|
|
&& ( offset == rhs.offset )
|
|
&& ( range == rhs.range );
|
|
}
|
|
|
|
bool operator!=( DescriptorBufferInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::Buffer buffer = {};
|
|
VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
|
|
VULKAN_HPP_NAMESPACE::DeviceSize range = {};
|
|
};
|
|
static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorBufferInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorImageInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorImageInfo( VULKAN_HPP_NAMESPACE::Sampler sampler_ = {},
|
|
VULKAN_HPP_NAMESPACE::ImageView imageView_ = {},
|
|
VULKAN_HPP_NAMESPACE::ImageLayout imageLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
|
|
: sampler( sampler_ )
|
|
, imageView( imageView_ )
|
|
, imageLayout( imageLayout_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorImageInfo( DescriptorImageInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: sampler( rhs.sampler )
|
|
, imageView( rhs.imageView )
|
|
, imageLayout( rhs.imageLayout )
|
|
{}
|
|
|
|
DescriptorImageInfo & operator=( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorImageInfo ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorImageInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorImageInfo & setSampler( VULKAN_HPP_NAMESPACE::Sampler sampler_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
sampler = sampler_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorImageInfo & setImageView( VULKAN_HPP_NAMESPACE::ImageView imageView_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
imageView = imageView_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorImageInfo & setImageLayout( VULKAN_HPP_NAMESPACE::ImageLayout imageLayout_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
imageLayout = imageLayout_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorImageInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorImageInfo*>( this );
|
|
}
|
|
|
|
operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorImageInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorImageInfo const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorImageInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sampler == rhs.sampler )
|
|
&& ( imageView == rhs.imageView )
|
|
&& ( imageLayout == rhs.imageLayout );
|
|
}
|
|
|
|
bool operator!=( DescriptorImageInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::Sampler sampler = {};
|
|
VULKAN_HPP_NAMESPACE::ImageView imageView = {};
|
|
VULKAN_HPP_NAMESPACE::ImageLayout imageLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined;
|
|
};
|
|
static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorImageInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorPoolSize
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorPoolSize( VULKAN_HPP_NAMESPACE::DescriptorType type_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler,
|
|
uint32_t descriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: type( type_ )
|
|
, descriptorCount( descriptorCount_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorPoolSize( DescriptorPoolSize const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: type( rhs.type )
|
|
, descriptorCount( rhs.descriptorCount )
|
|
{}
|
|
|
|
DescriptorPoolSize & operator=( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorPoolSize ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorPoolSize const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolSize & setType( VULKAN_HPP_NAMESPACE::DescriptorType type_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
type = type_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolSize & setDescriptorCount( uint32_t descriptorCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorCount = descriptorCount_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorPoolSize const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorPoolSize*>( this );
|
|
}
|
|
|
|
operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorPoolSize*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorPoolSize const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorPoolSize const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( type == rhs.type )
|
|
&& ( descriptorCount == rhs.descriptorCount );
|
|
}
|
|
|
|
bool operator!=( DescriptorPoolSize const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::DescriptorType type = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler;
|
|
uint32_t descriptorCount = {};
|
|
};
|
|
static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorPoolSize>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorPoolCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags flags_ = {},
|
|
uint32_t maxSets_ = {},
|
|
uint32_t poolSizeCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::DescriptorPoolSize* pPoolSizes_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, maxSets( maxSets_ )
|
|
, poolSizeCount( poolSizeCount_ )
|
|
, pPoolSizes( pPoolSizes_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( DescriptorPoolCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, maxSets( rhs.maxSets )
|
|
, poolSizeCount( rhs.poolSizeCount )
|
|
, pPoolSizes( rhs.pPoolSizes )
|
|
{}
|
|
|
|
DescriptorPoolCreateInfo & operator=( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorPoolCreateInfo ) - offsetof( DescriptorPoolCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolCreateInfo & setMaxSets( uint32_t maxSets_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
maxSets = maxSets_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolCreateInfo & setPoolSizeCount( uint32_t poolSizeCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
poolSizeCount = poolSizeCount_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolCreateInfo & setPPoolSizes( const VULKAN_HPP_NAMESPACE::DescriptorPoolSize* pPoolSizes_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pPoolSizes = pPoolSizes_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorPoolCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorPoolCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorPoolCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorPoolCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( maxSets == rhs.maxSets )
|
|
&& ( poolSizeCount == rhs.poolSizeCount )
|
|
&& ( pPoolSizes == rhs.pPoolSizes );
|
|
}
|
|
|
|
bool operator!=( DescriptorPoolCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorPoolCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags flags = {};
|
|
uint32_t maxSets = {};
|
|
uint32_t poolSizeCount = {};
|
|
const VULKAN_HPP_NAMESPACE::DescriptorPoolSize* pPoolSizes = {};
|
|
};
|
|
static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorPoolCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorPoolInlineUniformBlockCreateInfoEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, maxInlineUniformBlockBindings( rhs.maxInlineUniformBlockBindings )
|
|
{}
|
|
|
|
DescriptorPoolInlineUniformBlockCreateInfoEXT & operator=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) - offsetof( DescriptorPoolInlineUniformBlockCreateInfoEXT, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolInlineUniformBlockCreateInfoEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorPoolInlineUniformBlockCreateInfoEXT & setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>( this );
|
|
}
|
|
|
|
operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfoEXT const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings );
|
|
}
|
|
|
|
bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
|
|
const void* pNext = {};
|
|
uint32_t maxInlineUniformBlockBindings = {};
|
|
};
|
|
static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorPoolInlineUniformBlockCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorSetAllocateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool_ = {},
|
|
uint32_t descriptorSetCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: descriptorPool( descriptorPool_ )
|
|
, descriptorSetCount( descriptorSetCount_ )
|
|
, pSetLayouts( pSetLayouts_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( DescriptorSetAllocateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, descriptorPool( rhs.descriptorPool )
|
|
, descriptorSetCount( rhs.descriptorSetCount )
|
|
, pSetLayouts( rhs.pSetLayouts )
|
|
{}
|
|
|
|
DescriptorSetAllocateInfo & operator=( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetAllocateInfo ) - offsetof( DescriptorSetAllocateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetAllocateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetAllocateInfo & setDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorPool = descriptorPool_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetAllocateInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorSetCount = descriptorSetCount_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetAllocateInfo & setPSetLayouts( const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pSetLayouts = pSetLayouts_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorSetAllocateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>( this );
|
|
}
|
|
|
|
operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorSetAllocateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorSetAllocateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorSetAllocateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( descriptorPool == rhs.descriptorPool )
|
|
&& ( descriptorSetCount == rhs.descriptorSetCount )
|
|
&& ( pSetLayouts == rhs.pSetLayouts );
|
|
}
|
|
|
|
bool operator!=( DescriptorSetAllocateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetAllocateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool = {};
|
|
uint32_t descriptorSetCount = {};
|
|
const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts = {};
|
|
};
|
|
static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorSetAllocateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorSetLayoutBinding
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( uint32_t binding_ = {},
|
|
VULKAN_HPP_NAMESPACE::DescriptorType descriptorType_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler,
|
|
uint32_t descriptorCount_ = {},
|
|
VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags_ = {},
|
|
const VULKAN_HPP_NAMESPACE::Sampler* pImmutableSamplers_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: binding( binding_ )
|
|
, descriptorType( descriptorType_ )
|
|
, descriptorCount( descriptorCount_ )
|
|
, stageFlags( stageFlags_ )
|
|
, pImmutableSamplers( pImmutableSamplers_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( DescriptorSetLayoutBinding const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: binding( rhs.binding )
|
|
, descriptorType( rhs.descriptorType )
|
|
, descriptorCount( rhs.descriptorCount )
|
|
, stageFlags( rhs.stageFlags )
|
|
, pImmutableSamplers( rhs.pImmutableSamplers )
|
|
{}
|
|
|
|
DescriptorSetLayoutBinding & operator=( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorSetLayoutBinding ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBinding & setBinding( uint32_t binding_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
binding = binding_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBinding & setDescriptorType( VULKAN_HPP_NAMESPACE::DescriptorType descriptorType_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorType = descriptorType_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBinding & setDescriptorCount( uint32_t descriptorCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorCount = descriptorCount_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBinding & setStageFlags( VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
stageFlags = stageFlags_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBinding & setPImmutableSamplers( const VULKAN_HPP_NAMESPACE::Sampler* pImmutableSamplers_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pImmutableSamplers = pImmutableSamplers_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorSetLayoutBinding const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>( this );
|
|
}
|
|
|
|
operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorSetLayoutBinding*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorSetLayoutBinding const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorSetLayoutBinding const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( binding == rhs.binding )
|
|
&& ( descriptorType == rhs.descriptorType )
|
|
&& ( descriptorCount == rhs.descriptorCount )
|
|
&& ( stageFlags == rhs.stageFlags )
|
|
&& ( pImmutableSamplers == rhs.pImmutableSamplers );
|
|
}
|
|
|
|
bool operator!=( DescriptorSetLayoutBinding const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
uint32_t binding = {};
|
|
VULKAN_HPP_NAMESPACE::DescriptorType descriptorType = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler;
|
|
uint32_t descriptorCount = {};
|
|
VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags = {};
|
|
const VULKAN_HPP_NAMESPACE::Sampler* pImmutableSamplers = {};
|
|
};
|
|
static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorSetLayoutBinding>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::DescriptorBindingFlagsEXT* pBindingFlags_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: bindingCount( bindingCount_ )
|
|
, pBindingFlags( pBindingFlags_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, bindingCount( rhs.bindingCount )
|
|
, pBindingFlags( rhs.pBindingFlags )
|
|
{}
|
|
|
|
DescriptorSetLayoutBindingFlagsCreateInfoEXT & operator=( DescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) - offsetof( DescriptorSetLayoutBindingFlagsCreateInfoEXT, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfoEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBindingFlagsCreateInfoEXT & setBindingCount( uint32_t bindingCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
bindingCount = bindingCount_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPBindingFlags( const VULKAN_HPP_NAMESPACE::DescriptorBindingFlagsEXT* pBindingFlags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pBindingFlags = pBindingFlags_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>( this );
|
|
}
|
|
|
|
operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( bindingCount == rhs.bindingCount )
|
|
&& ( pBindingFlags == rhs.pBindingFlags );
|
|
}
|
|
|
|
bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
|
|
const void* pNext = {};
|
|
uint32_t bindingCount = {};
|
|
const VULKAN_HPP_NAMESPACE::DescriptorBindingFlagsEXT* pBindingFlags = {};
|
|
};
|
|
static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorSetLayoutBindingFlagsCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorSetLayoutCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags flags_ = {},
|
|
uint32_t bindingCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding* pBindings_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, bindingCount( bindingCount_ )
|
|
, pBindings( pBindings_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, bindingCount( rhs.bindingCount )
|
|
, pBindings( rhs.pBindings )
|
|
{}
|
|
|
|
DescriptorSetLayoutCreateInfo & operator=( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetLayoutCreateInfo ) - offsetof( DescriptorSetLayoutCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutCreateInfo & setBindingCount( uint32_t bindingCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
bindingCount = bindingCount_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutCreateInfo & setPBindings( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding* pBindings_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pBindings = pBindings_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorSetLayoutCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorSetLayoutCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( bindingCount == rhs.bindingCount )
|
|
&& ( pBindings == rhs.pBindings );
|
|
}
|
|
|
|
bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags flags = {};
|
|
uint32_t bindingCount = {};
|
|
const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding* pBindings = {};
|
|
};
|
|
static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorSetLayoutCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorSetLayoutSupport
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( VULKAN_HPP_NAMESPACE::Bool32 supported_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: supported( supported_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( DescriptorSetLayoutSupport const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, supported( rhs.supported )
|
|
{}
|
|
|
|
DescriptorSetLayoutSupport & operator=( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetLayoutSupport ) - offsetof( DescriptorSetLayoutSupport, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorSetLayoutSupport const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorSetLayoutSupport*>( this );
|
|
}
|
|
|
|
operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorSetLayoutSupport*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorSetLayoutSupport const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorSetLayoutSupport const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( supported == rhs.supported );
|
|
}
|
|
|
|
bool operator!=( DescriptorSetLayoutSupport const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetLayoutSupport;
|
|
void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 supported = {};
|
|
};
|
|
static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorSetLayoutSupport>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorSetVariableDescriptorCountAllocateInfoEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = {},
|
|
const uint32_t* pDescriptorCounts_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: descriptorSetCount( descriptorSetCount_ )
|
|
, pDescriptorCounts( pDescriptorCounts_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, descriptorSetCount( rhs.descriptorSetCount )
|
|
, pDescriptorCounts( rhs.pDescriptorCounts )
|
|
{}
|
|
|
|
DescriptorSetVariableDescriptorCountAllocateInfoEXT & operator=( DescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) - offsetof( DescriptorSetVariableDescriptorCountAllocateInfoEXT, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfoEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetVariableDescriptorCountAllocateInfoEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetVariableDescriptorCountAllocateInfoEXT & setDescriptorSetCount( uint32_t descriptorSetCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorSetCount = descriptorSetCount_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetVariableDescriptorCountAllocateInfoEXT & setPDescriptorCounts( const uint32_t* pDescriptorCounts_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pDescriptorCounts = pDescriptorCounts_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>( this );
|
|
}
|
|
|
|
operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( descriptorSetCount == rhs.descriptorSetCount )
|
|
&& ( pDescriptorCounts == rhs.pDescriptorCounts );
|
|
}
|
|
|
|
bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT;
|
|
const void* pNext = {};
|
|
uint32_t descriptorSetCount = {};
|
|
const uint32_t* pDescriptorCounts = {};
|
|
};
|
|
static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountAllocateInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupportEXT( uint32_t maxVariableDescriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: maxVariableDescriptorCount( maxVariableDescriptorCount_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupportEXT( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, maxVariableDescriptorCount( rhs.maxVariableDescriptorCount )
|
|
{}
|
|
|
|
DescriptorSetVariableDescriptorCountLayoutSupportEXT & operator=( DescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) - offsetof( DescriptorSetVariableDescriptorCountLayoutSupportEXT, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupportEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>( this );
|
|
}
|
|
|
|
operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount );
|
|
}
|
|
|
|
bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT;
|
|
void* pNext = {};
|
|
uint32_t maxVariableDescriptorCount = {};
|
|
};
|
|
static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountLayoutSupportEXT>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorUpdateTemplateEntry
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = {},
|
|
uint32_t dstArrayElement_ = {},
|
|
uint32_t descriptorCount_ = {},
|
|
VULKAN_HPP_NAMESPACE::DescriptorType descriptorType_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler,
|
|
size_t offset_ = {},
|
|
size_t stride_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: dstBinding( dstBinding_ )
|
|
, dstArrayElement( dstArrayElement_ )
|
|
, descriptorCount( descriptorCount_ )
|
|
, descriptorType( descriptorType_ )
|
|
, offset( offset_ )
|
|
, stride( stride_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( DescriptorUpdateTemplateEntry const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: dstBinding( rhs.dstBinding )
|
|
, dstArrayElement( rhs.dstArrayElement )
|
|
, descriptorCount( rhs.descriptorCount )
|
|
, descriptorType( rhs.descriptorType )
|
|
, offset( rhs.offset )
|
|
, stride( rhs.stride )
|
|
{}
|
|
|
|
DescriptorUpdateTemplateEntry & operator=( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateEntry & setDstBinding( uint32_t dstBinding_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstBinding = dstBinding_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateEntry & setDstArrayElement( uint32_t dstArrayElement_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstArrayElement = dstArrayElement_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateEntry & setDescriptorCount( uint32_t descriptorCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorCount = descriptorCount_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateEntry & setDescriptorType( VULKAN_HPP_NAMESPACE::DescriptorType descriptorType_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorType = descriptorType_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateEntry & setOffset( size_t offset_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
offset = offset_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateEntry & setStride( size_t stride_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
stride = stride_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorUpdateTemplateEntry const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry*>( this );
|
|
}
|
|
|
|
operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorUpdateTemplateEntry const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorUpdateTemplateEntry const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( dstBinding == rhs.dstBinding )
|
|
&& ( dstArrayElement == rhs.dstArrayElement )
|
|
&& ( descriptorCount == rhs.descriptorCount )
|
|
&& ( descriptorType == rhs.descriptorType )
|
|
&& ( offset == rhs.offset )
|
|
&& ( stride == rhs.stride );
|
|
}
|
|
|
|
bool operator!=( DescriptorUpdateTemplateEntry const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
uint32_t dstBinding = {};
|
|
uint32_t dstArrayElement = {};
|
|
uint32_t descriptorCount = {};
|
|
VULKAN_HPP_NAMESPACE::DescriptorType descriptorType = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler;
|
|
size_t offset = {};
|
|
size_t stride = {};
|
|
};
|
|
static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorUpdateTemplateEntry>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DescriptorUpdateTemplateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags flags_ = {},
|
|
uint32_t descriptorUpdateEntryCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = {},
|
|
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType templateType_ = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType::eDescriptorSet,
|
|
VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout_ = {},
|
|
VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics,
|
|
VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout_ = {},
|
|
uint32_t set_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
|
|
, pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
|
|
, templateType( templateType_ )
|
|
, descriptorSetLayout( descriptorSetLayout_ )
|
|
, pipelineBindPoint( pipelineBindPoint_ )
|
|
, pipelineLayout( pipelineLayout_ )
|
|
, set( set_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, descriptorUpdateEntryCount( rhs.descriptorUpdateEntryCount )
|
|
, pDescriptorUpdateEntries( rhs.pDescriptorUpdateEntries )
|
|
, templateType( rhs.templateType )
|
|
, descriptorSetLayout( rhs.descriptorSetLayout )
|
|
, pipelineBindPoint( rhs.pipelineBindPoint )
|
|
, pipelineLayout( rhs.pipelineLayout )
|
|
, set( rhs.set )
|
|
{}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & operator=( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DescriptorUpdateTemplateCreateInfo ) - offsetof( DescriptorUpdateTemplateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & setPDescriptorUpdateEntries( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & setTemplateType( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType templateType_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
templateType = templateType_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
descriptorSetLayout = descriptorSetLayout_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pipelineBindPoint = pipelineBindPoint_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & setPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pipelineLayout = pipelineLayout_;
|
|
return *this;
|
|
}
|
|
|
|
DescriptorUpdateTemplateCreateInfo & setSet( uint32_t set_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
set = set_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDescriptorUpdateTemplateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DescriptorUpdateTemplateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( DescriptorUpdateTemplateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount )
|
|
&& ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries )
|
|
&& ( templateType == rhs.templateType )
|
|
&& ( descriptorSetLayout == rhs.descriptorSetLayout )
|
|
&& ( pipelineBindPoint == rhs.pipelineBindPoint )
|
|
&& ( pipelineLayout == rhs.pipelineLayout )
|
|
&& ( set == rhs.set );
|
|
}
|
|
|
|
bool operator!=( DescriptorUpdateTemplateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags flags = {};
|
|
uint32_t descriptorUpdateEntryCount = {};
|
|
const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries = {};
|
|
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType templateType = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType::eDescriptorSet;
|
|
VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics;
|
|
VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout = {};
|
|
uint32_t set = {};
|
|
};
|
|
static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DescriptorUpdateTemplateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
} // namespace VULKAN_HPP_NAMESPACE
|