mirror of
https://github.com/skyline-emu/skyline.git
synced 2024-12-25 17:11:51 +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.
1711 lines
66 KiB
C++
1711 lines
66 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 "VkInitialize.hpp"
|
|
#include "VkAllocation.hpp"
|
|
#include "VkExternal.hpp"
|
|
#include "VkBind.hpp"
|
|
#include "VkObject.hpp"
|
|
#include "VkCooperative.hpp"
|
|
#include "VkAndroid.hpp"
|
|
#include "VkImport.hpp"
|
|
#include "VkImage.hpp"
|
|
#include "VkDescriptor.hpp"
|
|
#include "VkBase.hpp"
|
|
#include "VkAttachment.hpp"
|
|
#include "VkBuffer.hpp"
|
|
#include "VkFramebuffer.hpp"
|
|
#include "VkCalibrated.hpp"
|
|
#include "VkDevice.hpp"
|
|
#include "VkCheckpoint.hpp"
|
|
#include "VkConformance.hpp"
|
|
#include "VkClear.hpp"
|
|
#include "VkCmd.hpp"
|
|
#include "VkCoarse.hpp"
|
|
#include "VkExtension.hpp"
|
|
#include "VkCommand.hpp"
|
|
#include "VkFormat.hpp"
|
|
#include "VkMetal.hpp"
|
|
#include "VkComponent.hpp"
|
|
#include "VkCopy.hpp"
|
|
#include "VkCompute.hpp"
|
|
#include "VkPast.hpp"
|
|
#include "VkConditional.hpp"
|
|
#include "VkMapped.hpp"
|
|
#include "VkD3D.hpp"
|
|
#include "VkDebug.hpp"
|
|
#include "VkDedicated.hpp"
|
|
#include "VkFence.hpp"
|
|
#include "VkDispatch.hpp"
|
|
#include "VkPipeline.hpp"
|
|
#include "VkDraw.hpp"
|
|
#include "VkDisplay.hpp"
|
|
#include "VkDrm.hpp"
|
|
#include "VkEvent.hpp"
|
|
#include "VkExport.hpp"
|
|
#include "VkRay.hpp"
|
|
#include "VkExtent.hpp"
|
|
#include "VkPerformance.hpp"
|
|
#include "VkFilter.hpp"
|
|
#include "VkGeometry.hpp"
|
|
#include "VkGraphics.hpp"
|
|
#include "VkHdr.hpp"
|
|
#include "VkHeadless.hpp"
|
|
#include "VkMultisample.hpp"
|
|
#include "VkI.hpp"
|
|
#include "VkIndirect.hpp"
|
|
#include "VkInput.hpp"
|
|
#include "VkOffset.hpp"
|
|
#include "VkMemory.hpp"
|
|
#include "VkInstance.hpp"
|
|
#include "VkLayer.hpp"
|
|
#include "VkMac.hpp"
|
|
#include "VkPhysical.hpp"
|
|
#include "VkPresent.hpp"
|
|
#include "VkProtected.hpp"
|
|
#include "VkPush.hpp"
|
|
#include "VkQuery.hpp"
|
|
#include "VkQueue.hpp"
|
|
#include "VkRect.hpp"
|
|
#include "VkRefresh.hpp"
|
|
#include "VkRender.hpp"
|
|
|
|
namespace VULKAN_HPP_NAMESPACE
|
|
{
|
|
struct RenderPassAttachmentBeginInfoKHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::ImageView* pAttachments_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: attachmentCount( attachmentCount_ )
|
|
, pAttachments( pAttachments_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( RenderPassAttachmentBeginInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, attachmentCount( rhs.attachmentCount )
|
|
, pAttachments( rhs.pAttachments )
|
|
{}
|
|
|
|
RenderPassAttachmentBeginInfoKHR & operator=( RenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassAttachmentBeginInfoKHR ) - offsetof( RenderPassAttachmentBeginInfoKHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfoKHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
RenderPassAttachmentBeginInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassAttachmentBeginInfoKHR & setAttachmentCount( uint32_t attachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
attachmentCount = attachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassAttachmentBeginInfoKHR & setPAttachments( const VULKAN_HPP_NAMESPACE::ImageView* pAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pAttachments = pAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkRenderPassAttachmentBeginInfoKHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkRenderPassAttachmentBeginInfoKHR*>( this );
|
|
}
|
|
|
|
operator VkRenderPassAttachmentBeginInfoKHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( RenderPassAttachmentBeginInfoKHR const& ) const = default;
|
|
#else
|
|
bool operator==( RenderPassAttachmentBeginInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( attachmentCount == rhs.attachmentCount )
|
|
&& ( pAttachments == rhs.pAttachments );
|
|
}
|
|
|
|
bool operator!=( RenderPassAttachmentBeginInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR;
|
|
const void* pNext = {};
|
|
uint32_t attachmentCount = {};
|
|
const VULKAN_HPP_NAMESPACE::ImageView* pAttachments = {};
|
|
};
|
|
static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<RenderPassAttachmentBeginInfoKHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct RenderPassBeginInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {},
|
|
VULKAN_HPP_NAMESPACE::Framebuffer framebuffer_ = {},
|
|
VULKAN_HPP_NAMESPACE::Rect2D renderArea_ = {},
|
|
uint32_t clearValueCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::ClearValue* pClearValues_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: renderPass( renderPass_ )
|
|
, framebuffer( framebuffer_ )
|
|
, renderArea( renderArea_ )
|
|
, clearValueCount( clearValueCount_ )
|
|
, pClearValues( pClearValues_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( RenderPassBeginInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, renderPass( rhs.renderPass )
|
|
, framebuffer( rhs.framebuffer )
|
|
, renderArea( rhs.renderArea )
|
|
, clearValueCount( rhs.clearValueCount )
|
|
, pClearValues( rhs.pClearValues )
|
|
{}
|
|
|
|
RenderPassBeginInfo & operator=( RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassBeginInfo ) - offsetof( RenderPassBeginInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
RenderPassBeginInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassBeginInfo & setRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
renderPass = renderPass_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassBeginInfo & setFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
framebuffer = framebuffer_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassBeginInfo & setRenderArea( VULKAN_HPP_NAMESPACE::Rect2D renderArea_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
renderArea = renderArea_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassBeginInfo & setClearValueCount( uint32_t clearValueCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
clearValueCount = clearValueCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassBeginInfo & setPClearValues( const VULKAN_HPP_NAMESPACE::ClearValue* pClearValues_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pClearValues = pClearValues_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkRenderPassBeginInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkRenderPassBeginInfo*>( this );
|
|
}
|
|
|
|
operator VkRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkRenderPassBeginInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( RenderPassBeginInfo const& ) const = default;
|
|
#else
|
|
bool operator==( RenderPassBeginInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( renderPass == rhs.renderPass )
|
|
&& ( framebuffer == rhs.framebuffer )
|
|
&& ( renderArea == rhs.renderArea )
|
|
&& ( clearValueCount == rhs.clearValueCount )
|
|
&& ( pClearValues == rhs.pClearValues );
|
|
}
|
|
|
|
bool operator!=( RenderPassBeginInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassBeginInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::RenderPass renderPass = {};
|
|
VULKAN_HPP_NAMESPACE::Framebuffer framebuffer = {};
|
|
VULKAN_HPP_NAMESPACE::Rect2D renderArea = {};
|
|
uint32_t clearValueCount = {};
|
|
const VULKAN_HPP_NAMESPACE::ClearValue* pClearValues = {};
|
|
};
|
|
static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<RenderPassBeginInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct SubpassDescription
|
|
{
|
|
VULKAN_HPP_CONSTEXPR SubpassDescription( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ = {},
|
|
VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics,
|
|
uint32_t inputAttachmentCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference* pInputAttachments_ = {},
|
|
uint32_t colorAttachmentCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference* pColorAttachments_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference* pResolveAttachments_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference* pDepthStencilAttachment_ = {},
|
|
uint32_t preserveAttachmentCount_ = {},
|
|
const uint32_t* pPreserveAttachments_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, pipelineBindPoint( pipelineBindPoint_ )
|
|
, inputAttachmentCount( inputAttachmentCount_ )
|
|
, pInputAttachments( pInputAttachments_ )
|
|
, colorAttachmentCount( colorAttachmentCount_ )
|
|
, pColorAttachments( pColorAttachments_ )
|
|
, pResolveAttachments( pResolveAttachments_ )
|
|
, pDepthStencilAttachment( pDepthStencilAttachment_ )
|
|
, preserveAttachmentCount( preserveAttachmentCount_ )
|
|
, pPreserveAttachments( pPreserveAttachments_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR SubpassDescription( SubpassDescription const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: flags( rhs.flags )
|
|
, pipelineBindPoint( rhs.pipelineBindPoint )
|
|
, inputAttachmentCount( rhs.inputAttachmentCount )
|
|
, pInputAttachments( rhs.pInputAttachments )
|
|
, colorAttachmentCount( rhs.colorAttachmentCount )
|
|
, pColorAttachments( rhs.pColorAttachments )
|
|
, pResolveAttachments( rhs.pResolveAttachments )
|
|
, pDepthStencilAttachment( rhs.pDepthStencilAttachment )
|
|
, preserveAttachmentCount( rhs.preserveAttachmentCount )
|
|
, pPreserveAttachments( rhs.pPreserveAttachments )
|
|
{}
|
|
|
|
SubpassDescription & operator=( SubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( SubpassDescription ) );
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
SubpassDescription& operator=( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SubpassDescription const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setFlags( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setPipelineBindPoint( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pipelineBindPoint = pipelineBindPoint_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setInputAttachmentCount( uint32_t inputAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
inputAttachmentCount = inputAttachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setPInputAttachments( const VULKAN_HPP_NAMESPACE::AttachmentReference* pInputAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pInputAttachments = pInputAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
colorAttachmentCount = colorAttachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setPColorAttachments( const VULKAN_HPP_NAMESPACE::AttachmentReference* pColorAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pColorAttachments = pColorAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setPResolveAttachments( const VULKAN_HPP_NAMESPACE::AttachmentReference* pResolveAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pResolveAttachments = pResolveAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setPDepthStencilAttachment( const VULKAN_HPP_NAMESPACE::AttachmentReference* pDepthStencilAttachment_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pDepthStencilAttachment = pDepthStencilAttachment_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
preserveAttachmentCount = preserveAttachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription & setPPreserveAttachments( const uint32_t* pPreserveAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pPreserveAttachments = pPreserveAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkSubpassDescription const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkSubpassDescription*>( this );
|
|
}
|
|
|
|
operator VkSubpassDescription &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkSubpassDescription*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( SubpassDescription const& ) const = default;
|
|
#else
|
|
bool operator==( SubpassDescription const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( flags == rhs.flags )
|
|
&& ( pipelineBindPoint == rhs.pipelineBindPoint )
|
|
&& ( inputAttachmentCount == rhs.inputAttachmentCount )
|
|
&& ( pInputAttachments == rhs.pInputAttachments )
|
|
&& ( colorAttachmentCount == rhs.colorAttachmentCount )
|
|
&& ( pColorAttachments == rhs.pColorAttachments )
|
|
&& ( pResolveAttachments == rhs.pResolveAttachments )
|
|
&& ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
|
|
&& ( preserveAttachmentCount == rhs.preserveAttachmentCount )
|
|
&& ( pPreserveAttachments == rhs.pPreserveAttachments );
|
|
}
|
|
|
|
bool operator!=( SubpassDescription const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics;
|
|
uint32_t inputAttachmentCount = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference* pInputAttachments = {};
|
|
uint32_t colorAttachmentCount = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference* pColorAttachments = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference* pResolveAttachments = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference* pDepthStencilAttachment = {};
|
|
uint32_t preserveAttachmentCount = {};
|
|
const uint32_t* pPreserveAttachments = {};
|
|
};
|
|
static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<SubpassDescription>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct SubpassDependency
|
|
{
|
|
VULKAN_HPP_CONSTEXPR SubpassDependency( uint32_t srcSubpass_ = {},
|
|
uint32_t dstSubpass_ = {},
|
|
VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask_ = {},
|
|
VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask_ = {},
|
|
VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {},
|
|
VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {},
|
|
VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: srcSubpass( srcSubpass_ )
|
|
, dstSubpass( dstSubpass_ )
|
|
, srcStageMask( srcStageMask_ )
|
|
, dstStageMask( dstStageMask_ )
|
|
, srcAccessMask( srcAccessMask_ )
|
|
, dstAccessMask( dstAccessMask_ )
|
|
, dependencyFlags( dependencyFlags_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR SubpassDependency( SubpassDependency const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: srcSubpass( rhs.srcSubpass )
|
|
, dstSubpass( rhs.dstSubpass )
|
|
, srcStageMask( rhs.srcStageMask )
|
|
, dstStageMask( rhs.dstStageMask )
|
|
, srcAccessMask( rhs.srcAccessMask )
|
|
, dstAccessMask( rhs.dstAccessMask )
|
|
, dependencyFlags( rhs.dependencyFlags )
|
|
{}
|
|
|
|
SubpassDependency & operator=( SubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( SubpassDependency ) );
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
SubpassDependency& operator=( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SubpassDependency const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency & setSrcSubpass( uint32_t srcSubpass_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
srcSubpass = srcSubpass_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency & setDstSubpass( uint32_t dstSubpass_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstSubpass = dstSubpass_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency & setSrcStageMask( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
srcStageMask = srcStageMask_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency & setDstStageMask( VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstStageMask = dstStageMask_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency & setSrcAccessMask( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
srcAccessMask = srcAccessMask_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency & setDstAccessMask( VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstAccessMask = dstAccessMask_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency & setDependencyFlags( VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dependencyFlags = dependencyFlags_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkSubpassDependency const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkSubpassDependency*>( this );
|
|
}
|
|
|
|
operator VkSubpassDependency &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkSubpassDependency*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( SubpassDependency const& ) const = default;
|
|
#else
|
|
bool operator==( SubpassDependency const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( srcSubpass == rhs.srcSubpass )
|
|
&& ( dstSubpass == rhs.dstSubpass )
|
|
&& ( srcStageMask == rhs.srcStageMask )
|
|
&& ( dstStageMask == rhs.dstStageMask )
|
|
&& ( srcAccessMask == rhs.srcAccessMask )
|
|
&& ( dstAccessMask == rhs.dstAccessMask )
|
|
&& ( dependencyFlags == rhs.dependencyFlags );
|
|
}
|
|
|
|
bool operator!=( SubpassDependency const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
uint32_t srcSubpass = {};
|
|
uint32_t dstSubpass = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask = {};
|
|
VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask = {};
|
|
VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask = {};
|
|
VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags = {};
|
|
};
|
|
static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<SubpassDependency>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct RenderPassCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ = {},
|
|
uint32_t attachmentCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentDescription* pAttachments_ = {},
|
|
uint32_t subpassCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::SubpassDescription* pSubpasses_ = {},
|
|
uint32_t dependencyCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::SubpassDependency* pDependencies_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, attachmentCount( attachmentCount_ )
|
|
, pAttachments( pAttachments_ )
|
|
, subpassCount( subpassCount_ )
|
|
, pSubpasses( pSubpasses_ )
|
|
, dependencyCount( dependencyCount_ )
|
|
, pDependencies( pDependencies_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( RenderPassCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, attachmentCount( rhs.attachmentCount )
|
|
, pAttachments( rhs.pAttachments )
|
|
, subpassCount( rhs.subpassCount )
|
|
, pSubpasses( rhs.pSubpasses )
|
|
, dependencyCount( rhs.dependencyCount )
|
|
, pDependencies( rhs.pDependencies )
|
|
{}
|
|
|
|
RenderPassCreateInfo & operator=( RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassCreateInfo ) - offsetof( RenderPassCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo & setFlags( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo & setAttachmentCount( uint32_t attachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
attachmentCount = attachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo & setPAttachments( const VULKAN_HPP_NAMESPACE::AttachmentDescription* pAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pAttachments = pAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo & setSubpassCount( uint32_t subpassCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
subpassCount = subpassCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo & setPSubpasses( const VULKAN_HPP_NAMESPACE::SubpassDescription* pSubpasses_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pSubpasses = pSubpasses_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo & setDependencyCount( uint32_t dependencyCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dependencyCount = dependencyCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo & setPDependencies( const VULKAN_HPP_NAMESPACE::SubpassDependency* pDependencies_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pDependencies = pDependencies_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkRenderPassCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkRenderPassCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkRenderPassCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkRenderPassCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( RenderPassCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( RenderPassCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( attachmentCount == rhs.attachmentCount )
|
|
&& ( pAttachments == rhs.pAttachments )
|
|
&& ( subpassCount == rhs.subpassCount )
|
|
&& ( pSubpasses == rhs.pSubpasses )
|
|
&& ( dependencyCount == rhs.dependencyCount )
|
|
&& ( pDependencies == rhs.pDependencies );
|
|
}
|
|
|
|
bool operator!=( RenderPassCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassCreateInfo;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags = {};
|
|
uint32_t attachmentCount = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentDescription* pAttachments = {};
|
|
uint32_t subpassCount = {};
|
|
const VULKAN_HPP_NAMESPACE::SubpassDescription* pSubpasses = {};
|
|
uint32_t dependencyCount = {};
|
|
const VULKAN_HPP_NAMESPACE::SubpassDependency* pDependencies = {};
|
|
};
|
|
static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<RenderPassCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct SubpassDescription2KHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR SubpassDescription2KHR( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ = {},
|
|
VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics,
|
|
uint32_t viewMask_ = {},
|
|
uint32_t inputAttachmentCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pInputAttachments_ = {},
|
|
uint32_t colorAttachmentCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pColorAttachments_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pResolveAttachments_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pDepthStencilAttachment_ = {},
|
|
uint32_t preserveAttachmentCount_ = {},
|
|
const uint32_t* pPreserveAttachments_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, pipelineBindPoint( pipelineBindPoint_ )
|
|
, viewMask( viewMask_ )
|
|
, inputAttachmentCount( inputAttachmentCount_ )
|
|
, pInputAttachments( pInputAttachments_ )
|
|
, colorAttachmentCount( colorAttachmentCount_ )
|
|
, pColorAttachments( pColorAttachments_ )
|
|
, pResolveAttachments( pResolveAttachments_ )
|
|
, pDepthStencilAttachment( pDepthStencilAttachment_ )
|
|
, preserveAttachmentCount( preserveAttachmentCount_ )
|
|
, pPreserveAttachments( pPreserveAttachments_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR SubpassDescription2KHR( SubpassDescription2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, pipelineBindPoint( rhs.pipelineBindPoint )
|
|
, viewMask( rhs.viewMask )
|
|
, inputAttachmentCount( rhs.inputAttachmentCount )
|
|
, pInputAttachments( rhs.pInputAttachments )
|
|
, colorAttachmentCount( rhs.colorAttachmentCount )
|
|
, pColorAttachments( rhs.pColorAttachments )
|
|
, pResolveAttachments( rhs.pResolveAttachments )
|
|
, pDepthStencilAttachment( rhs.pDepthStencilAttachment )
|
|
, preserveAttachmentCount( rhs.preserveAttachmentCount )
|
|
, pPreserveAttachments( rhs.pPreserveAttachments )
|
|
{}
|
|
|
|
SubpassDescription2KHR & operator=( SubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( SubpassDescription2KHR ) - offsetof( SubpassDescription2KHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SubpassDescription2KHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setFlags( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setPipelineBindPoint( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pipelineBindPoint = pipelineBindPoint_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setViewMask( uint32_t viewMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
viewMask = viewMask_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setInputAttachmentCount( uint32_t inputAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
inputAttachmentCount = inputAttachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setPInputAttachments( const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pInputAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pInputAttachments = pInputAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
colorAttachmentCount = colorAttachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setPColorAttachments( const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pColorAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pColorAttachments = pColorAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setPResolveAttachments( const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pResolveAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pResolveAttachments = pResolveAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setPDepthStencilAttachment( const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pDepthStencilAttachment_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pDepthStencilAttachment = pDepthStencilAttachment_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
preserveAttachmentCount = preserveAttachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDescription2KHR & setPPreserveAttachments( const uint32_t* pPreserveAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pPreserveAttachments = pPreserveAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkSubpassDescription2KHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkSubpassDescription2KHR*>( this );
|
|
}
|
|
|
|
operator VkSubpassDescription2KHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkSubpassDescription2KHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( SubpassDescription2KHR const& ) const = default;
|
|
#else
|
|
bool operator==( SubpassDescription2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( pipelineBindPoint == rhs.pipelineBindPoint )
|
|
&& ( viewMask == rhs.viewMask )
|
|
&& ( inputAttachmentCount == rhs.inputAttachmentCount )
|
|
&& ( pInputAttachments == rhs.pInputAttachments )
|
|
&& ( colorAttachmentCount == rhs.colorAttachmentCount )
|
|
&& ( pColorAttachments == rhs.pColorAttachments )
|
|
&& ( pResolveAttachments == rhs.pResolveAttachments )
|
|
&& ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
|
|
&& ( preserveAttachmentCount == rhs.preserveAttachmentCount )
|
|
&& ( pPreserveAttachments == rhs.pPreserveAttachments );
|
|
}
|
|
|
|
bool operator!=( SubpassDescription2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassDescription2KHR;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics;
|
|
uint32_t viewMask = {};
|
|
uint32_t inputAttachmentCount = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pInputAttachments = {};
|
|
uint32_t colorAttachmentCount = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pColorAttachments = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pResolveAttachments = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentReference2KHR* pDepthStencilAttachment = {};
|
|
uint32_t preserveAttachmentCount = {};
|
|
const uint32_t* pPreserveAttachments = {};
|
|
};
|
|
static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<SubpassDescription2KHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct SubpassDependency2KHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR SubpassDependency2KHR( uint32_t srcSubpass_ = {},
|
|
uint32_t dstSubpass_ = {},
|
|
VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask_ = {},
|
|
VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask_ = {},
|
|
VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {},
|
|
VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {},
|
|
VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags_ = {},
|
|
int32_t viewOffset_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: srcSubpass( srcSubpass_ )
|
|
, dstSubpass( dstSubpass_ )
|
|
, srcStageMask( srcStageMask_ )
|
|
, dstStageMask( dstStageMask_ )
|
|
, srcAccessMask( srcAccessMask_ )
|
|
, dstAccessMask( dstAccessMask_ )
|
|
, dependencyFlags( dependencyFlags_ )
|
|
, viewOffset( viewOffset_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR SubpassDependency2KHR( SubpassDependency2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, srcSubpass( rhs.srcSubpass )
|
|
, dstSubpass( rhs.dstSubpass )
|
|
, srcStageMask( rhs.srcStageMask )
|
|
, dstStageMask( rhs.dstStageMask )
|
|
, srcAccessMask( rhs.srcAccessMask )
|
|
, dstAccessMask( rhs.dstAccessMask )
|
|
, dependencyFlags( rhs.dependencyFlags )
|
|
, viewOffset( rhs.viewOffset )
|
|
{}
|
|
|
|
SubpassDependency2KHR & operator=( SubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( SubpassDependency2KHR ) - offsetof( SubpassDependency2KHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SubpassDependency2KHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR & setSrcSubpass( uint32_t srcSubpass_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
srcSubpass = srcSubpass_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR & setDstSubpass( uint32_t dstSubpass_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstSubpass = dstSubpass_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR & setSrcStageMask( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
srcStageMask = srcStageMask_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR & setDstStageMask( VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstStageMask = dstStageMask_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR & setSrcAccessMask( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
srcAccessMask = srcAccessMask_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR & setDstAccessMask( VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstAccessMask = dstAccessMask_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR & setDependencyFlags( VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dependencyFlags = dependencyFlags_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassDependency2KHR & setViewOffset( int32_t viewOffset_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
viewOffset = viewOffset_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkSubpassDependency2KHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkSubpassDependency2KHR*>( this );
|
|
}
|
|
|
|
operator VkSubpassDependency2KHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkSubpassDependency2KHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( SubpassDependency2KHR const& ) const = default;
|
|
#else
|
|
bool operator==( SubpassDependency2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( srcSubpass == rhs.srcSubpass )
|
|
&& ( dstSubpass == rhs.dstSubpass )
|
|
&& ( srcStageMask == rhs.srcStageMask )
|
|
&& ( dstStageMask == rhs.dstStageMask )
|
|
&& ( srcAccessMask == rhs.srcAccessMask )
|
|
&& ( dstAccessMask == rhs.dstAccessMask )
|
|
&& ( dependencyFlags == rhs.dependencyFlags )
|
|
&& ( viewOffset == rhs.viewOffset );
|
|
}
|
|
|
|
bool operator!=( SubpassDependency2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassDependency2KHR;
|
|
const void* pNext = {};
|
|
uint32_t srcSubpass = {};
|
|
uint32_t dstSubpass = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask = {};
|
|
VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask = {};
|
|
VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask = {};
|
|
VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags = {};
|
|
int32_t viewOffset = {};
|
|
};
|
|
static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<SubpassDependency2KHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct RenderPassCreateInfo2KHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2KHR( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ = {},
|
|
uint32_t attachmentCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentDescription2KHR* pAttachments_ = {},
|
|
uint32_t subpassCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::SubpassDescription2KHR* pSubpasses_ = {},
|
|
uint32_t dependencyCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::SubpassDependency2KHR* pDependencies_ = {},
|
|
uint32_t correlatedViewMaskCount_ = {},
|
|
const uint32_t* pCorrelatedViewMasks_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, attachmentCount( attachmentCount_ )
|
|
, pAttachments( pAttachments_ )
|
|
, subpassCount( subpassCount_ )
|
|
, pSubpasses( pSubpasses_ )
|
|
, dependencyCount( dependencyCount_ )
|
|
, pDependencies( pDependencies_ )
|
|
, correlatedViewMaskCount( correlatedViewMaskCount_ )
|
|
, pCorrelatedViewMasks( pCorrelatedViewMasks_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2KHR( RenderPassCreateInfo2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, attachmentCount( rhs.attachmentCount )
|
|
, pAttachments( rhs.pAttachments )
|
|
, subpassCount( rhs.subpassCount )
|
|
, pSubpasses( rhs.pSubpasses )
|
|
, dependencyCount( rhs.dependencyCount )
|
|
, pDependencies( rhs.pDependencies )
|
|
, correlatedViewMaskCount( rhs.correlatedViewMaskCount )
|
|
, pCorrelatedViewMasks( rhs.pCorrelatedViewMasks )
|
|
{}
|
|
|
|
RenderPassCreateInfo2KHR & operator=( RenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassCreateInfo2KHR ) - offsetof( RenderPassCreateInfo2KHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2KHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setFlags( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setAttachmentCount( uint32_t attachmentCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
attachmentCount = attachmentCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setPAttachments( const VULKAN_HPP_NAMESPACE::AttachmentDescription2KHR* pAttachments_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pAttachments = pAttachments_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setSubpassCount( uint32_t subpassCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
subpassCount = subpassCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setPSubpasses( const VULKAN_HPP_NAMESPACE::SubpassDescription2KHR* pSubpasses_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pSubpasses = pSubpasses_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setDependencyCount( uint32_t dependencyCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dependencyCount = dependencyCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setPDependencies( const VULKAN_HPP_NAMESPACE::SubpassDependency2KHR* pDependencies_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pDependencies = pDependencies_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
correlatedViewMaskCount = correlatedViewMaskCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassCreateInfo2KHR & setPCorrelatedViewMasks( const uint32_t* pCorrelatedViewMasks_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pCorrelatedViewMasks = pCorrelatedViewMasks_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkRenderPassCreateInfo2KHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( this );
|
|
}
|
|
|
|
operator VkRenderPassCreateInfo2KHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkRenderPassCreateInfo2KHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( RenderPassCreateInfo2KHR const& ) const = default;
|
|
#else
|
|
bool operator==( RenderPassCreateInfo2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( attachmentCount == rhs.attachmentCount )
|
|
&& ( pAttachments == rhs.pAttachments )
|
|
&& ( subpassCount == rhs.subpassCount )
|
|
&& ( pSubpasses == rhs.pSubpasses )
|
|
&& ( dependencyCount == rhs.dependencyCount )
|
|
&& ( pDependencies == rhs.pDependencies )
|
|
&& ( correlatedViewMaskCount == rhs.correlatedViewMaskCount )
|
|
&& ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks );
|
|
}
|
|
|
|
bool operator!=( RenderPassCreateInfo2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassCreateInfo2KHR;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags = {};
|
|
uint32_t attachmentCount = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentDescription2KHR* pAttachments = {};
|
|
uint32_t subpassCount = {};
|
|
const VULKAN_HPP_NAMESPACE::SubpassDescription2KHR* pSubpasses = {};
|
|
uint32_t dependencyCount = {};
|
|
const VULKAN_HPP_NAMESPACE::SubpassDependency2KHR* pDependencies = {};
|
|
uint32_t correlatedViewMaskCount = {};
|
|
const uint32_t* pCorrelatedViewMasks = {};
|
|
};
|
|
static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<RenderPassCreateInfo2KHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct RenderPassFragmentDensityMapCreateInfoEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, fragmentDensityMapAttachment( rhs.fragmentDensityMapAttachment )
|
|
{}
|
|
|
|
RenderPassFragmentDensityMapCreateInfoEXT & operator=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) - offsetof( RenderPassFragmentDensityMapCreateInfoEXT, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
RenderPassFragmentDensityMapCreateInfoEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
fragmentDensityMapAttachment = fragmentDensityMapAttachment_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkRenderPassFragmentDensityMapCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>( this );
|
|
}
|
|
|
|
operator VkRenderPassFragmentDensityMapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const& ) const = default;
|
|
#else
|
|
bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment );
|
|
}
|
|
|
|
bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment = {};
|
|
};
|
|
static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<RenderPassFragmentDensityMapCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct RenderPassInputAttachmentAspectCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference* pAspectReferences_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: aspectReferenceCount( aspectReferenceCount_ )
|
|
, pAspectReferences( pAspectReferences_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( RenderPassInputAttachmentAspectCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, aspectReferenceCount( rhs.aspectReferenceCount )
|
|
, pAspectReferences( rhs.pAspectReferences )
|
|
{}
|
|
|
|
RenderPassInputAttachmentAspectCreateInfo & operator=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassInputAttachmentAspectCreateInfo ) - offsetof( RenderPassInputAttachmentAspectCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
RenderPassInputAttachmentAspectCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassInputAttachmentAspectCreateInfo & setAspectReferenceCount( uint32_t aspectReferenceCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
aspectReferenceCount = aspectReferenceCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassInputAttachmentAspectCreateInfo & setPAspectReferences( const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference* pAspectReferences_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pAspectReferences = pAspectReferences_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkRenderPassInputAttachmentAspectCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkRenderPassInputAttachmentAspectCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( aspectReferenceCount == rhs.aspectReferenceCount )
|
|
&& ( pAspectReferences == rhs.pAspectReferences );
|
|
}
|
|
|
|
bool operator!=( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
|
|
const void* pNext = {};
|
|
uint32_t aspectReferenceCount = {};
|
|
const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference* pAspectReferences = {};
|
|
};
|
|
static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<RenderPassInputAttachmentAspectCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct RenderPassMultiviewCreateInfo
|
|
{
|
|
VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = {},
|
|
const uint32_t* pViewMasks_ = {},
|
|
uint32_t dependencyCount_ = {},
|
|
const int32_t* pViewOffsets_ = {},
|
|
uint32_t correlationMaskCount_ = {},
|
|
const uint32_t* pCorrelationMasks_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: subpassCount( subpassCount_ )
|
|
, pViewMasks( pViewMasks_ )
|
|
, dependencyCount( dependencyCount_ )
|
|
, pViewOffsets( pViewOffsets_ )
|
|
, correlationMaskCount( correlationMaskCount_ )
|
|
, pCorrelationMasks( pCorrelationMasks_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( RenderPassMultiviewCreateInfo const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, subpassCount( rhs.subpassCount )
|
|
, pViewMasks( rhs.pViewMasks )
|
|
, dependencyCount( rhs.dependencyCount )
|
|
, pViewOffsets( rhs.pViewOffsets )
|
|
, correlationMaskCount( rhs.correlationMaskCount )
|
|
, pCorrelationMasks( rhs.pCorrelationMasks )
|
|
{}
|
|
|
|
RenderPassMultiviewCreateInfo & operator=( RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassMultiviewCreateInfo ) - offsetof( RenderPassMultiviewCreateInfo, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
RenderPassMultiviewCreateInfo & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassMultiviewCreateInfo & setSubpassCount( uint32_t subpassCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
subpassCount = subpassCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassMultiviewCreateInfo & setPViewMasks( const uint32_t* pViewMasks_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pViewMasks = pViewMasks_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassMultiviewCreateInfo & setDependencyCount( uint32_t dependencyCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dependencyCount = dependencyCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassMultiviewCreateInfo & setPViewOffsets( const int32_t* pViewOffsets_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pViewOffsets = pViewOffsets_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassMultiviewCreateInfo & setCorrelationMaskCount( uint32_t correlationMaskCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
correlationMaskCount = correlationMaskCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassMultiviewCreateInfo & setPCorrelationMasks( const uint32_t* pCorrelationMasks_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pCorrelationMasks = pCorrelationMasks_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkRenderPassMultiviewCreateInfo const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>( this );
|
|
}
|
|
|
|
operator VkRenderPassMultiviewCreateInfo &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( RenderPassMultiviewCreateInfo const& ) const = default;
|
|
#else
|
|
bool operator==( RenderPassMultiviewCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( subpassCount == rhs.subpassCount )
|
|
&& ( pViewMasks == rhs.pViewMasks )
|
|
&& ( dependencyCount == rhs.dependencyCount )
|
|
&& ( pViewOffsets == rhs.pViewOffsets )
|
|
&& ( correlationMaskCount == rhs.correlationMaskCount )
|
|
&& ( pCorrelationMasks == rhs.pCorrelationMasks );
|
|
}
|
|
|
|
bool operator!=( RenderPassMultiviewCreateInfo const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassMultiviewCreateInfo;
|
|
const void* pNext = {};
|
|
uint32_t subpassCount = {};
|
|
const uint32_t* pViewMasks = {};
|
|
uint32_t dependencyCount = {};
|
|
const int32_t* pViewOffsets = {};
|
|
uint32_t correlationMaskCount = {};
|
|
const uint32_t* pCorrelationMasks = {};
|
|
};
|
|
static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<RenderPassMultiviewCreateInfo>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct SubpassSampleLocationsEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( uint32_t subpassIndex_ = {},
|
|
VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: subpassIndex( subpassIndex_ )
|
|
, sampleLocationsInfo( sampleLocationsInfo_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( SubpassSampleLocationsEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: subpassIndex( rhs.subpassIndex )
|
|
, sampleLocationsInfo( rhs.sampleLocationsInfo )
|
|
{}
|
|
|
|
SubpassSampleLocationsEXT & operator=( SubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( SubpassSampleLocationsEXT ) );
|
|
return *this;
|
|
}
|
|
|
|
SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
SubpassSampleLocationsEXT & setSubpassIndex( uint32_t subpassIndex_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
subpassIndex = subpassIndex_;
|
|
return *this;
|
|
}
|
|
|
|
SubpassSampleLocationsEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
sampleLocationsInfo = sampleLocationsInfo_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkSubpassSampleLocationsEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>( this );
|
|
}
|
|
|
|
operator VkSubpassSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkSubpassSampleLocationsEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( SubpassSampleLocationsEXT const& ) const = default;
|
|
#else
|
|
bool operator==( SubpassSampleLocationsEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( subpassIndex == rhs.subpassIndex )
|
|
&& ( sampleLocationsInfo == rhs.sampleLocationsInfo );
|
|
}
|
|
|
|
bool operator!=( SubpassSampleLocationsEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
uint32_t subpassIndex = {};
|
|
VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo = {};
|
|
};
|
|
static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<SubpassSampleLocationsEXT>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct RenderPassSampleLocationsBeginInfoEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = {},
|
|
uint32_t postSubpassSampleLocationsCount_ = {},
|
|
const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
|
|
, pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
|
|
, postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
|
|
, pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( RenderPassSampleLocationsBeginInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, attachmentInitialSampleLocationsCount( rhs.attachmentInitialSampleLocationsCount )
|
|
, pAttachmentInitialSampleLocations( rhs.pAttachmentInitialSampleLocations )
|
|
, postSubpassSampleLocationsCount( rhs.postSubpassSampleLocationsCount )
|
|
, pPostSubpassSampleLocations( rhs.pPostSubpassSampleLocations )
|
|
{}
|
|
|
|
RenderPassSampleLocationsBeginInfoEXT & operator=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( RenderPassSampleLocationsBeginInfoEXT ) - offsetof( RenderPassSampleLocationsBeginInfoEXT, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
RenderPassSampleLocationsBeginInfoEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassSampleLocationsBeginInfoEXT & setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassSampleLocationsBeginInfoEXT & setPAttachmentInitialSampleLocations( const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassSampleLocationsBeginInfoEXT & setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_;
|
|
return *this;
|
|
}
|
|
|
|
RenderPassSampleLocationsBeginInfoEXT & setPPostSubpassSampleLocations( const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pPostSubpassSampleLocations = pPostSubpassSampleLocations_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkRenderPassSampleLocationsBeginInfoEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>( this );
|
|
}
|
|
|
|
operator VkRenderPassSampleLocationsBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const& ) const = default;
|
|
#else
|
|
bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount )
|
|
&& ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations )
|
|
&& ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount )
|
|
&& ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations );
|
|
}
|
|
|
|
bool operator!=( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
|
|
const void* pNext = {};
|
|
uint32_t attachmentInitialSampleLocationsCount = {};
|
|
const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations = {};
|
|
uint32_t postSubpassSampleLocationsCount = {};
|
|
const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT* pPostSubpassSampleLocations = {};
|
|
};
|
|
static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<RenderPassSampleLocationsBeginInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
|
} // namespace VULKAN_HPP_NAMESPACE
|