mirror of
https://github.com/skyline-emu/skyline.git
synced 2024-09-29 01:08:34 +02: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.
2041 lines
81 KiB
C++
2041 lines
81 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 "VkExternal.hpp"
|
|
#include "VkBind.hpp"
|
|
#include "VkCooperative.hpp"
|
|
#include "VkAndroid.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"
|
|
|
|
namespace VULKAN_HPP_NAMESPACE
|
|
{
|
|
struct VertexInputBindingDescription
|
|
{
|
|
VULKAN_HPP_CONSTEXPR VertexInputBindingDescription( uint32_t binding_ = {},
|
|
uint32_t stride_ = {},
|
|
VULKAN_HPP_NAMESPACE::VertexInputRate inputRate_ = VULKAN_HPP_NAMESPACE::VertexInputRate::eVertex ) VULKAN_HPP_NOEXCEPT
|
|
: binding( binding_ )
|
|
, stride( stride_ )
|
|
, inputRate( inputRate_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR VertexInputBindingDescription( VertexInputBindingDescription const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: binding( rhs.binding )
|
|
, stride( rhs.stride )
|
|
, inputRate( rhs.inputRate )
|
|
{}
|
|
|
|
VertexInputBindingDescription & operator=( VertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( VertexInputBindingDescription ) );
|
|
return *this;
|
|
}
|
|
|
|
VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
VertexInputBindingDescription & setBinding( uint32_t binding_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
binding = binding_;
|
|
return *this;
|
|
}
|
|
|
|
VertexInputBindingDescription & setStride( uint32_t stride_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
stride = stride_;
|
|
return *this;
|
|
}
|
|
|
|
VertexInputBindingDescription & setInputRate( VULKAN_HPP_NAMESPACE::VertexInputRate inputRate_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
inputRate = inputRate_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkVertexInputBindingDescription const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkVertexInputBindingDescription*>( this );
|
|
}
|
|
|
|
operator VkVertexInputBindingDescription &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkVertexInputBindingDescription*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( VertexInputBindingDescription const& ) const = default;
|
|
#else
|
|
bool operator==( VertexInputBindingDescription const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( binding == rhs.binding )
|
|
&& ( stride == rhs.stride )
|
|
&& ( inputRate == rhs.inputRate );
|
|
}
|
|
|
|
bool operator!=( VertexInputBindingDescription const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
uint32_t binding = {};
|
|
uint32_t stride = {};
|
|
VULKAN_HPP_NAMESPACE::VertexInputRate inputRate = VULKAN_HPP_NAMESPACE::VertexInputRate::eVertex;
|
|
};
|
|
static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<VertexInputBindingDescription>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct VertexInputAttributeDescription
|
|
{
|
|
VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( uint32_t location_ = {},
|
|
uint32_t binding_ = {},
|
|
VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined,
|
|
uint32_t offset_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: location( location_ )
|
|
, binding( binding_ )
|
|
, format( format_ )
|
|
, offset( offset_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( VertexInputAttributeDescription const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: location( rhs.location )
|
|
, binding( rhs.binding )
|
|
, format( rhs.format )
|
|
, offset( rhs.offset )
|
|
{}
|
|
|
|
VertexInputAttributeDescription & operator=( VertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( VertexInputAttributeDescription ) );
|
|
return *this;
|
|
}
|
|
|
|
VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
VertexInputAttributeDescription & setLocation( uint32_t location_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
location = location_;
|
|
return *this;
|
|
}
|
|
|
|
VertexInputAttributeDescription & setBinding( uint32_t binding_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
binding = binding_;
|
|
return *this;
|
|
}
|
|
|
|
VertexInputAttributeDescription & setFormat( VULKAN_HPP_NAMESPACE::Format format_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
format = format_;
|
|
return *this;
|
|
}
|
|
|
|
VertexInputAttributeDescription & setOffset( uint32_t offset_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
offset = offset_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkVertexInputAttributeDescription const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkVertexInputAttributeDescription*>( this );
|
|
}
|
|
|
|
operator VkVertexInputAttributeDescription &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkVertexInputAttributeDescription*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( VertexInputAttributeDescription const& ) const = default;
|
|
#else
|
|
bool operator==( VertexInputAttributeDescription const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( location == rhs.location )
|
|
&& ( binding == rhs.binding )
|
|
&& ( format == rhs.format )
|
|
&& ( offset == rhs.offset );
|
|
}
|
|
|
|
bool operator!=( VertexInputAttributeDescription const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
uint32_t location = {};
|
|
uint32_t binding = {};
|
|
VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined;
|
|
uint32_t offset = {};
|
|
};
|
|
static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<VertexInputAttributeDescription>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineVertexInputStateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags flags_ = {},
|
|
uint32_t vertexBindingDescriptionCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription* pVertexBindingDescriptions_ = {},
|
|
uint32_t vertexAttributeDescriptionCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
|
|
, pVertexBindingDescriptions( pVertexBindingDescriptions_ )
|
|
, vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
|
|
, pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, vertexBindingDescriptionCount( rhs.vertexBindingDescriptionCount )
|
|
, pVertexBindingDescriptions( rhs.pVertexBindingDescriptions )
|
|
, vertexAttributeDescriptionCount( rhs.vertexAttributeDescriptionCount )
|
|
, pVertexAttributeDescriptions( rhs.pVertexAttributeDescriptions )
|
|
{}
|
|
|
|
PipelineVertexInputStateCreateInfo & operator=( PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( PipelineVertexInputStateCreateInfo ) - offsetof( PipelineVertexInputStateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineVertexInputStateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineVertexInputStateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineVertexInputStateCreateInfo & setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
vertexBindingDescriptionCount = vertexBindingDescriptionCount_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineVertexInputStateCreateInfo & setPVertexBindingDescriptions( const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription* pVertexBindingDescriptions_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pVertexBindingDescriptions = pVertexBindingDescriptions_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineVertexInputStateCreateInfo & setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineVertexInputStateCreateInfo & setPVertexAttributeDescriptions( const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription* pVertexAttributeDescriptions_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pVertexAttributeDescriptions = pVertexAttributeDescriptions_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineVertexInputStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkPipelineVertexInputStateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineVertexInputStateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineVertexInputStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount )
|
|
&& ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions )
|
|
&& ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount )
|
|
&& ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions );
|
|
}
|
|
|
|
bool operator!=( PipelineVertexInputStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags flags = {};
|
|
uint32_t vertexBindingDescriptionCount = {};
|
|
const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription* pVertexBindingDescriptions = {};
|
|
uint32_t vertexAttributeDescriptionCount = {};
|
|
const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription* pVertexAttributeDescriptions = {};
|
|
};
|
|
static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineVertexInputStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineInputAssemblyStateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags flags_ = {},
|
|
VULKAN_HPP_NAMESPACE::PrimitiveTopology topology_ = VULKAN_HPP_NAMESPACE::PrimitiveTopology::ePointList,
|
|
VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, topology( topology_ )
|
|
, primitiveRestartEnable( primitiveRestartEnable_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, topology( rhs.topology )
|
|
, primitiveRestartEnable( rhs.primitiveRestartEnable )
|
|
{}
|
|
|
|
PipelineInputAssemblyStateCreateInfo & operator=( PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( PipelineInputAssemblyStateCreateInfo ) - offsetof( PipelineInputAssemblyStateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineInputAssemblyStateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineInputAssemblyStateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineInputAssemblyStateCreateInfo & setTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology topology_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
topology = topology_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineInputAssemblyStateCreateInfo & setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
primitiveRestartEnable = primitiveRestartEnable_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineInputAssemblyStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkPipelineInputAssemblyStateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineInputAssemblyStateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineInputAssemblyStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( topology == rhs.topology )
|
|
&& ( primitiveRestartEnable == rhs.primitiveRestartEnable );
|
|
}
|
|
|
|
bool operator!=( PipelineInputAssemblyStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags flags = {};
|
|
VULKAN_HPP_NAMESPACE::PrimitiveTopology topology = VULKAN_HPP_NAMESPACE::PrimitiveTopology::ePointList;
|
|
VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable = {};
|
|
};
|
|
static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineInputAssemblyStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineTessellationStateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags flags_ = {},
|
|
uint32_t patchControlPoints_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, patchControlPoints( patchControlPoints_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, patchControlPoints( rhs.patchControlPoints )
|
|
{}
|
|
|
|
PipelineTessellationStateCreateInfo & operator=( PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( PipelineTessellationStateCreateInfo ) - offsetof( PipelineTessellationStateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineTessellationStateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineTessellationStateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineTessellationStateCreateInfo & setPatchControlPoints( uint32_t patchControlPoints_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
patchControlPoints = patchControlPoints_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineTessellationStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkPipelineTessellationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineTessellationStateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineTessellationStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( patchControlPoints == rhs.patchControlPoints );
|
|
}
|
|
|
|
bool operator!=( PipelineTessellationStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags flags = {};
|
|
uint32_t patchControlPoints = {};
|
|
};
|
|
static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineTessellationStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct Viewport
|
|
{
|
|
VULKAN_HPP_CONSTEXPR Viewport( float x_ = {},
|
|
float y_ = {},
|
|
float width_ = {},
|
|
float height_ = {},
|
|
float minDepth_ = {},
|
|
float maxDepth_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: x( x_ )
|
|
, y( y_ )
|
|
, width( width_ )
|
|
, height( height_ )
|
|
, minDepth( minDepth_ )
|
|
, maxDepth( maxDepth_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR Viewport( Viewport const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: x( rhs.x )
|
|
, y( rhs.y )
|
|
, width( rhs.width )
|
|
, height( rhs.height )
|
|
, minDepth( rhs.minDepth )
|
|
, maxDepth( rhs.maxDepth )
|
|
{}
|
|
|
|
Viewport & operator=( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( Viewport ) );
|
|
return *this;
|
|
}
|
|
|
|
Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
Viewport& operator=( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::Viewport const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
Viewport & setX( float x_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
x = x_;
|
|
return *this;
|
|
}
|
|
|
|
Viewport & setY( float y_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
y = y_;
|
|
return *this;
|
|
}
|
|
|
|
Viewport & setWidth( float width_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
width = width_;
|
|
return *this;
|
|
}
|
|
|
|
Viewport & setHeight( float height_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
height = height_;
|
|
return *this;
|
|
}
|
|
|
|
Viewport & setMinDepth( float minDepth_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
minDepth = minDepth_;
|
|
return *this;
|
|
}
|
|
|
|
Viewport & setMaxDepth( float maxDepth_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
maxDepth = maxDepth_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkViewport const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkViewport*>( this );
|
|
}
|
|
|
|
operator VkViewport &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkViewport*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( Viewport const& ) const = default;
|
|
#else
|
|
bool operator==( Viewport const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( x == rhs.x )
|
|
&& ( y == rhs.y )
|
|
&& ( width == rhs.width )
|
|
&& ( height == rhs.height )
|
|
&& ( minDepth == rhs.minDepth )
|
|
&& ( maxDepth == rhs.maxDepth );
|
|
}
|
|
|
|
bool operator!=( Viewport const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
float x = {};
|
|
float y = {};
|
|
float width = {};
|
|
float height = {};
|
|
float minDepth = {};
|
|
float maxDepth = {};
|
|
};
|
|
static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<Viewport>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineViewportStateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags flags_ = {},
|
|
uint32_t viewportCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::Viewport* pViewports_ = {},
|
|
uint32_t scissorCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::Rect2D* pScissors_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, viewportCount( viewportCount_ )
|
|
, pViewports( pViewports_ )
|
|
, scissorCount( scissorCount_ )
|
|
, pScissors( pScissors_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( PipelineViewportStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, viewportCount( rhs.viewportCount )
|
|
, pViewports( rhs.pViewports )
|
|
, scissorCount( rhs.scissorCount )
|
|
, pScissors( rhs.pScissors )
|
|
{}
|
|
|
|
PipelineViewportStateCreateInfo & operator=( PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( PipelineViewportStateCreateInfo ) - offsetof( PipelineViewportStateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineViewportStateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineViewportStateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineViewportStateCreateInfo & setViewportCount( uint32_t viewportCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
viewportCount = viewportCount_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineViewportStateCreateInfo & setPViewports( const VULKAN_HPP_NAMESPACE::Viewport* pViewports_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pViewports = pViewports_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineViewportStateCreateInfo & setScissorCount( uint32_t scissorCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
scissorCount = scissorCount_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineViewportStateCreateInfo & setPScissors( const VULKAN_HPP_NAMESPACE::Rect2D* pScissors_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pScissors = pScissors_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineViewportStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkPipelineViewportStateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineViewportStateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineViewportStateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineViewportStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( viewportCount == rhs.viewportCount )
|
|
&& ( pViewports == rhs.pViewports )
|
|
&& ( scissorCount == rhs.scissorCount )
|
|
&& ( pScissors == rhs.pScissors );
|
|
}
|
|
|
|
bool operator!=( PipelineViewportStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportStateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags flags = {};
|
|
uint32_t viewportCount = {};
|
|
const VULKAN_HPP_NAMESPACE::Viewport* pViewports = {};
|
|
uint32_t scissorCount = {};
|
|
const VULKAN_HPP_NAMESPACE::Rect2D* pScissors = {};
|
|
};
|
|
static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineViewportStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineRasterizationStateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags flags_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable_ = {},
|
|
VULKAN_HPP_NAMESPACE::PolygonMode polygonMode_ = VULKAN_HPP_NAMESPACE::PolygonMode::eFill,
|
|
VULKAN_HPP_NAMESPACE::CullModeFlags cullMode_ = {},
|
|
VULKAN_HPP_NAMESPACE::FrontFace frontFace_ = VULKAN_HPP_NAMESPACE::FrontFace::eCounterClockwise,
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable_ = {},
|
|
float depthBiasConstantFactor_ = {},
|
|
float depthBiasClamp_ = {},
|
|
float depthBiasSlopeFactor_ = {},
|
|
float lineWidth_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, depthClampEnable( depthClampEnable_ )
|
|
, rasterizerDiscardEnable( rasterizerDiscardEnable_ )
|
|
, polygonMode( polygonMode_ )
|
|
, cullMode( cullMode_ )
|
|
, frontFace( frontFace_ )
|
|
, depthBiasEnable( depthBiasEnable_ )
|
|
, depthBiasConstantFactor( depthBiasConstantFactor_ )
|
|
, depthBiasClamp( depthBiasClamp_ )
|
|
, depthBiasSlopeFactor( depthBiasSlopeFactor_ )
|
|
, lineWidth( lineWidth_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, depthClampEnable( rhs.depthClampEnable )
|
|
, rasterizerDiscardEnable( rhs.rasterizerDiscardEnable )
|
|
, polygonMode( rhs.polygonMode )
|
|
, cullMode( rhs.cullMode )
|
|
, frontFace( rhs.frontFace )
|
|
, depthBiasEnable( rhs.depthBiasEnable )
|
|
, depthBiasConstantFactor( rhs.depthBiasConstantFactor )
|
|
, depthBiasClamp( rhs.depthBiasClamp )
|
|
, depthBiasSlopeFactor( rhs.depthBiasSlopeFactor )
|
|
, lineWidth( rhs.lineWidth )
|
|
{}
|
|
|
|
PipelineRasterizationStateCreateInfo & operator=( PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( PipelineRasterizationStateCreateInfo ) - offsetof( PipelineRasterizationStateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setDepthClampEnable( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthClampEnable = depthClampEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
rasterizerDiscardEnable = rasterizerDiscardEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setPolygonMode( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
polygonMode = polygonMode_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
cullMode = cullMode_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
frontFace = frontFace_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthBiasEnable = depthBiasEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthBiasConstantFactor = depthBiasConstantFactor_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setDepthBiasClamp( float depthBiasClamp_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthBiasClamp = depthBiasClamp_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthBiasSlopeFactor = depthBiasSlopeFactor_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineRasterizationStateCreateInfo & setLineWidth( float lineWidth_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
lineWidth = lineWidth_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineRasterizationStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkPipelineRasterizationStateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineRasterizationStateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineRasterizationStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( depthClampEnable == rhs.depthClampEnable )
|
|
&& ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable )
|
|
&& ( polygonMode == rhs.polygonMode )
|
|
&& ( cullMode == rhs.cullMode )
|
|
&& ( frontFace == rhs.frontFace )
|
|
&& ( depthBiasEnable == rhs.depthBiasEnable )
|
|
&& ( depthBiasConstantFactor == rhs.depthBiasConstantFactor )
|
|
&& ( depthBiasClamp == rhs.depthBiasClamp )
|
|
&& ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor )
|
|
&& ( lineWidth == rhs.lineWidth );
|
|
}
|
|
|
|
bool operator!=( PipelineRasterizationStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags flags = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable = {};
|
|
VULKAN_HPP_NAMESPACE::PolygonMode polygonMode = VULKAN_HPP_NAMESPACE::PolygonMode::eFill;
|
|
VULKAN_HPP_NAMESPACE::CullModeFlags cullMode = {};
|
|
VULKAN_HPP_NAMESPACE::FrontFace frontFace = VULKAN_HPP_NAMESPACE::FrontFace::eCounterClockwise;
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable = {};
|
|
float depthBiasConstantFactor = {};
|
|
float depthBiasClamp = {};
|
|
float depthBiasSlopeFactor = {};
|
|
float lineWidth = {};
|
|
};
|
|
static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineRasterizationStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineMultisampleStateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags flags_ = {},
|
|
VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1,
|
|
VULKAN_HPP_NAMESPACE::Bool32 sampleShadingEnable_ = {},
|
|
float minSampleShading_ = {},
|
|
const VULKAN_HPP_NAMESPACE::SampleMask* pSampleMask_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, rasterizationSamples( rasterizationSamples_ )
|
|
, sampleShadingEnable( sampleShadingEnable_ )
|
|
, minSampleShading( minSampleShading_ )
|
|
, pSampleMask( pSampleMask_ )
|
|
, alphaToCoverageEnable( alphaToCoverageEnable_ )
|
|
, alphaToOneEnable( alphaToOneEnable_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, rasterizationSamples( rhs.rasterizationSamples )
|
|
, sampleShadingEnable( rhs.sampleShadingEnable )
|
|
, minSampleShading( rhs.minSampleShading )
|
|
, pSampleMask( rhs.pSampleMask )
|
|
, alphaToCoverageEnable( rhs.alphaToCoverageEnable )
|
|
, alphaToOneEnable( rhs.alphaToOneEnable )
|
|
{}
|
|
|
|
PipelineMultisampleStateCreateInfo & operator=( PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( PipelineMultisampleStateCreateInfo ) - offsetof( PipelineMultisampleStateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo & setRasterizationSamples( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
rasterizationSamples = rasterizationSamples_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo & setSampleShadingEnable( VULKAN_HPP_NAMESPACE::Bool32 sampleShadingEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
sampleShadingEnable = sampleShadingEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo & setMinSampleShading( float minSampleShading_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
minSampleShading = minSampleShading_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo & setPSampleMask( const VULKAN_HPP_NAMESPACE::SampleMask* pSampleMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pSampleMask = pSampleMask_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo & setAlphaToCoverageEnable( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
alphaToCoverageEnable = alphaToCoverageEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineMultisampleStateCreateInfo & setAlphaToOneEnable( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
alphaToOneEnable = alphaToOneEnable_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineMultisampleStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkPipelineMultisampleStateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineMultisampleStateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( rasterizationSamples == rhs.rasterizationSamples )
|
|
&& ( sampleShadingEnable == rhs.sampleShadingEnable )
|
|
&& ( minSampleShading == rhs.minSampleShading )
|
|
&& ( pSampleMask == rhs.pSampleMask )
|
|
&& ( alphaToCoverageEnable == rhs.alphaToCoverageEnable )
|
|
&& ( alphaToOneEnable == rhs.alphaToOneEnable );
|
|
}
|
|
|
|
bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags flags = {};
|
|
VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1;
|
|
VULKAN_HPP_NAMESPACE::Bool32 sampleShadingEnable = {};
|
|
float minSampleShading = {};
|
|
const VULKAN_HPP_NAMESPACE::SampleMask* pSampleMask = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable = {};
|
|
};
|
|
static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineMultisampleStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct StencilOpState
|
|
{
|
|
VULKAN_HPP_CONSTEXPR StencilOpState( VULKAN_HPP_NAMESPACE::StencilOp failOp_ = VULKAN_HPP_NAMESPACE::StencilOp::eKeep,
|
|
VULKAN_HPP_NAMESPACE::StencilOp passOp_ = VULKAN_HPP_NAMESPACE::StencilOp::eKeep,
|
|
VULKAN_HPP_NAMESPACE::StencilOp depthFailOp_ = VULKAN_HPP_NAMESPACE::StencilOp::eKeep,
|
|
VULKAN_HPP_NAMESPACE::CompareOp compareOp_ = VULKAN_HPP_NAMESPACE::CompareOp::eNever,
|
|
uint32_t compareMask_ = {},
|
|
uint32_t writeMask_ = {},
|
|
uint32_t reference_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: failOp( failOp_ )
|
|
, passOp( passOp_ )
|
|
, depthFailOp( depthFailOp_ )
|
|
, compareOp( compareOp_ )
|
|
, compareMask( compareMask_ )
|
|
, writeMask( writeMask_ )
|
|
, reference( reference_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR StencilOpState( StencilOpState const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: failOp( rhs.failOp )
|
|
, passOp( rhs.passOp )
|
|
, depthFailOp( rhs.depthFailOp )
|
|
, compareOp( rhs.compareOp )
|
|
, compareMask( rhs.compareMask )
|
|
, writeMask( rhs.writeMask )
|
|
, reference( rhs.reference )
|
|
{}
|
|
|
|
StencilOpState & operator=( StencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( StencilOpState ) );
|
|
return *this;
|
|
}
|
|
|
|
StencilOpState( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
StencilOpState& operator=( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::StencilOpState const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
StencilOpState & setFailOp( VULKAN_HPP_NAMESPACE::StencilOp failOp_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
failOp = failOp_;
|
|
return *this;
|
|
}
|
|
|
|
StencilOpState & setPassOp( VULKAN_HPP_NAMESPACE::StencilOp passOp_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
passOp = passOp_;
|
|
return *this;
|
|
}
|
|
|
|
StencilOpState & setDepthFailOp( VULKAN_HPP_NAMESPACE::StencilOp depthFailOp_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthFailOp = depthFailOp_;
|
|
return *this;
|
|
}
|
|
|
|
StencilOpState & setCompareOp( VULKAN_HPP_NAMESPACE::CompareOp compareOp_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
compareOp = compareOp_;
|
|
return *this;
|
|
}
|
|
|
|
StencilOpState & setCompareMask( uint32_t compareMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
compareMask = compareMask_;
|
|
return *this;
|
|
}
|
|
|
|
StencilOpState & setWriteMask( uint32_t writeMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
writeMask = writeMask_;
|
|
return *this;
|
|
}
|
|
|
|
StencilOpState & setReference( uint32_t reference_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
reference = reference_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkStencilOpState const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkStencilOpState*>( this );
|
|
}
|
|
|
|
operator VkStencilOpState &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkStencilOpState*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( StencilOpState const& ) const = default;
|
|
#else
|
|
bool operator==( StencilOpState const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( failOp == rhs.failOp )
|
|
&& ( passOp == rhs.passOp )
|
|
&& ( depthFailOp == rhs.depthFailOp )
|
|
&& ( compareOp == rhs.compareOp )
|
|
&& ( compareMask == rhs.compareMask )
|
|
&& ( writeMask == rhs.writeMask )
|
|
&& ( reference == rhs.reference );
|
|
}
|
|
|
|
bool operator!=( StencilOpState const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::StencilOp failOp = VULKAN_HPP_NAMESPACE::StencilOp::eKeep;
|
|
VULKAN_HPP_NAMESPACE::StencilOp passOp = VULKAN_HPP_NAMESPACE::StencilOp::eKeep;
|
|
VULKAN_HPP_NAMESPACE::StencilOp depthFailOp = VULKAN_HPP_NAMESPACE::StencilOp::eKeep;
|
|
VULKAN_HPP_NAMESPACE::CompareOp compareOp = VULKAN_HPP_NAMESPACE::CompareOp::eNever;
|
|
uint32_t compareMask = {};
|
|
uint32_t writeMask = {};
|
|
uint32_t reference = {};
|
|
};
|
|
static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<StencilOpState>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineDepthStencilStateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags flags_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable_ = {},
|
|
VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp_ = VULKAN_HPP_NAMESPACE::CompareOp::eNever,
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable_ = {},
|
|
VULKAN_HPP_NAMESPACE::StencilOpState front_ = {},
|
|
VULKAN_HPP_NAMESPACE::StencilOpState back_ = {},
|
|
float minDepthBounds_ = {},
|
|
float maxDepthBounds_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, depthTestEnable( depthTestEnable_ )
|
|
, depthWriteEnable( depthWriteEnable_ )
|
|
, depthCompareOp( depthCompareOp_ )
|
|
, depthBoundsTestEnable( depthBoundsTestEnable_ )
|
|
, stencilTestEnable( stencilTestEnable_ )
|
|
, front( front_ )
|
|
, back( back_ )
|
|
, minDepthBounds( minDepthBounds_ )
|
|
, maxDepthBounds( maxDepthBounds_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, depthTestEnable( rhs.depthTestEnable )
|
|
, depthWriteEnable( rhs.depthWriteEnable )
|
|
, depthCompareOp( rhs.depthCompareOp )
|
|
, depthBoundsTestEnable( rhs.depthBoundsTestEnable )
|
|
, stencilTestEnable( rhs.stencilTestEnable )
|
|
, front( rhs.front )
|
|
, back( rhs.back )
|
|
, minDepthBounds( rhs.minDepthBounds )
|
|
, maxDepthBounds( rhs.maxDepthBounds )
|
|
{}
|
|
|
|
PipelineDepthStencilStateCreateInfo & operator=( PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( PipelineDepthStencilStateCreateInfo ) - offsetof( PipelineDepthStencilStateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthTestEnable = depthTestEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthWriteEnable = depthWriteEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthCompareOp = depthCompareOp_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
depthBoundsTestEnable = depthBoundsTestEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
stencilTestEnable = stencilTestEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setFront( VULKAN_HPP_NAMESPACE::StencilOpState front_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
front = front_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setBack( VULKAN_HPP_NAMESPACE::StencilOpState back_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
back = back_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setMinDepthBounds( float minDepthBounds_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
minDepthBounds = minDepthBounds_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDepthStencilStateCreateInfo & setMaxDepthBounds( float maxDepthBounds_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
maxDepthBounds = maxDepthBounds_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineDepthStencilStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkPipelineDepthStencilStateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineDepthStencilStateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineDepthStencilStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( depthTestEnable == rhs.depthTestEnable )
|
|
&& ( depthWriteEnable == rhs.depthWriteEnable )
|
|
&& ( depthCompareOp == rhs.depthCompareOp )
|
|
&& ( depthBoundsTestEnable == rhs.depthBoundsTestEnable )
|
|
&& ( stencilTestEnable == rhs.stencilTestEnable )
|
|
&& ( front == rhs.front )
|
|
&& ( back == rhs.back )
|
|
&& ( minDepthBounds == rhs.minDepthBounds )
|
|
&& ( maxDepthBounds == rhs.maxDepthBounds );
|
|
}
|
|
|
|
bool operator!=( PipelineDepthStencilStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags flags = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable = {};
|
|
VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp = VULKAN_HPP_NAMESPACE::CompareOp::eNever;
|
|
VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable = {};
|
|
VULKAN_HPP_NAMESPACE::StencilOpState front = {};
|
|
VULKAN_HPP_NAMESPACE::StencilOpState back = {};
|
|
float minDepthBounds = {};
|
|
float maxDepthBounds = {};
|
|
};
|
|
static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineDepthStencilStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineColorBlendAttachmentState
|
|
{
|
|
VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( VULKAN_HPP_NAMESPACE::Bool32 blendEnable_ = {},
|
|
VULKAN_HPP_NAMESPACE::BlendFactor srcColorBlendFactor_ = VULKAN_HPP_NAMESPACE::BlendFactor::eZero,
|
|
VULKAN_HPP_NAMESPACE::BlendFactor dstColorBlendFactor_ = VULKAN_HPP_NAMESPACE::BlendFactor::eZero,
|
|
VULKAN_HPP_NAMESPACE::BlendOp colorBlendOp_ = VULKAN_HPP_NAMESPACE::BlendOp::eAdd,
|
|
VULKAN_HPP_NAMESPACE::BlendFactor srcAlphaBlendFactor_ = VULKAN_HPP_NAMESPACE::BlendFactor::eZero,
|
|
VULKAN_HPP_NAMESPACE::BlendFactor dstAlphaBlendFactor_ = VULKAN_HPP_NAMESPACE::BlendFactor::eZero,
|
|
VULKAN_HPP_NAMESPACE::BlendOp alphaBlendOp_ = VULKAN_HPP_NAMESPACE::BlendOp::eAdd,
|
|
VULKAN_HPP_NAMESPACE::ColorComponentFlags colorWriteMask_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: blendEnable( blendEnable_ )
|
|
, srcColorBlendFactor( srcColorBlendFactor_ )
|
|
, dstColorBlendFactor( dstColorBlendFactor_ )
|
|
, colorBlendOp( colorBlendOp_ )
|
|
, srcAlphaBlendFactor( srcAlphaBlendFactor_ )
|
|
, dstAlphaBlendFactor( dstAlphaBlendFactor_ )
|
|
, alphaBlendOp( alphaBlendOp_ )
|
|
, colorWriteMask( colorWriteMask_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( PipelineColorBlendAttachmentState const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: blendEnable( rhs.blendEnable )
|
|
, srcColorBlendFactor( rhs.srcColorBlendFactor )
|
|
, dstColorBlendFactor( rhs.dstColorBlendFactor )
|
|
, colorBlendOp( rhs.colorBlendOp )
|
|
, srcAlphaBlendFactor( rhs.srcAlphaBlendFactor )
|
|
, dstAlphaBlendFactor( rhs.dstAlphaBlendFactor )
|
|
, alphaBlendOp( rhs.alphaBlendOp )
|
|
, colorWriteMask( rhs.colorWriteMask )
|
|
{}
|
|
|
|
PipelineColorBlendAttachmentState & operator=( PipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( PipelineColorBlendAttachmentState ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState & setBlendEnable( VULKAN_HPP_NAMESPACE::Bool32 blendEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
blendEnable = blendEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState & setSrcColorBlendFactor( VULKAN_HPP_NAMESPACE::BlendFactor srcColorBlendFactor_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
srcColorBlendFactor = srcColorBlendFactor_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState & setDstColorBlendFactor( VULKAN_HPP_NAMESPACE::BlendFactor dstColorBlendFactor_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstColorBlendFactor = dstColorBlendFactor_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState & setColorBlendOp( VULKAN_HPP_NAMESPACE::BlendOp colorBlendOp_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
colorBlendOp = colorBlendOp_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState & setSrcAlphaBlendFactor( VULKAN_HPP_NAMESPACE::BlendFactor srcAlphaBlendFactor_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
srcAlphaBlendFactor = srcAlphaBlendFactor_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState & setDstAlphaBlendFactor( VULKAN_HPP_NAMESPACE::BlendFactor dstAlphaBlendFactor_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstAlphaBlendFactor = dstAlphaBlendFactor_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState & setAlphaBlendOp( VULKAN_HPP_NAMESPACE::BlendOp alphaBlendOp_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
alphaBlendOp = alphaBlendOp_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendAttachmentState & setColorWriteMask( VULKAN_HPP_NAMESPACE::ColorComponentFlags colorWriteMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
colorWriteMask = colorWriteMask_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineColorBlendAttachmentState const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>( this );
|
|
}
|
|
|
|
operator VkPipelineColorBlendAttachmentState &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineColorBlendAttachmentState*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineColorBlendAttachmentState const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineColorBlendAttachmentState const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( blendEnable == rhs.blendEnable )
|
|
&& ( srcColorBlendFactor == rhs.srcColorBlendFactor )
|
|
&& ( dstColorBlendFactor == rhs.dstColorBlendFactor )
|
|
&& ( colorBlendOp == rhs.colorBlendOp )
|
|
&& ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor )
|
|
&& ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor )
|
|
&& ( alphaBlendOp == rhs.alphaBlendOp )
|
|
&& ( colorWriteMask == rhs.colorWriteMask );
|
|
}
|
|
|
|
bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::Bool32 blendEnable = {};
|
|
VULKAN_HPP_NAMESPACE::BlendFactor srcColorBlendFactor = VULKAN_HPP_NAMESPACE::BlendFactor::eZero;
|
|
VULKAN_HPP_NAMESPACE::BlendFactor dstColorBlendFactor = VULKAN_HPP_NAMESPACE::BlendFactor::eZero;
|
|
VULKAN_HPP_NAMESPACE::BlendOp colorBlendOp = VULKAN_HPP_NAMESPACE::BlendOp::eAdd;
|
|
VULKAN_HPP_NAMESPACE::BlendFactor srcAlphaBlendFactor = VULKAN_HPP_NAMESPACE::BlendFactor::eZero;
|
|
VULKAN_HPP_NAMESPACE::BlendFactor dstAlphaBlendFactor = VULKAN_HPP_NAMESPACE::BlendFactor::eZero;
|
|
VULKAN_HPP_NAMESPACE::BlendOp alphaBlendOp = VULKAN_HPP_NAMESPACE::BlendOp::eAdd;
|
|
VULKAN_HPP_NAMESPACE::ColorComponentFlags colorWriteMask = {};
|
|
};
|
|
static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineColorBlendAttachmentState>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineColorBlendStateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags flags_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable_ = {},
|
|
VULKAN_HPP_NAMESPACE::LogicOp logicOp_ = VULKAN_HPP_NAMESPACE::LogicOp::eClear,
|
|
uint32_t attachmentCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState* pAttachments_ = {},
|
|
std::array<float,4> const& blendConstants_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, logicOpEnable( logicOpEnable_ )
|
|
, logicOp( logicOp_ )
|
|
, attachmentCount( attachmentCount_ )
|
|
, pAttachments( pAttachments_ )
|
|
, blendConstants{}
|
|
{
|
|
VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,4>::copy( blendConstants, blendConstants_ );
|
|
}
|
|
|
|
VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, logicOpEnable( rhs.logicOpEnable )
|
|
, logicOp( rhs.logicOp )
|
|
, attachmentCount( rhs.attachmentCount )
|
|
, pAttachments( rhs.pAttachments )
|
|
, blendConstants{}
|
|
{
|
|
VULKAN_HPP_NAMESPACE::ConstExpression1DArrayCopy<float,4>::copy( blendConstants, rhs.blendConstants );
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo & operator=( PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( PipelineColorBlendStateCreateInfo ) - offsetof( PipelineColorBlendStateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo & setLogicOpEnable( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
logicOpEnable = logicOpEnable_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo & setLogicOp( VULKAN_HPP_NAMESPACE::LogicOp logicOp_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
logicOp = logicOp_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo & setAttachmentCount( uint32_t attachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
attachmentCount = attachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo & setPAttachments( const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState* pAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pAttachments = pAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineColorBlendStateCreateInfo & setBlendConstants( std::array<float,4> blendConstants_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineColorBlendStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkPipelineColorBlendStateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineColorBlendStateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( logicOpEnable == rhs.logicOpEnable )
|
|
&& ( logicOp == rhs.logicOp )
|
|
&& ( attachmentCount == rhs.attachmentCount )
|
|
&& ( pAttachments == rhs.pAttachments )
|
|
&& ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
|
|
}
|
|
|
|
bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags flags = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable = {};
|
|
VULKAN_HPP_NAMESPACE::LogicOp logicOp = VULKAN_HPP_NAMESPACE::LogicOp::eClear;
|
|
uint32_t attachmentCount = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState* pAttachments = {};
|
|
float blendConstants[4] = {};
|
|
};
|
|
static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineColorBlendStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct PipelineDynamicStateCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags flags_ = {},
|
|
uint32_t dynamicStateCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::DynamicState* pDynamicStates_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, dynamicStateCount( dynamicStateCount_ )
|
|
, pDynamicStates( pDynamicStates_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, dynamicStateCount( rhs.dynamicStateCount )
|
|
, pDynamicStates( rhs.pDynamicStates )
|
|
{}
|
|
|
|
PipelineDynamicStateCreateInfo & operator=( PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( PipelineDynamicStateCreateInfo ) - offsetof( PipelineDynamicStateCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
PipelineDynamicStateCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDynamicStateCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDynamicStateCreateInfo & setDynamicStateCount( uint32_t dynamicStateCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dynamicStateCount = dynamicStateCount_;
|
|
return *this;
|
|
}
|
|
|
|
PipelineDynamicStateCreateInfo & setPDynamicStates( const VULKAN_HPP_NAMESPACE::DynamicState* pDynamicStates_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pDynamicStates = pDynamicStates_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkPipelineDynamicStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkPipelineDynamicStateCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( PipelineDynamicStateCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( dynamicStateCount == rhs.dynamicStateCount )
|
|
&& ( pDynamicStates == rhs.pDynamicStates );
|
|
}
|
|
|
|
bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags flags = {};
|
|
uint32_t dynamicStateCount = {};
|
|
const VULKAN_HPP_NAMESPACE::DynamicState* pDynamicStates = {};
|
|
};
|
|
static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<PipelineDynamicStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct GraphicsPipelineCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {},
|
|
uint32_t stageCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo* pVertexInputState_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo* pTessellationState_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo* pViewportState_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo* pRasterizationState_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo* pMultisampleState_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo* pColorBlendState_ = {},
|
|
const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo* pDynamicState_ = {},
|
|
VULKAN_HPP_NAMESPACE::PipelineLayout layout_ = {},
|
|
VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {},
|
|
uint32_t subpass_ = {},
|
|
VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle_ = {},
|
|
int32_t basePipelineIndex_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, stageCount( stageCount_ )
|
|
, pStages( pStages_ )
|
|
, pVertexInputState( pVertexInputState_ )
|
|
, pInputAssemblyState( pInputAssemblyState_ )
|
|
, pTessellationState( pTessellationState_ )
|
|
, pViewportState( pViewportState_ )
|
|
, pRasterizationState( pRasterizationState_ )
|
|
, pMultisampleState( pMultisampleState_ )
|
|
, pDepthStencilState( pDepthStencilState_ )
|
|
, pColorBlendState( pColorBlendState_ )
|
|
, pDynamicState( pDynamicState_ )
|
|
, layout( layout_ )
|
|
, renderPass( renderPass_ )
|
|
, subpass( subpass_ )
|
|
, basePipelineHandle( basePipelineHandle_ )
|
|
, basePipelineIndex( basePipelineIndex_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( GraphicsPipelineCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, stageCount( rhs.stageCount )
|
|
, pStages( rhs.pStages )
|
|
, pVertexInputState( rhs.pVertexInputState )
|
|
, pInputAssemblyState( rhs.pInputAssemblyState )
|
|
, pTessellationState( rhs.pTessellationState )
|
|
, pViewportState( rhs.pViewportState )
|
|
, pRasterizationState( rhs.pRasterizationState )
|
|
, pMultisampleState( rhs.pMultisampleState )
|
|
, pDepthStencilState( rhs.pDepthStencilState )
|
|
, pColorBlendState( rhs.pColorBlendState )
|
|
, pDynamicState( rhs.pDynamicState )
|
|
, layout( rhs.layout )
|
|
, renderPass( rhs.renderPass )
|
|
, subpass( rhs.subpass )
|
|
, basePipelineHandle( rhs.basePipelineHandle )
|
|
, basePipelineIndex( rhs.basePipelineIndex )
|
|
{}
|
|
|
|
GraphicsPipelineCreateInfo & operator=( GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( GraphicsPipelineCreateInfo ) - offsetof( GraphicsPipelineCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setStageCount( uint32_t stageCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
stageCount = stageCount_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPStages( const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pStages = pStages_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPVertexInputState( const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo* pVertexInputState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pVertexInputState = pVertexInputState_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPInputAssemblyState( const VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pInputAssemblyState = pInputAssemblyState_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPTessellationState( const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo* pTessellationState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pTessellationState = pTessellationState_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPViewportState( const VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo* pViewportState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pViewportState = pViewportState_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPRasterizationState( const VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo* pRasterizationState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pRasterizationState = pRasterizationState_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPMultisampleState( const VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo* pMultisampleState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pMultisampleState = pMultisampleState_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPDepthStencilState( const VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pDepthStencilState = pDepthStencilState_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPColorBlendState( const VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo* pColorBlendState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pColorBlendState = pColorBlendState_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setPDynamicState( const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo* pDynamicState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pDynamicState = pDynamicState_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setLayout( VULKAN_HPP_NAMESPACE::PipelineLayout layout_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
layout = layout_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
renderPass = renderPass_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setSubpass( uint32_t subpass_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
subpass = subpass_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setBasePipelineHandle( VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
basePipelineHandle = basePipelineHandle_;
|
|
return *this;
|
|
}
|
|
|
|
GraphicsPipelineCreateInfo & setBasePipelineIndex( int32_t basePipelineIndex_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
basePipelineIndex = basePipelineIndex_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkGraphicsPipelineCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkGraphicsPipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkGraphicsPipelineCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( GraphicsPipelineCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( GraphicsPipelineCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( stageCount == rhs.stageCount )
|
|
&& ( pStages == rhs.pStages )
|
|
&& ( pVertexInputState == rhs.pVertexInputState )
|
|
&& ( pInputAssemblyState == rhs.pInputAssemblyState )
|
|
&& ( pTessellationState == rhs.pTessellationState )
|
|
&& ( pViewportState == rhs.pViewportState )
|
|
&& ( pRasterizationState == rhs.pRasterizationState )
|
|
&& ( pMultisampleState == rhs.pMultisampleState )
|
|
&& ( pDepthStencilState == rhs.pDepthStencilState )
|
|
&& ( pColorBlendState == rhs.pColorBlendState )
|
|
&& ( pDynamicState == rhs.pDynamicState )
|
|
&& ( layout == rhs.layout )
|
|
&& ( renderPass == rhs.renderPass )
|
|
&& ( subpass == rhs.subpass )
|
|
&& ( basePipelineHandle == rhs.basePipelineHandle )
|
|
&& ( basePipelineIndex == rhs.basePipelineIndex );
|
|
}
|
|
|
|
bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags = {};
|
|
uint32_t stageCount = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo* pVertexInputState = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo* pTessellationState = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo* pViewportState = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo* pRasterizationState = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo* pMultisampleState = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo* pDepthStencilState = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo* pColorBlendState = {};
|
|
const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo* pDynamicState = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineLayout layout = {};
|
|
VULKAN_HPP_NAMESPACE::RenderPass renderPass = {};
|
|
uint32_t subpass = {};
|
|
VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle = {};
|
|
int32_t basePipelineIndex = {};
|
|
};
|
|
static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<GraphicsPipelineCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
} // namespace VULKAN_HPP_NAMESPACE
|