Added 1.1.75 Vulkan header/registry files

Updated files come from the following locations:

include/vulkan/vulkan.hpp   Vulkan-Hpp:vulkan/vulkan.hpp

include/vulkan/*            Vulkan-Docs:include/vulkan/*

registry/cgenerator.py      Vulkan-Docs:xml/cgenerator.py
registry/generator.py       Vulkan-Docs:xml/generator.py
registry/genvk.py           Vulkan-Docs:xml/genvk.py
registry/vk.xml             Vulkan-Docs:xml/vk.xml
registry/reg.py             Vulkan-Docs:xml/reg.py
registry/validusage.json    Vulkan-Docs:out/validation/validusage.json
This commit is contained in:
Mike Schuchardt 2018-05-22 10:17:11 -06:00
parent eb0c1fd44c
commit 6bebd0015b
5 changed files with 61513 additions and 61093 deletions

View File

@ -36,7 +36,7 @@
# include <cassert>
# define VULKAN_HPP_ASSERT assert
#endif
static_assert( VK_HEADER_VERSION == 74 , "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 75 , "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@ -471,6 +471,11 @@ namespace VULKAN_HPP_NAMESPACE
linkAndCopy<StructureElements...>(rhs);
}
StructureChain(StructureElements const &... elems)
{
linkAndCopyElements<StructureElements...>(elems...);
}
StructureChain& operator=(StructureChain const &rhs)
{
linkAndCopy<StructureElements...>(rhs);
@ -512,7 +517,24 @@ namespace VULKAN_HPP_NAMESPACE
linkAndCopy<Y, Z...>(rhs);
}
template<typename X>
void linkAndCopyElements(X const &xelem)
{
static_cast<X&>(*this) = xelem;
}
template<typename X, typename Y, typename ...Z>
void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem)
{
static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!");
X& x = static_cast<X&>(*this);
Y& y = static_cast<Y&>(*this);
x = xelem;
x.pNext = &y;
linkAndCopyElements<Y, Z...>(yelem, zelem...);
}
};
enum class Result
{
eSuccess = VK_SUCCESS,
@ -4810,6 +4832,12 @@ public:
{
}
explicit Offset3D( Offset2D const& offset2D, int32_t z_ = 0 )
: x( offset2D.x )
, y( offset2D.y )
, z( z_ )
{}
Offset3D( VkOffset3D const & rhs )
{
memcpy( this, &rhs, sizeof( Offset3D ) );
@ -4921,6 +4949,12 @@ public:
{
}
explicit Extent3D( Extent2D const& extent2D, uint32_t depth_ = 0 )
: width( extent2D.width )
, height( extent2D.height )
, depth( depth_ )
{}
Extent3D( VkExtent3D const & rhs )
{
memcpy( this, &rhs, sizeof( Extent3D ) );
@ -6614,6 +6648,12 @@ public:
{
}
explicit RectLayerKHR( Rect2D const& rect2D, uint32_t layer_ = 0 )
: offset( rect2D.offset )
, extent( rect2D.extent )
, layer( layer_ )
{}
RectLayerKHR( VkRectLayerKHR const & rhs )
{
memcpy( this, &rhs, sizeof( RectLayerKHR ) );
@ -24953,6 +24993,12 @@ public:
{
}
explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, Pipeline pipeline_ = Pipeline() )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, pipeline( pipeline_ )
{}
ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
{
memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
@ -25014,6 +25060,13 @@ public:
{
}
explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, PipelineLayout pipelineLayout_ = PipelineLayout(), DescriptorSet descriptorSet_ = DescriptorSet() )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, pipelineLayout( pipelineLayout_ )
, descriptorSet( descriptorSet_ )
{}
ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
{
memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
@ -25082,6 +25135,12 @@ public:
{
}
explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, Buffer buffer_ = Buffer() )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, buffer( buffer_ )
{}
ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
{
memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
@ -25143,6 +25202,13 @@ public:
{
}
explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, Buffer buffer_ = Buffer(), IndexType indexType_ = IndexType::eUint16 )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, buffer( buffer_ )
, indexType( indexType_ )
{}
ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
{
memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
@ -25212,6 +25278,13 @@ public:
{
}
explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX, PipelineLayout pipelineLayout_ = PipelineLayout(), ShaderStageFlags stageFlags_ = ShaderStageFlags() )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, pipelineLayout( pipelineLayout_ )
, stageFlags( stageFlags_ )
{}
ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
{
memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
@ -38438,6 +38511,92 @@ public:
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
struct BaseOutStructure
{
BaseOutStructure( )
{
}
BaseOutStructure( VkBaseOutStructure const & rhs )
{
memcpy( this, &rhs, sizeof( BaseOutStructure ) );
}
BaseOutStructure& operator=( VkBaseOutStructure const & rhs )
{
memcpy( this, &rhs, sizeof( BaseOutStructure ) );
return *this;
}
BaseOutStructure& setPNext( struct BaseOutStructure* pNext_ )
{
pNext = pNext_;
return *this;
}
operator const VkBaseOutStructure&() const
{
return *reinterpret_cast<const VkBaseOutStructure*>(this);
}
bool operator==( BaseOutStructure const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext );
}
bool operator!=( BaseOutStructure const& rhs ) const
{
return !operator==( rhs );
}
StructureType sType;
struct BaseOutStructure* pNext = nullptr;
};
static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" );
struct BaseInStructure
{
BaseInStructure( )
{
}
BaseInStructure( VkBaseInStructure const & rhs )
{
memcpy( this, &rhs, sizeof( BaseInStructure ) );
}
BaseInStructure& operator=( VkBaseInStructure const & rhs )
{
memcpy( this, &rhs, sizeof( BaseInStructure ) );
return *this;
}
BaseInStructure& setPNext( const struct BaseInStructure* pNext_ )
{
pNext = pNext_;
return *this;
}
operator const VkBaseInStructure&() const
{
return *reinterpret_cast<const VkBaseInStructure*>(this);
}
bool operator==( BaseInStructure const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext );
}
bool operator!=( BaseInStructure const& rhs ) const
{
return !operator==( rhs );
}
StructureType sType;
const struct BaseInStructure* pNext = nullptr;
};
static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" );
template <> struct isStructureChainValid<PresentInfoKHR, DisplayPresentInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, DedicatedAllocationImageCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<BufferCreateInfo, DedicatedAllocationBufferCreateInfoNV>{ enum { value = true }; };

View File

@ -43,7 +43,7 @@ extern "C" {
#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
// Version of this file
#define VK_HEADER_VERSION 74
#define VK_HEADER_VERSION 75
#define VK_NULL_HANDLE 0
@ -2715,6 +2715,16 @@ typedef struct VkDrawIndirectCommand {
uint32_t firstInstance;
} VkDrawIndirectCommand;
typedef struct VkBaseOutStructure {
VkStructureType sType;
struct VkBaseOutStructure* pNext;
} VkBaseOutStructure;
typedef struct VkBaseInStructure {
VkStructureType sType;
const struct VkBaseInStructure* pNext;
} VkBaseInStructure;
typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);

View File

@ -96,11 +96,11 @@ class BaseInfo:
if selfKeys != infoKeys:
return False
# Ignore value of 'extname', as this will inherently be different
# when redefining the same interface in different feature and/or
# extension blocks.
# Ignore value of 'extname' and 'extnumber', as these will inherently
# be different when redefining the same interface in different feature
# and/or extension blocks.
for key in selfKeys:
if (key != 'extname' and
if (key != 'extname' and key != 'extnumber' and
(self.elem.get(key) != info.elem.get(key))):
return False
@ -563,14 +563,21 @@ class Registry:
if depname:
self.gen.logMsg('diag', 'Generating dependent type',
depname, 'for', attrib, 'type', typename)
# Don't recurse on self-referential structures.
if (typename != depname):
self.markTypeRequired(depname, required)
else:
self.gen.logMsg('diag', 'type', typename, 'is self-referential')
# Tag types used in defining this type (e.g. in nested
# <type> tags)
# Look for <type> in entire <command> tree,
# not just immediate children
for subtype in type.elem.findall('.//type'):
self.gen.logMsg('diag', 'markRequired: type requires dependent <type>', subtype.text)
if (typename != subtype.text):
self.markTypeRequired(subtype.text, required)
else:
self.gen.logMsg('diag', 'type', typename, 'is self-referential')
# Tag enums used in defining this type, for example in
# <member><name>member</name>[<enum>MEMBER_SIZE</enum>]</member>
for subenum in type.elem.findall('.//enum'):

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff