mirror of
https://github.com/skyline-emu/skyline.git
synced 2024-11-17 04:39:18 +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.
1325 lines
49 KiB
C++
1325 lines
49 KiB
C++
// Copyright (c) 2015-2019 The Khronos Group Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
// ---- Exceptions to the Apache 2.0 License: ----
|
|
//
|
|
// As an exception, if you use this Software to generate code and portions of
|
|
// this Software are embedded into the generated code as a result, you may
|
|
// redistribute such product without providing attribution as would otherwise
|
|
// be required by Sections 4(a), 4(b) and 4(d) of the License.
|
|
//
|
|
// In addition, if you combine or link code generated by this Software with
|
|
// software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1
|
|
// ("`Combined Software`") and if a court of competent jurisdiction determines
|
|
// that the patent provision (Section 3), the indemnity provision (Section 9)
|
|
// or other Section of the License conflicts with the conditions of the
|
|
// applicable GPL or LGPL license, you may retroactively and prospectively
|
|
// choose to deem waived or otherwise exclude such Section(s) of the License,
|
|
// but only in their entirety and only with respect to the Combined Software.
|
|
//
|
|
|
|
// This header is generated from the Khronos Vulkan XML API Registry.
|
|
|
|
#pragma once
|
|
|
|
#include "../handles.hpp"
|
|
#include "VkAcquire.hpp"
|
|
#include "VkAcceleration.hpp"
|
|
#include "VkApplication.hpp"
|
|
#include "VkAllocation.hpp"
|
|
#include "VkBind.hpp"
|
|
#include "VkCooperative.hpp"
|
|
#include "VkAndroid.hpp"
|
|
#include "VkDescriptor.hpp"
|
|
#include "VkBase.hpp"
|
|
#include "VkAttachment.hpp"
|
|
#include "VkBuffer.hpp"
|
|
#include "VkCalibrated.hpp"
|
|
#include "VkDevice.hpp"
|
|
#include "VkCheckpoint.hpp"
|
|
#include "VkConformance.hpp"
|
|
#include "VkClear.hpp"
|
|
#include "VkCmd.hpp"
|
|
#include "VkCoarse.hpp"
|
|
#include "VkCommand.hpp"
|
|
#include "VkComponent.hpp"
|
|
#include "VkCopy.hpp"
|
|
#include "VkCompute.hpp"
|
|
#include "VkConditional.hpp"
|
|
#include "VkD3D.hpp"
|
|
#include "VkDebug.hpp"
|
|
#include "VkDedicated.hpp"
|
|
#include "VkDispatch.hpp"
|
|
#include "VkDisplay.hpp"
|
|
|
|
namespace VULKAN_HPP_NAMESPACE
|
|
{
|
|
struct DisplayEventInfoEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT displayEvent_ = VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT
|
|
: displayEvent( displayEvent_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( DisplayEventInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, displayEvent( rhs.displayEvent )
|
|
{}
|
|
|
|
DisplayEventInfoEXT & operator=( DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayEventInfoEXT ) - offsetof( DisplayEventInfoEXT, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DisplayEventInfoEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayEventInfoEXT & setDisplayEvent( VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT displayEvent_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
displayEvent = displayEvent_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayEventInfoEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayEventInfoEXT*>( this );
|
|
}
|
|
|
|
operator VkDisplayEventInfoEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayEventInfoEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayEventInfoEXT const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayEventInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( displayEvent == rhs.displayEvent );
|
|
}
|
|
|
|
bool operator!=( DisplayEventInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayEventInfoEXT;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT displayEvent = VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT::eFirstPixelOut;
|
|
};
|
|
static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayEventInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayModeParametersKHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( VULKAN_HPP_NAMESPACE::Extent2D visibleRegion_ = {},
|
|
uint32_t refreshRate_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: visibleRegion( visibleRegion_ )
|
|
, refreshRate( refreshRate_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( DisplayModeParametersKHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: visibleRegion( rhs.visibleRegion )
|
|
, refreshRate( rhs.refreshRate )
|
|
{}
|
|
|
|
DisplayModeParametersKHR & operator=( DisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayModeParametersKHR ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DisplayModeParametersKHR & setVisibleRegion( VULKAN_HPP_NAMESPACE::Extent2D visibleRegion_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
visibleRegion = visibleRegion_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayModeParametersKHR & setRefreshRate( uint32_t refreshRate_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
refreshRate = refreshRate_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayModeParametersKHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayModeParametersKHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayModeParametersKHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayModeParametersKHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayModeParametersKHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayModeParametersKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( visibleRegion == rhs.visibleRegion )
|
|
&& ( refreshRate == rhs.refreshRate );
|
|
}
|
|
|
|
bool operator!=( DisplayModeParametersKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::Extent2D visibleRegion = {};
|
|
uint32_t refreshRate = {};
|
|
};
|
|
static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayModeParametersKHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayModeCreateInfoKHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR flags_ = {},
|
|
VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, parameters( parameters_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( DisplayModeCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, parameters( rhs.parameters )
|
|
{}
|
|
|
|
DisplayModeCreateInfoKHR & operator=( DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayModeCreateInfoKHR ) - offsetof( DisplayModeCreateInfoKHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DisplayModeCreateInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayModeCreateInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayModeCreateInfoKHR & setParameters( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
parameters = parameters_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayModeCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayModeCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayModeCreateInfoKHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayModeCreateInfoKHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayModeCreateInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( parameters == rhs.parameters );
|
|
}
|
|
|
|
bool operator!=( DisplayModeCreateInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR flags = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters = {};
|
|
};
|
|
static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayModeCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayModePropertiesKHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode_ = {},
|
|
VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: displayMode( displayMode_ )
|
|
, parameters( parameters_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( DisplayModePropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: displayMode( rhs.displayMode )
|
|
, parameters( rhs.parameters )
|
|
{}
|
|
|
|
DisplayModePropertiesKHR & operator=( DisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayModePropertiesKHR ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayModePropertiesKHR& operator=( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayModePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayModePropertiesKHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayModePropertiesKHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayModePropertiesKHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayModePropertiesKHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayModePropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( displayMode == rhs.displayMode )
|
|
&& ( parameters == rhs.parameters );
|
|
}
|
|
|
|
bool operator!=( DisplayModePropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters = {};
|
|
};
|
|
static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayModePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayModeProperties2KHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR displayModeProperties_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: displayModeProperties( displayModeProperties_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( DisplayModeProperties2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, displayModeProperties( rhs.displayModeProperties )
|
|
{}
|
|
|
|
DisplayModeProperties2KHR & operator=( DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayModeProperties2KHR ) - offsetof( DisplayModeProperties2KHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayModeProperties2KHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayModeProperties2KHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayModeProperties2KHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayModeProperties2KHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayModeProperties2KHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayModeProperties2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( displayModeProperties == rhs.displayModeProperties );
|
|
}
|
|
|
|
bool operator!=( DisplayModeProperties2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayModeProperties2KHR;
|
|
void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR displayModeProperties = {};
|
|
};
|
|
static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayModeProperties2KHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayNativeHdrSurfaceCapabilitiesAMD
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingSupport_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: localDimmingSupport( localDimmingSupport_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( DisplayNativeHdrSurfaceCapabilitiesAMD const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, localDimmingSupport( rhs.localDimmingSupport )
|
|
{}
|
|
|
|
DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) - offsetof( DisplayNativeHdrSurfaceCapabilitiesAMD, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>( this );
|
|
}
|
|
|
|
operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( localDimmingSupport == rhs.localDimmingSupport );
|
|
}
|
|
|
|
bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD;
|
|
void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 localDimmingSupport = {};
|
|
};
|
|
static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayNativeHdrSurfaceCapabilitiesAMD>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayPlaneCapabilitiesKHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR supportedAlpha_ = {},
|
|
VULKAN_HPP_NAMESPACE::Offset2D minSrcPosition_ = {},
|
|
VULKAN_HPP_NAMESPACE::Offset2D maxSrcPosition_ = {},
|
|
VULKAN_HPP_NAMESPACE::Extent2D minSrcExtent_ = {},
|
|
VULKAN_HPP_NAMESPACE::Extent2D maxSrcExtent_ = {},
|
|
VULKAN_HPP_NAMESPACE::Offset2D minDstPosition_ = {},
|
|
VULKAN_HPP_NAMESPACE::Offset2D maxDstPosition_ = {},
|
|
VULKAN_HPP_NAMESPACE::Extent2D minDstExtent_ = {},
|
|
VULKAN_HPP_NAMESPACE::Extent2D maxDstExtent_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: supportedAlpha( supportedAlpha_ )
|
|
, minSrcPosition( minSrcPosition_ )
|
|
, maxSrcPosition( maxSrcPosition_ )
|
|
, minSrcExtent( minSrcExtent_ )
|
|
, maxSrcExtent( maxSrcExtent_ )
|
|
, minDstPosition( minDstPosition_ )
|
|
, maxDstPosition( maxDstPosition_ )
|
|
, minDstExtent( minDstExtent_ )
|
|
, maxDstExtent( maxDstExtent_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( DisplayPlaneCapabilitiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: supportedAlpha( rhs.supportedAlpha )
|
|
, minSrcPosition( rhs.minSrcPosition )
|
|
, maxSrcPosition( rhs.maxSrcPosition )
|
|
, minSrcExtent( rhs.minSrcExtent )
|
|
, maxSrcExtent( rhs.maxSrcExtent )
|
|
, minDstPosition( rhs.minDstPosition )
|
|
, maxDstPosition( rhs.maxDstPosition )
|
|
, minDstExtent( rhs.minDstExtent )
|
|
, maxDstExtent( rhs.maxDstExtent )
|
|
{}
|
|
|
|
DisplayPlaneCapabilitiesKHR & operator=( DisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayPlaneCapabilitiesKHR ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayPlaneCapabilitiesKHR& operator=( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayPlaneCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayPlaneCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayPlaneCapabilitiesKHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( supportedAlpha == rhs.supportedAlpha )
|
|
&& ( minSrcPosition == rhs.minSrcPosition )
|
|
&& ( maxSrcPosition == rhs.maxSrcPosition )
|
|
&& ( minSrcExtent == rhs.minSrcExtent )
|
|
&& ( maxSrcExtent == rhs.maxSrcExtent )
|
|
&& ( minDstPosition == rhs.minDstPosition )
|
|
&& ( maxDstPosition == rhs.maxDstPosition )
|
|
&& ( minDstExtent == rhs.minDstExtent )
|
|
&& ( maxDstExtent == rhs.maxDstExtent );
|
|
}
|
|
|
|
bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR supportedAlpha = {};
|
|
VULKAN_HPP_NAMESPACE::Offset2D minSrcPosition = {};
|
|
VULKAN_HPP_NAMESPACE::Offset2D maxSrcPosition = {};
|
|
VULKAN_HPP_NAMESPACE::Extent2D minSrcExtent = {};
|
|
VULKAN_HPP_NAMESPACE::Extent2D maxSrcExtent = {};
|
|
VULKAN_HPP_NAMESPACE::Offset2D minDstPosition = {};
|
|
VULKAN_HPP_NAMESPACE::Offset2D maxDstPosition = {};
|
|
VULKAN_HPP_NAMESPACE::Extent2D minDstExtent = {};
|
|
VULKAN_HPP_NAMESPACE::Extent2D maxDstExtent = {};
|
|
};
|
|
static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayPlaneCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayPlaneCapabilities2KHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: capabilities( capabilities_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( DisplayPlaneCapabilities2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, capabilities( rhs.capabilities )
|
|
{}
|
|
|
|
DisplayPlaneCapabilities2KHR & operator=( DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPlaneCapabilities2KHR ) - offsetof( DisplayPlaneCapabilities2KHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayPlaneCapabilities2KHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayPlaneCapabilities2KHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayPlaneCapabilities2KHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayPlaneCapabilities2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( capabilities == rhs.capabilities );
|
|
}
|
|
|
|
bool operator!=( DisplayPlaneCapabilities2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
|
|
void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities = {};
|
|
};
|
|
static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayPlaneCapabilities2KHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayPlaneInfo2KHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode_ = {},
|
|
uint32_t planeIndex_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: mode( mode_ )
|
|
, planeIndex( planeIndex_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( DisplayPlaneInfo2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, mode( rhs.mode )
|
|
, planeIndex( rhs.planeIndex )
|
|
{}
|
|
|
|
DisplayPlaneInfo2KHR & operator=( DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPlaneInfo2KHR ) - offsetof( DisplayPlaneInfo2KHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DisplayPlaneInfo2KHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayPlaneInfo2KHR & setMode( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
mode = mode_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayPlaneInfo2KHR & setPlaneIndex( uint32_t planeIndex_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
planeIndex = planeIndex_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayPlaneInfo2KHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayPlaneInfo2KHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayPlaneInfo2KHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayPlaneInfo2KHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayPlaneInfo2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( mode == rhs.mode )
|
|
&& ( planeIndex == rhs.planeIndex );
|
|
}
|
|
|
|
bool operator!=( DisplayPlaneInfo2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPlaneInfo2KHR;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayModeKHR mode = {};
|
|
uint32_t planeIndex = {};
|
|
};
|
|
static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayPlaneInfo2KHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayPlanePropertiesKHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR currentDisplay_ = {},
|
|
uint32_t currentStackIndex_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: currentDisplay( currentDisplay_ )
|
|
, currentStackIndex( currentStackIndex_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( DisplayPlanePropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: currentDisplay( rhs.currentDisplay )
|
|
, currentStackIndex( rhs.currentStackIndex )
|
|
{}
|
|
|
|
DisplayPlanePropertiesKHR & operator=( DisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayPlanePropertiesKHR ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayPlanePropertiesKHR& operator=( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayPlanePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayPlanePropertiesKHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayPlanePropertiesKHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayPlanePropertiesKHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayPlanePropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( currentDisplay == rhs.currentDisplay )
|
|
&& ( currentStackIndex == rhs.currentStackIndex );
|
|
}
|
|
|
|
bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::DisplayKHR currentDisplay = {};
|
|
uint32_t currentStackIndex = {};
|
|
};
|
|
static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayPlanePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayPlaneProperties2KHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR displayPlaneProperties_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: displayPlaneProperties( displayPlaneProperties_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( DisplayPlaneProperties2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, displayPlaneProperties( rhs.displayPlaneProperties )
|
|
{}
|
|
|
|
DisplayPlaneProperties2KHR & operator=( DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPlaneProperties2KHR ) - offsetof( DisplayPlaneProperties2KHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayPlaneProperties2KHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayPlaneProperties2KHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayPlaneProperties2KHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayPlaneProperties2KHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayPlaneProperties2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( displayPlaneProperties == rhs.displayPlaneProperties );
|
|
}
|
|
|
|
bool operator!=( DisplayPlaneProperties2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPlaneProperties2KHR;
|
|
void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR displayPlaneProperties = {};
|
|
};
|
|
static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayPlaneProperties2KHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayPowerInfoEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT powerState_ = VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT
|
|
: powerState( powerState_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( DisplayPowerInfoEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, powerState( rhs.powerState )
|
|
{}
|
|
|
|
DisplayPowerInfoEXT & operator=( DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPowerInfoEXT ) - offsetof( DisplayPowerInfoEXT, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DisplayPowerInfoEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayPowerInfoEXT & setPowerState( VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT powerState_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
powerState = powerState_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayPowerInfoEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayPowerInfoEXT*>( this );
|
|
}
|
|
|
|
operator VkDisplayPowerInfoEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayPowerInfoEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayPowerInfoEXT const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayPowerInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( powerState == rhs.powerState );
|
|
}
|
|
|
|
bool operator!=( DisplayPowerInfoEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPowerInfoEXT;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT powerState = VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT::eOff;
|
|
};
|
|
static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayPowerInfoEXT>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayPresentInfoKHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( VULKAN_HPP_NAMESPACE::Rect2D srcRect_ = {},
|
|
VULKAN_HPP_NAMESPACE::Rect2D dstRect_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 persistent_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: srcRect( srcRect_ )
|
|
, dstRect( dstRect_ )
|
|
, persistent( persistent_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( DisplayPresentInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, srcRect( rhs.srcRect )
|
|
, dstRect( rhs.dstRect )
|
|
, persistent( rhs.persistent )
|
|
{}
|
|
|
|
DisplayPresentInfoKHR & operator=( DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayPresentInfoKHR ) - offsetof( DisplayPresentInfoKHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DisplayPresentInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayPresentInfoKHR & setSrcRect( VULKAN_HPP_NAMESPACE::Rect2D srcRect_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
srcRect = srcRect_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayPresentInfoKHR & setDstRect( VULKAN_HPP_NAMESPACE::Rect2D dstRect_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
dstRect = dstRect_;
|
|
return *this;
|
|
}
|
|
|
|
DisplayPresentInfoKHR & setPersistent( VULKAN_HPP_NAMESPACE::Bool32 persistent_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
persistent = persistent_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayPresentInfoKHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayPresentInfoKHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayPresentInfoKHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayPresentInfoKHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayPresentInfoKHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayPresentInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( srcRect == rhs.srcRect )
|
|
&& ( dstRect == rhs.dstRect )
|
|
&& ( persistent == rhs.persistent );
|
|
}
|
|
|
|
bool operator!=( DisplayPresentInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPresentInfoKHR;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::Rect2D srcRect = {};
|
|
VULKAN_HPP_NAMESPACE::Rect2D dstRect = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 persistent = {};
|
|
};
|
|
static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayPresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayPropertiesKHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display_ = {},
|
|
const char* displayName_ = {},
|
|
VULKAN_HPP_NAMESPACE::Extent2D physicalDimensions_ = {},
|
|
VULKAN_HPP_NAMESPACE::Extent2D physicalResolution_ = {},
|
|
VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR supportedTransforms_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 planeReorderPossible_ = {},
|
|
VULKAN_HPP_NAMESPACE::Bool32 persistentContent_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: display( display_ )
|
|
, displayName( displayName_ )
|
|
, physicalDimensions( physicalDimensions_ )
|
|
, physicalResolution( physicalResolution_ )
|
|
, supportedTransforms( supportedTransforms_ )
|
|
, planeReorderPossible( planeReorderPossible_ )
|
|
, persistentContent( persistentContent_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( DisplayPropertiesKHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: display( rhs.display )
|
|
, displayName( rhs.displayName )
|
|
, physicalDimensions( rhs.physicalDimensions )
|
|
, physicalResolution( rhs.physicalResolution )
|
|
, supportedTransforms( rhs.supportedTransforms )
|
|
, planeReorderPossible( rhs.planeReorderPossible )
|
|
, persistentContent( rhs.persistentContent )
|
|
{}
|
|
|
|
DisplayPropertiesKHR & operator=( DisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( DisplayPropertiesKHR ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayPropertiesKHR& operator=( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayPropertiesKHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayPropertiesKHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayPropertiesKHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayPropertiesKHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayPropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( display == rhs.display )
|
|
&& ( displayName == rhs.displayName )
|
|
&& ( physicalDimensions == rhs.physicalDimensions )
|
|
&& ( physicalResolution == rhs.physicalResolution )
|
|
&& ( supportedTransforms == rhs.supportedTransforms )
|
|
&& ( planeReorderPossible == rhs.planeReorderPossible )
|
|
&& ( persistentContent == rhs.persistentContent );
|
|
}
|
|
|
|
bool operator!=( DisplayPropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::DisplayKHR display = {};
|
|
const char* displayName = {};
|
|
VULKAN_HPP_NAMESPACE::Extent2D physicalDimensions = {};
|
|
VULKAN_HPP_NAMESPACE::Extent2D physicalResolution = {};
|
|
VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR supportedTransforms = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 planeReorderPossible = {};
|
|
VULKAN_HPP_NAMESPACE::Bool32 persistentContent = {};
|
|
};
|
|
static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplayProperties2KHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR displayProperties_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: displayProperties( displayProperties_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( DisplayProperties2KHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, displayProperties( rhs.displayProperties )
|
|
{}
|
|
|
|
DisplayProperties2KHR & operator=( DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplayProperties2KHR ) - offsetof( DisplayProperties2KHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplayProperties2KHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplayProperties2KHR*>( this );
|
|
}
|
|
|
|
operator VkDisplayProperties2KHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplayProperties2KHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplayProperties2KHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplayProperties2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( displayProperties == rhs.displayProperties );
|
|
}
|
|
|
|
bool operator!=( DisplayProperties2KHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayProperties2KHR;
|
|
void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR displayProperties = {};
|
|
};
|
|
static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplayProperties2KHR>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct DisplaySurfaceCreateInfoKHR
|
|
{
|
|
VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR flags_ = {},
|
|
VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode_ = {},
|
|
uint32_t planeIndex_ = {},
|
|
uint32_t planeStackIndex_ = {},
|
|
VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform_ = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity,
|
|
float globalAlpha_ = {},
|
|
VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR::eOpaque,
|
|
VULKAN_HPP_NAMESPACE::Extent2D imageExtent_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: flags( flags_ )
|
|
, displayMode( displayMode_ )
|
|
, planeIndex( planeIndex_ )
|
|
, planeStackIndex( planeStackIndex_ )
|
|
, transform( transform_ )
|
|
, globalAlpha( globalAlpha_ )
|
|
, alphaMode( alphaMode_ )
|
|
, imageExtent( imageExtent_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateInfoKHR const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, flags( rhs.flags )
|
|
, displayMode( rhs.displayMode )
|
|
, planeIndex( rhs.planeIndex )
|
|
, planeStackIndex( rhs.planeStackIndex )
|
|
, transform( rhs.transform )
|
|
, globalAlpha( rhs.globalAlpha )
|
|
, alphaMode( rhs.alphaMode )
|
|
, imageExtent( rhs.imageExtent )
|
|
{}
|
|
|
|
DisplaySurfaceCreateInfoKHR & operator=( DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( DisplaySurfaceCreateInfoKHR ) - offsetof( DisplaySurfaceCreateInfoKHR, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
flags = flags_;
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR & setDisplayMode( VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
displayMode = displayMode_;
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR & setPlaneIndex( uint32_t planeIndex_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
planeIndex = planeIndex_;
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR & setPlaneStackIndex( uint32_t planeStackIndex_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
planeStackIndex = planeStackIndex_;
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR & setTransform( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
transform = transform_;
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR & setGlobalAlpha( float globalAlpha_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
globalAlpha = globalAlpha_;
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR & setAlphaMode( VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
alphaMode = alphaMode_;
|
|
return *this;
|
|
}
|
|
|
|
DisplaySurfaceCreateInfoKHR & setImageExtent( VULKAN_HPP_NAMESPACE::Extent2D imageExtent_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
imageExtent = imageExtent_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkDisplaySurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( this );
|
|
}
|
|
|
|
operator VkDisplaySurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( DisplaySurfaceCreateInfoKHR const& ) const = default;
|
|
#else
|
|
bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( flags == rhs.flags )
|
|
&& ( displayMode == rhs.displayMode )
|
|
&& ( planeIndex == rhs.planeIndex )
|
|
&& ( planeStackIndex == rhs.planeStackIndex )
|
|
&& ( transform == rhs.transform )
|
|
&& ( globalAlpha == rhs.globalAlpha )
|
|
&& ( alphaMode == rhs.alphaMode )
|
|
&& ( imageExtent == rhs.imageExtent );
|
|
}
|
|
|
|
bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR flags = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode = {};
|
|
uint32_t planeIndex = {};
|
|
uint32_t planeStackIndex = {};
|
|
VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity;
|
|
float globalAlpha = {};
|
|
VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR alphaMode = VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR::eOpaque;
|
|
VULKAN_HPP_NAMESPACE::Extent2D imageExtent = {};
|
|
};
|
|
static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<DisplaySurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
|
|
} // namespace VULKAN_HPP_NAMESPACE
|