mirror of
https://github.com/skyline-emu/skyline.git
synced 2024-12-25 16:41:50 +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.
306 lines
10 KiB
C++
306 lines
10 KiB
C++
// Copyright (c) 2015-2019 The Khronos Group Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
// ---- Exceptions to the Apache 2.0 License: ----
|
|
//
|
|
// As an exception, if you use this Software to generate code and portions of
|
|
// this Software are embedded into the generated code as a result, you may
|
|
// redistribute such product without providing attribution as would otherwise
|
|
// be required by Sections 4(a), 4(b) and 4(d) of the License.
|
|
//
|
|
// In addition, if you combine or link code generated by this Software with
|
|
// software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1
|
|
// ("`Combined Software`") and if a court of competent jurisdiction determines
|
|
// that the patent provision (Section 3), the indemnity provision (Section 9)
|
|
// or other Section of the License conflicts with the conditions of the
|
|
// applicable GPL or LGPL license, you may retroactively and prospectively
|
|
// choose to deem waived or otherwise exclude such Section(s) of the License,
|
|
// but only in their entirety and only with respect to the Combined Software.
|
|
//
|
|
|
|
// This header is generated from the Khronos Vulkan XML API Registry.
|
|
|
|
#pragma once
|
|
|
|
#include "../handles.hpp"
|
|
#include "VkAcquire.hpp"
|
|
#include "VkAcceleration.hpp"
|
|
#include "VkApplication.hpp"
|
|
#include "VkAllocation.hpp"
|
|
#include "VkExternal.hpp"
|
|
#include "VkBind.hpp"
|
|
#include "VkCooperative.hpp"
|
|
#include "VkAndroid.hpp"
|
|
#include "VkDescriptor.hpp"
|
|
#include "VkBase.hpp"
|
|
#include "VkAttachment.hpp"
|
|
#include "VkBuffer.hpp"
|
|
#include "VkFramebuffer.hpp"
|
|
#include "VkCalibrated.hpp"
|
|
#include "VkDevice.hpp"
|
|
#include "VkCheckpoint.hpp"
|
|
#include "VkConformance.hpp"
|
|
#include "VkClear.hpp"
|
|
#include "VkCmd.hpp"
|
|
#include "VkExtension.hpp"
|
|
#include "VkCoarse.hpp"
|
|
#include "VkCommand.hpp"
|
|
#include "VkFormat.hpp"
|
|
#include "VkComponent.hpp"
|
|
#include "VkCopy.hpp"
|
|
#include "VkCompute.hpp"
|
|
#include "VkConditional.hpp"
|
|
#include "VkD3D.hpp"
|
|
#include "VkDebug.hpp"
|
|
#include "VkFence.hpp"
|
|
#include "VkDedicated.hpp"
|
|
#include "VkDraw.hpp"
|
|
#include "VkDispatch.hpp"
|
|
#include "VkDisplay.hpp"
|
|
#include "VkDrm.hpp"
|
|
#include "VkEvent.hpp"
|
|
#include "VkExport.hpp"
|
|
#include "VkExtent.hpp"
|
|
#include "VkFilter.hpp"
|
|
#include "VkGeometry.hpp"
|
|
#include "VkGraphics.hpp"
|
|
|
|
namespace VULKAN_HPP_NAMESPACE
|
|
{
|
|
struct XYColorEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR XYColorEXT( float x_ = {},
|
|
float y_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: x( x_ )
|
|
, y( y_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR XYColorEXT( XYColorEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: x( rhs.x )
|
|
, y( rhs.y )
|
|
{}
|
|
|
|
XYColorEXT & operator=( XYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( static_cast<void*>(this), &rhs, sizeof( XYColorEXT ) );
|
|
return *this;
|
|
}
|
|
|
|
XYColorEXT( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
XYColorEXT& operator=( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::XYColorEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
XYColorEXT & setX( float x_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
x = x_;
|
|
return *this;
|
|
}
|
|
|
|
XYColorEXT & setY( float y_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
y = y_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkXYColorEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkXYColorEXT*>( this );
|
|
}
|
|
|
|
operator VkXYColorEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkXYColorEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( XYColorEXT const& ) const = default;
|
|
#else
|
|
bool operator==( XYColorEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( x == rhs.x )
|
|
&& ( y == rhs.y );
|
|
}
|
|
|
|
bool operator!=( XYColorEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
float x = {};
|
|
float y = {};
|
|
};
|
|
static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<XYColorEXT>::value, "struct wrapper is not a standard layout!" );
|
|
|
|
struct HdrMetadataEXT
|
|
{
|
|
VULKAN_HPP_CONSTEXPR HdrMetadataEXT( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryRed_ = {},
|
|
VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryGreen_ = {},
|
|
VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryBlue_ = {},
|
|
VULKAN_HPP_NAMESPACE::XYColorEXT whitePoint_ = {},
|
|
float maxLuminance_ = {},
|
|
float minLuminance_ = {},
|
|
float maxContentLightLevel_ = {},
|
|
float maxFrameAverageLightLevel_ = {} ) VULKAN_HPP_NOEXCEPT
|
|
: displayPrimaryRed( displayPrimaryRed_ )
|
|
, displayPrimaryGreen( displayPrimaryGreen_ )
|
|
, displayPrimaryBlue( displayPrimaryBlue_ )
|
|
, whitePoint( whitePoint_ )
|
|
, maxLuminance( maxLuminance_ )
|
|
, minLuminance( minLuminance_ )
|
|
, maxContentLightLevel( maxContentLightLevel_ )
|
|
, maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
|
|
{}
|
|
|
|
VULKAN_HPP_CONSTEXPR HdrMetadataEXT( HdrMetadataEXT const& rhs ) VULKAN_HPP_NOEXCEPT
|
|
: pNext( rhs.pNext )
|
|
, displayPrimaryRed( rhs.displayPrimaryRed )
|
|
, displayPrimaryGreen( rhs.displayPrimaryGreen )
|
|
, displayPrimaryBlue( rhs.displayPrimaryBlue )
|
|
, whitePoint( rhs.whitePoint )
|
|
, maxLuminance( rhs.maxLuminance )
|
|
, minLuminance( rhs.minLuminance )
|
|
, maxContentLightLevel( rhs.maxContentLightLevel )
|
|
, maxFrameAverageLightLevel( rhs.maxFrameAverageLightLevel )
|
|
{}
|
|
|
|
HdrMetadataEXT & operator=( HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
memcpy( &pNext, &rhs.pNext, sizeof( HdrMetadataEXT ) - offsetof( HdrMetadataEXT, pNext ) );
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::HdrMetadataEXT const *>(&rhs);
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
pNext = pNext_;
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT & setDisplayPrimaryRed( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryRed_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
displayPrimaryRed = displayPrimaryRed_;
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT & setDisplayPrimaryGreen( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryGreen_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
displayPrimaryGreen = displayPrimaryGreen_;
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT & setDisplayPrimaryBlue( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryBlue_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
displayPrimaryBlue = displayPrimaryBlue_;
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT & setWhitePoint( VULKAN_HPP_NAMESPACE::XYColorEXT whitePoint_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
whitePoint = whitePoint_;
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT & setMaxLuminance( float maxLuminance_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
maxLuminance = maxLuminance_;
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT & setMinLuminance( float minLuminance_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
minLuminance = minLuminance_;
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT & setMaxContentLightLevel( float maxContentLightLevel_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
maxContentLightLevel = maxContentLightLevel_;
|
|
return *this;
|
|
}
|
|
|
|
HdrMetadataEXT & setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
maxFrameAverageLightLevel = maxFrameAverageLightLevel_;
|
|
return *this;
|
|
}
|
|
|
|
operator VkHdrMetadataEXT const&() const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<const VkHdrMetadataEXT*>( this );
|
|
}
|
|
|
|
operator VkHdrMetadataEXT &() VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return *reinterpret_cast<VkHdrMetadataEXT*>( this );
|
|
}
|
|
|
|
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
|
|
auto operator<=>( HdrMetadataEXT const& ) const = default;
|
|
#else
|
|
bool operator==( HdrMetadataEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ( sType == rhs.sType )
|
|
&& ( pNext == rhs.pNext )
|
|
&& ( displayPrimaryRed == rhs.displayPrimaryRed )
|
|
&& ( displayPrimaryGreen == rhs.displayPrimaryGreen )
|
|
&& ( displayPrimaryBlue == rhs.displayPrimaryBlue )
|
|
&& ( whitePoint == rhs.whitePoint )
|
|
&& ( maxLuminance == rhs.maxLuminance )
|
|
&& ( minLuminance == rhs.minLuminance )
|
|
&& ( maxContentLightLevel == rhs.maxContentLightLevel )
|
|
&& ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel );
|
|
}
|
|
|
|
bool operator!=( HdrMetadataEXT const& rhs ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return !operator==( rhs );
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eHdrMetadataEXT;
|
|
const void* pNext = {};
|
|
VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryRed = {};
|
|
VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryGreen = {};
|
|
VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryBlue = {};
|
|
VULKAN_HPP_NAMESPACE::XYColorEXT whitePoint = {};
|
|
float maxLuminance = {};
|
|
float minLuminance = {};
|
|
float maxContentLightLevel = {};
|
|
float maxFrameAverageLightLevel = {};
|
|
};
|
|
static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" );
|
|
static_assert( std::is_standard_layout<HdrMetadataEXT>::value, "struct wrapper is not a standard layout!" );
|
|
} // namespace VULKAN_HPP_NAMESPACE
|