mirror of
https://github.com/skyline-emu/skyline.git
synced 2024-11-17 07:39:25 +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.
303 lines
11 KiB
C++
303 lines
11 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 "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"
|
|
|
|
namespace VULKAN_HPP_NAMESPACE
|
|
{
|
|
struct QueueFamilyCheckpointPropertiesNV
|
|
{
|
|
VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( VULKAN_HPP_NAMESPACE::PipelineStageFlags checkpointExecutionStageMask_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: checkpointExecutionStageMask( checkpointExecutionStageMask_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( QueueFamilyCheckpointPropertiesNV const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, checkpointExecutionStageMask( rhs.checkpointExecutionStageMask )
|
|
{}
|
|
|
|
QueueFamilyCheckpointPropertiesNV & operator=( QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( QueueFamilyCheckpointPropertiesNV ) - offsetof( QueueFamilyCheckpointPropertiesNV, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkQueueFamilyCheckpointPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>( this );
|
|
}
|
|
|
|
operator VkQueueFamilyCheckpointPropertiesNV &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( QueueFamilyCheckpointPropertiesNV const& ) const = default;
|
|
#else
|
|
bool operator==( QueueFamilyCheckpointPropertiesNV const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
|
|
}
|
|
|
|
bool operator!=( QueueFamilyCheckpointPropertiesNV const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
|
|
void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::PipelineStageFlags checkpointExecutionStageMask = {};
|
|
};
|
|
static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<QueueFamilyCheckpointPropertiesNV>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct QueueFamilyProperties
|
|
{
|
|
VULKAN_HPP_CONSTEXPR QueueFamilyProperties( VULKAN_HPP_NAMESPACE::QueueFlags queueFlags_ = {},
|
|
uint32_t queueCount_ = {},
|
|
uint32_t timestampValidBits_ = {},
|
|
VULKAN_HPP_NAMESPACE::Extent3D minImageTransferGranularity_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: queueFlags( queueFlags_ )
|
|
, queueCount( queueCount_ )
|
|
, timestampValidBits( timestampValidBits_ )
|
|
, minImageTransferGranularity( minImageTransferGranularity_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR QueueFamilyProperties( QueueFamilyProperties const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: queueFlags( rhs.queueFlags )
|
|
, queueCount( rhs.queueCount )
|
|
, timestampValidBits( rhs.timestampValidBits )
|
|
, minImageTransferGranularity( rhs.minImageTransferGranularity )
|
|
{}
|
|
|
|
QueueFamilyProperties & operator=( QueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( QueueFamilyProperties ) );
|
|
return *this;
|
|
}
|
|
|
|
QueueFamilyProperties( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
QueueFamilyProperties& operator=( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::QueueFamilyProperties const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkQueueFamilyProperties const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkQueueFamilyProperties*>( this );
|
|
}
|
|
|
|
operator VkQueueFamilyProperties &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkQueueFamilyProperties*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( QueueFamilyProperties const& ) const = default;
|
|
#else
|
|
bool operator==( QueueFamilyProperties const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( queueFlags == rhs.queueFlags )
|
|
&& ( queueCount == rhs.queueCount )
|
|
&& ( timestampValidBits == rhs.timestampValidBits )
|
|
&& ( minImageTransferGranularity == rhs.minImageTransferGranularity );
|
|
}
|
|
|
|
bool operator!=( QueueFamilyProperties const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
VULKAN_HPP_NAMESPACE::QueueFlags queueFlags = {};
|
|
uint32_t queueCount = {};
|
|
uint32_t timestampValidBits = {};
|
|
VULKAN_HPP_NAMESPACE::Extent3D minImageTransferGranularity = {};
|
|
};
|
|
static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<QueueFamilyProperties>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct QueueFamilyProperties2
|
|
{
|
|
VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( VULKAN_HPP_NAMESPACE::QueueFamilyProperties queueFamilyProperties_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: queueFamilyProperties( queueFamilyProperties_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( QueueFamilyProperties2 const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, queueFamilyProperties( rhs.queueFamilyProperties )
|
|
{}
|
|
|
|
QueueFamilyProperties2 & operator=( QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( QueueFamilyProperties2 ) - offsetof( QueueFamilyProperties2, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
operator VkQueueFamilyProperties2 const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkQueueFamilyProperties2*>( this );
|
|
}
|
|
|
|
operator VkQueueFamilyProperties2 &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkQueueFamilyProperties2*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( QueueFamilyProperties2 const& ) const = default;
|
|
#else
|
|
bool operator==( QueueFamilyProperties2 const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( queueFamilyProperties == rhs.queueFamilyProperties );
|
|
}
|
|
|
|
bool operator!=( QueueFamilyProperties2 const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyProperties2;
|
|
void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::QueueFamilyProperties queueFamilyProperties = {};
|
|
};
|
|
static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<QueueFamilyProperties2>::value, "struct wrapper is not a standard layout!" );
|
|
} // namespace VULKAN_HPP_NAMESPACE
|