// Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:09.632589 -0500 EST m=+2.158027596. DO NOT EDIT.

package vk

import "unsafe"

// AabbPositionsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAabbPositionsKHR.html
type AabbPositionsKHR struct {
	MinX float32
	MinY float32
	MinZ float32
	MaxX float32
	MaxY float32
	MaxZ float32
}

type _vkAabbPositionsKHR = AabbPositionsKHR

func (s *_vkAabbPositionsKHR) Goify() *AabbPositionsKHR {
	rval := (*AabbPositionsKHR)(s)
	return rval
}
func (s *AabbPositionsKHR) Vulkanize() *_vkAabbPositionsKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkAabbPositionsKHR)(s)
	return rval
}

// AabbPositionsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAabbPositionsNV.html
type AabbPositionsNV struct {
}

type _vkAabbPositionsNV = AabbPositionsNV

func (s *_vkAabbPositionsNV) Goify() *AabbPositionsNV {
	rval := (*AabbPositionsNV)(s)
	return rval
}
func (s *AabbPositionsNV) Vulkanize() *_vkAabbPositionsNV {
	if s == nil {
		return nil
	}
	rval := (*_vkAabbPositionsNV)(s)
	return rval
}

// AccelerationStructureBuildGeometryInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html
type AccelerationStructureBuildGeometryInfoKHR struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR
	PNext                    unsafe.Pointer
	Typ                      AccelerationStructureTypeKHR
	Flags                    BuildAccelerationStructureFlagsKHR
	Mode                     BuildAccelerationStructureModeKHR
	SrcAccelerationStructure AccelerationStructureKHR
	DstAccelerationStructure AccelerationStructureKHR
	// geometryCount
	PGeometries  []AccelerationStructureGeometryKHR
	PpGeometries []*AccelerationStructureGeometryKHR
	ScratchData  DeviceOrHostAddressKHR
}

type _vkAccelerationStructureBuildGeometryInfoKHR struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	typ                      AccelerationStructureTypeKHR
	flags                    BuildAccelerationStructureFlagsKHR
	mode                     BuildAccelerationStructureModeKHR
	srcAccelerationStructure AccelerationStructureKHR
	dstAccelerationStructure AccelerationStructureKHR
	geometryCount            uint32
	pGeometries              *_vkAccelerationStructureGeometryKHR
	ppGeometries             **_vkAccelerationStructureGeometryKHR
	scratchData              _vkDeviceOrHostAddressKHR
}

func (s *_vkAccelerationStructureBuildGeometryInfoKHR) Goify() *AccelerationStructureBuildGeometryInfoKHR {
	rval := &AccelerationStructureBuildGeometryInfoKHR{
		PNext:                    (unsafe.Pointer)(s.pNext),
		Typ:                      (AccelerationStructureTypeKHR)(s.typ),
		Flags:                    (BuildAccelerationStructureFlagsKHR)(s.flags),
		Mode:                     (BuildAccelerationStructureModeKHR)(s.mode),
		SrcAccelerationStructure: (AccelerationStructureKHR)(s.srcAccelerationStructure),
		DstAccelerationStructure: (AccelerationStructureKHR)(s.dstAccelerationStructure),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pGeometries in returned struct
		// Unexpected pointer member ppGeometries in returned struct
		// Can't Goify union member scratchData
	}
	return rval
}
func (s *AccelerationStructureBuildGeometryInfoKHR) Vulkanize() *_vkAccelerationStructureBuildGeometryInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pGeometries *_vkAccelerationStructureGeometryKHR
	if len(s.PGeometries) > 0 {
		sl_pGeometries := make([]_vkAccelerationStructureGeometryKHR, len(s.PGeometries))
		for i, v := range s.PGeometries {
			sl_pGeometries[i] = *(v.Vulkanize())
		}
		psl_pGeometries = &sl_pGeometries[0]
	}

	var psl_ppGeometries **_vkAccelerationStructureGeometryKHR
	if len(s.PpGeometries) > 0 {
		sl_ppGeometries := make([]*_vkAccelerationStructureGeometryKHR, len(s.PpGeometries))
		for i, v := range s.PpGeometries {
			sl_ppGeometries[i] = v.Vulkanize()
		}
		psl_ppGeometries = &sl_ppGeometries[0]
	}
	rval := &_vkAccelerationStructureBuildGeometryInfoKHR{
		sType:                    STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                     /*cb*/
		typ:                      (AccelerationStructureTypeKHR)(s.Typ),                         /*cb*/
		flags:                    (BuildAccelerationStructureFlagsKHR)(s.Flags),                 /*cb*/
		mode:                     (BuildAccelerationStructureModeKHR)(s.Mode),                   /*cb*/
		srcAccelerationStructure: (AccelerationStructureKHR)(s.SrcAccelerationStructure),        /*cb*/
		dstAccelerationStructure: (AccelerationStructureKHR)(s.DstAccelerationStructure),        /*cb*/
		pGeometries:              psl_pGeometries,                                               /*c rem*/
		ppGeometries:             psl_ppGeometries,                                              /*c rem*/
		scratchData:              *s.ScratchData.Vulkanize(),                                    /*c union*/
	}
	rval.geometryCount = 0 // c6-b
	if uint32(len(s.PGeometries)) > rval.geometryCount {
		rval.geometryCount = uint32(len(s.PGeometries))
	}
	if uint32(len(s.PpGeometries)) > rval.geometryCount {
		rval.geometryCount = uint32(len(s.PpGeometries))
	}
	return rval
}

// AccelerationStructureBuildRangeInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildRangeInfoKHR.html
type AccelerationStructureBuildRangeInfoKHR struct {
	PrimitiveCount  uint32
	PrimitiveOffset uint32
	FirstVertex     uint32
	TransformOffset uint32
}

type _vkAccelerationStructureBuildRangeInfoKHR = AccelerationStructureBuildRangeInfoKHR

func (s *_vkAccelerationStructureBuildRangeInfoKHR) Goify() *AccelerationStructureBuildRangeInfoKHR {
	rval := (*AccelerationStructureBuildRangeInfoKHR)(s)
	return rval
}
func (s *AccelerationStructureBuildRangeInfoKHR) Vulkanize() *_vkAccelerationStructureBuildRangeInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkAccelerationStructureBuildRangeInfoKHR)(s)
	return rval
}

// AccelerationStructureBuildSizesInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildSizesInfoKHR.html
type AccelerationStructureBuildSizesInfoKHR struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR
	PNext                     unsafe.Pointer
	AccelerationStructureSize DeviceSize
	UpdateScratchSize         DeviceSize
	BuildScratchSize          DeviceSize
}

type _vkAccelerationStructureBuildSizesInfoKHR struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	accelerationStructureSize DeviceSize
	updateScratchSize         DeviceSize
	buildScratchSize          DeviceSize
}

func (s *_vkAccelerationStructureBuildSizesInfoKHR) Goify() *AccelerationStructureBuildSizesInfoKHR {
	rval := &AccelerationStructureBuildSizesInfoKHR{
		PNext:                     (unsafe.Pointer)(s.pNext),
		AccelerationStructureSize: (DeviceSize)(s.accelerationStructureSize),
		UpdateScratchSize:         (DeviceSize)(s.updateScratchSize),
		BuildScratchSize:          (DeviceSize)(s.buildScratchSize),
	}
	return rval
}
func (s *AccelerationStructureBuildSizesInfoKHR) Vulkanize() *_vkAccelerationStructureBuildSizesInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureBuildSizesInfoKHR{
		sType:                     STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR, /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                                  /*cb*/
		accelerationStructureSize: (DeviceSize)(s.AccelerationStructureSize),                  /*cb*/
		updateScratchSize:         (DeviceSize)(s.UpdateScratchSize),                          /*cb*/
		buildScratchSize:          (DeviceSize)(s.BuildScratchSize),                           /*cb*/
	}
	return rval
}

// AccelerationStructureCaptureDescriptorDataInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCaptureDescriptorDataInfoEXT.html
type AccelerationStructureCaptureDescriptorDataInfoEXT struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
	PNext                   unsafe.Pointer
	AccelerationStructure   AccelerationStructureKHR
	AccelerationStructureNV AccelerationStructureNV
}

type _vkAccelerationStructureCaptureDescriptorDataInfoEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	accelerationStructure   AccelerationStructureKHR
	accelerationStructureNV AccelerationStructureNV
}

func (s *_vkAccelerationStructureCaptureDescriptorDataInfoEXT) Goify() *AccelerationStructureCaptureDescriptorDataInfoEXT {
	rval := &AccelerationStructureCaptureDescriptorDataInfoEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		AccelerationStructure:   (AccelerationStructureKHR)(s.accelerationStructure),
		AccelerationStructureNV: (AccelerationStructureNV)(s.accelerationStructureNV),
	}
	return rval
}
func (s *AccelerationStructureCaptureDescriptorDataInfoEXT) Vulkanize() *_vkAccelerationStructureCaptureDescriptorDataInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureCaptureDescriptorDataInfoEXT{
		sType:                   STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                              /*cb*/
		accelerationStructure:   (AccelerationStructureKHR)(s.AccelerationStructure),                    /*cb*/
		accelerationStructureNV: (AccelerationStructureNV)(s.AccelerationStructureNV),                   /*cb*/
	}
	return rval
}

// AccelerationStructureCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoKHR.html
type AccelerationStructureCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR
	PNext       unsafe.Pointer
	CreateFlags AccelerationStructureCreateFlagsKHR
	Buffer      Buffer
	//  Specified in bytes;
	Offset        DeviceSize
	Size          DeviceSize
	Typ           AccelerationStructureTypeKHR
	DeviceAddress DeviceAddress
}

type _vkAccelerationStructureCreateInfoKHR struct {
	sType         StructureType
	pNext         unsafe.Pointer
	createFlags   AccelerationStructureCreateFlagsKHR
	buffer        Buffer
	offset        DeviceSize
	size          DeviceSize
	typ           AccelerationStructureTypeKHR
	deviceAddress DeviceAddress
}

func (s *_vkAccelerationStructureCreateInfoKHR) Goify() *AccelerationStructureCreateInfoKHR {
	rval := &AccelerationStructureCreateInfoKHR{
		PNext:         (unsafe.Pointer)(s.pNext),
		CreateFlags:   (AccelerationStructureCreateFlagsKHR)(s.createFlags),
		Buffer:        (Buffer)(s.buffer),
		Offset:        (DeviceSize)(s.offset),
		Size:          (DeviceSize)(s.size),
		Typ:           (AccelerationStructureTypeKHR)(s.typ),
		DeviceAddress: (DeviceAddress)(s.deviceAddress),
	}
	return rval
}
func (s *AccelerationStructureCreateInfoKHR) Vulkanize() *_vkAccelerationStructureCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureCreateInfoKHR{
		sType:         STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                             /*cb*/
		createFlags:   (AccelerationStructureCreateFlagsKHR)(s.CreateFlags),  /*cb*/
		buffer:        (Buffer)(s.Buffer),                                    /*cb*/
		offset:        (DeviceSize)(s.Offset),                                /*cb*/
		size:          (DeviceSize)(s.Size),                                  /*cb*/
		typ:           (AccelerationStructureTypeKHR)(s.Typ),                 /*cb*/
		deviceAddress: (DeviceAddress)(s.DeviceAddress),                      /*cb*/
	}
	return rval
}

// AccelerationStructureCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoNV.html
type AccelerationStructureCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV
	PNext         unsafe.Pointer
	CompactedSize DeviceSize
	Info          AccelerationStructureInfoNV
}

type _vkAccelerationStructureCreateInfoNV struct {
	sType         StructureType
	pNext         unsafe.Pointer
	compactedSize DeviceSize
	info          _vkAccelerationStructureInfoNV
}

func (s *_vkAccelerationStructureCreateInfoNV) Goify() *AccelerationStructureCreateInfoNV {
	rval := &AccelerationStructureCreateInfoNV{
		PNext:         (unsafe.Pointer)(s.pNext),
		CompactedSize: (DeviceSize)(s.compactedSize),
		Info:          *(s.info.Goify()),
	}
	return rval
}
func (s *AccelerationStructureCreateInfoNV) Vulkanize() *_vkAccelerationStructureCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureCreateInfoNV{
		sType:         STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                            /*cb*/
		compactedSize: (DeviceSize)(s.CompactedSize),                        /*cb*/
		info:          *(s.Info.Vulkanize()),                                /*c3*/
	}
	return rval
}

// AccelerationStructureDeviceAddressInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html
type AccelerationStructureDeviceAddressInfoKHR struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR
	PNext                 unsafe.Pointer
	AccelerationStructure AccelerationStructureKHR
}

type _vkAccelerationStructureDeviceAddressInfoKHR struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	accelerationStructure AccelerationStructureKHR
}

func (s *_vkAccelerationStructureDeviceAddressInfoKHR) Goify() *AccelerationStructureDeviceAddressInfoKHR {
	rval := &AccelerationStructureDeviceAddressInfoKHR{
		PNext:                 (unsafe.Pointer)(s.pNext),
		AccelerationStructure: (AccelerationStructureKHR)(s.accelerationStructure),
	}
	return rval
}
func (s *AccelerationStructureDeviceAddressInfoKHR) Vulkanize() *_vkAccelerationStructureDeviceAddressInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureDeviceAddressInfoKHR{
		sType:                 STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                     /*cb*/
		accelerationStructure: (AccelerationStructureKHR)(s.AccelerationStructure),           /*cb*/
	}
	return rval
}

// AccelerationStructureGeometryAabbsDataKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html
type AccelerationStructureGeometryAabbsDataKHR struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR
	PNext  unsafe.Pointer
	Data   DeviceOrHostAddressConstKHR
	Stride DeviceSize
}

type _vkAccelerationStructureGeometryAabbsDataKHR struct {
	sType  StructureType
	pNext  unsafe.Pointer
	data   _vkDeviceOrHostAddressConstKHR
	stride DeviceSize
}

func (s *_vkAccelerationStructureGeometryAabbsDataKHR) Goify() *AccelerationStructureGeometryAabbsDataKHR {
	rval := &AccelerationStructureGeometryAabbsDataKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Can't Goify union member data
		Stride: (DeviceSize)(s.stride),
	}
	return rval
}
func (s *AccelerationStructureGeometryAabbsDataKHR) Vulkanize() *_vkAccelerationStructureGeometryAabbsDataKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureGeometryAabbsDataKHR{
		sType:  STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                                     /*cb*/
		data:   *s.Data.Vulkanize(),                                           /*c union*/
		stride: (DeviceSize)(s.Stride),                                        /*cb*/
	}
	return rval
}

// AccelerationStructureGeometryInstancesDataKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html
type AccelerationStructureGeometryInstancesDataKHR struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR
	PNext           unsafe.Pointer
	ArrayOfPointers bool
	Data            DeviceOrHostAddressConstKHR
}

type _vkAccelerationStructureGeometryInstancesDataKHR struct {
	sType           StructureType
	pNext           unsafe.Pointer
	arrayOfPointers Bool32
	data            _vkDeviceOrHostAddressConstKHR
}

func (s *_vkAccelerationStructureGeometryInstancesDataKHR) Goify() *AccelerationStructureGeometryInstancesDataKHR {
	rval := &AccelerationStructureGeometryInstancesDataKHR{
		PNext:           (unsafe.Pointer)(s.pNext),
		ArrayOfPointers: translatePublic_Bool32(s.arrayOfPointers), /*default*/
		// Can't Goify union member data
	}
	return rval
}
func (s *AccelerationStructureGeometryInstancesDataKHR) Vulkanize() *_vkAccelerationStructureGeometryInstancesDataKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureGeometryInstancesDataKHR{
		sType:           STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                         /*cb*/
		arrayOfPointers: translateInternal_Bool32(s.ArrayOfPointers),                       /*default*/
		data:            *s.Data.Vulkanize(),                                               /*c union*/
	}
	return rval
}

// AccelerationStructureGeometryKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryKHR.html
type AccelerationStructureGeometryKHR struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR
	PNext        unsafe.Pointer
	GeometryType GeometryTypeKHR
	Geometry     AccelerationStructureGeometryDataKHR
	Flags        GeometryFlagsKHR
}

type _vkAccelerationStructureGeometryKHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	geometryType GeometryTypeKHR
	geometry     _vkAccelerationStructureGeometryDataKHR
	flags        GeometryFlagsKHR
}

func (s *_vkAccelerationStructureGeometryKHR) Goify() *AccelerationStructureGeometryKHR {
	rval := &AccelerationStructureGeometryKHR{
		PNext:        (unsafe.Pointer)(s.pNext),
		GeometryType: (GeometryTypeKHR)(s.geometryType),
		// Can't Goify union member geometry
		Flags: (GeometryFlagsKHR)(s.flags),
	}
	return rval
}
func (s *AccelerationStructureGeometryKHR) Vulkanize() *_vkAccelerationStructureGeometryKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureGeometryKHR{
		sType:        STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                          /*cb*/
		geometryType: (GeometryTypeKHR)(s.GeometryType),                  /*cb*/
		geometry:     *s.Geometry.Vulkanize(),                            /*c union*/
		flags:        (GeometryFlagsKHR)(s.Flags),                        /*cb*/
	}
	return rval
}

// AccelerationStructureGeometryMotionTrianglesDataNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html
type AccelerationStructureGeometryMotionTrianglesDataNV struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV
	PNext      unsafe.Pointer
	VertexData DeviceOrHostAddressConstKHR
}

type _vkAccelerationStructureGeometryMotionTrianglesDataNV struct {
	sType      StructureType
	pNext      unsafe.Pointer
	vertexData _vkDeviceOrHostAddressConstKHR
}

func (s *_vkAccelerationStructureGeometryMotionTrianglesDataNV) Goify() *AccelerationStructureGeometryMotionTrianglesDataNV {
	rval := &AccelerationStructureGeometryMotionTrianglesDataNV{
		PNext: (unsafe.Pointer)(s.pNext),
		// Can't Goify union member vertexData
	}
	return rval
}
func (s *AccelerationStructureGeometryMotionTrianglesDataNV) Vulkanize() *_vkAccelerationStructureGeometryMotionTrianglesDataNV {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureGeometryMotionTrianglesDataNV{
		sType:      STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                                               /*cb*/
		vertexData: *s.VertexData.Vulkanize(),                                               /*c union*/
	}
	return rval
}

// AccelerationStructureGeometryTrianglesDataKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html
type AccelerationStructureGeometryTrianglesDataKHR struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR
	PNext         unsafe.Pointer
	VertexFormat  Format
	VertexData    DeviceOrHostAddressConstKHR
	VertexStride  DeviceSize
	MaxVertex     uint32
	IndexType     IndexType
	IndexData     DeviceOrHostAddressConstKHR
	TransformData DeviceOrHostAddressConstKHR
}

type _vkAccelerationStructureGeometryTrianglesDataKHR struct {
	sType         StructureType
	pNext         unsafe.Pointer
	vertexFormat  Format
	vertexData    _vkDeviceOrHostAddressConstKHR
	vertexStride  DeviceSize
	maxVertex     uint32
	indexType     IndexType
	indexData     _vkDeviceOrHostAddressConstKHR
	transformData _vkDeviceOrHostAddressConstKHR
}

func (s *_vkAccelerationStructureGeometryTrianglesDataKHR) Goify() *AccelerationStructureGeometryTrianglesDataKHR {
	rval := &AccelerationStructureGeometryTrianglesDataKHR{
		PNext:        (unsafe.Pointer)(s.pNext),
		VertexFormat: (Format)(s.vertexFormat),
		// Can't Goify union member vertexData
		VertexStride: (DeviceSize)(s.vertexStride),
		MaxVertex:    (uint32)(s.maxVertex),
		IndexType:    (IndexType)(s.indexType),
		// Can't Goify union member indexData
		// Can't Goify union member transformData
	}
	return rval
}
func (s *AccelerationStructureGeometryTrianglesDataKHR) Vulkanize() *_vkAccelerationStructureGeometryTrianglesDataKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureGeometryTrianglesDataKHR{
		sType:         STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                         /*cb*/
		vertexFormat:  (Format)(s.VertexFormat),                                          /*cb*/
		vertexData:    *s.VertexData.Vulkanize(),                                         /*c union*/
		vertexStride:  (DeviceSize)(s.VertexStride),                                      /*cb*/
		maxVertex:     (uint32)(s.MaxVertex),                                             /*cb*/
		indexType:     (IndexType)(s.IndexType),                                          /*cb*/
		indexData:     *s.IndexData.Vulkanize(),                                          /*c union*/
		transformData: *s.TransformData.Vulkanize(),                                      /*c union*/
	}
	return rval
}

// AccelerationStructureInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInfoNV.html
type AccelerationStructureInfoNV struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV
	PNext         unsafe.Pointer
	Typ           AccelerationStructureTypeNV
	Flags         BuildAccelerationStructureFlagsNV
	InstanceCount uint32
	// geometryCount
	PGeometries []GeometryNV
}

type _vkAccelerationStructureInfoNV struct {
	sType         StructureType
	pNext         unsafe.Pointer
	typ           AccelerationStructureTypeNV
	flags         BuildAccelerationStructureFlagsNV
	instanceCount uint32
	geometryCount uint32
	pGeometries   *_vkGeometryNV
}

func (s *_vkAccelerationStructureInfoNV) Goify() *AccelerationStructureInfoNV {
	rval := &AccelerationStructureInfoNV{
		PNext:         (unsafe.Pointer)(s.pNext),
		Typ:           (AccelerationStructureTypeNV)(s.typ),
		Flags:         (BuildAccelerationStructureFlagsNV)(s.flags),
		InstanceCount: (uint32)(s.instanceCount),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pGeometries in returned struct
	}
	return rval
}
func (s *AccelerationStructureInfoNV) Vulkanize() *_vkAccelerationStructureInfoNV {
	if s == nil {
		return nil
	}

	var psl_pGeometries *_vkGeometryNV
	if len(s.PGeometries) > 0 {
		sl_pGeometries := make([]_vkGeometryNV, len(s.PGeometries))
		for i, v := range s.PGeometries {
			sl_pGeometries[i] = *(v.Vulkanize())
		}
		psl_pGeometries = &sl_pGeometries[0]
	}
	rval := &_vkAccelerationStructureInfoNV{
		sType:         STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                     /*cb*/
		typ:           (AccelerationStructureTypeNV)(s.Typ),          /*cb*/
		flags:         (BuildAccelerationStructureFlagsNV)(s.Flags),  /*cb*/
		instanceCount: (uint32)(s.InstanceCount),                     /*cb*/
		geometryCount: uint32(len(s.PGeometries)),                    /*c6-a*/
		pGeometries:   psl_pGeometries,                               /*c rem*/
	}
	return rval
}

// AccelerationStructureInstanceKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInstanceKHR.html
type AccelerationStructureInstanceKHR struct {
	Transform                              TransformMatrixKHR
	InstanceCustomIndex                    uint32
	Mask                                   uint32
	InstanceShaderBindingTableRecordOffset uint32
	Flags                                  GeometryInstanceFlagsKHR
	AccelerationStructureReference         uint64
}

type _vkAccelerationStructureInstanceKHR struct {
	transform                              _vkTransformMatrixKHR
	instanceCustomIndex                    uint32
	mask                                   uint32
	instanceShaderBindingTableRecordOffset uint32
	flags                                  GeometryInstanceFlagsKHR
	accelerationStructureReference         uint64
}

func (s *_vkAccelerationStructureInstanceKHR) Goify() *AccelerationStructureInstanceKHR {
	rval := &AccelerationStructureInstanceKHR{
		Transform:                              (TransformMatrixKHR)(s.transform),
		InstanceCustomIndex:                    (uint32)(s.instanceCustomIndex),
		Mask:                                   (uint32)(s.mask),
		InstanceShaderBindingTableRecordOffset: (uint32)(s.instanceShaderBindingTableRecordOffset),
		Flags:                                  (GeometryInstanceFlagsKHR)(s.flags),
		AccelerationStructureReference:         (uint64)(s.accelerationStructureReference),
	}
	return rval
}
func (s *AccelerationStructureInstanceKHR) Vulkanize() *_vkAccelerationStructureInstanceKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureInstanceKHR{
		transform:                              (_vkTransformMatrixKHR)(s.Transform),               /*cb*/
		instanceCustomIndex:                    (uint32)(s.InstanceCustomIndex),                    /*cb*/
		mask:                                   (uint32)(s.Mask),                                   /*cb*/
		instanceShaderBindingTableRecordOffset: (uint32)(s.InstanceShaderBindingTableRecordOffset), /*cb*/
		flags:                                  (GeometryInstanceFlagsKHR)(s.Flags),                /*cb*/
		accelerationStructureReference:         (uint64)(s.AccelerationStructureReference),         /*cb*/
	}
	return rval
}

// AccelerationStructureInstanceNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInstanceNV.html
type AccelerationStructureInstanceNV struct {
}

type _vkAccelerationStructureInstanceNV = AccelerationStructureInstanceNV

func (s *_vkAccelerationStructureInstanceNV) Goify() *AccelerationStructureInstanceNV {
	rval := (*AccelerationStructureInstanceNV)(s)
	return rval
}
func (s *AccelerationStructureInstanceNV) Vulkanize() *_vkAccelerationStructureInstanceNV {
	if s == nil {
		return nil
	}
	rval := (*_vkAccelerationStructureInstanceNV)(s)
	return rval
}

// AccelerationStructureMatrixMotionInstanceNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMatrixMotionInstanceNV.html
type AccelerationStructureMatrixMotionInstanceNV struct {
	TransformT0                            TransformMatrixKHR
	TransformT1                            TransformMatrixKHR
	InstanceCustomIndex                    uint32
	Mask                                   uint32
	InstanceShaderBindingTableRecordOffset uint32
	Flags                                  GeometryInstanceFlagsKHR
	AccelerationStructureReference         uint64
}

type _vkAccelerationStructureMatrixMotionInstanceNV struct {
	transformT0                            _vkTransformMatrixKHR
	transformT1                            _vkTransformMatrixKHR
	instanceCustomIndex                    uint32
	mask                                   uint32
	instanceShaderBindingTableRecordOffset uint32
	flags                                  GeometryInstanceFlagsKHR
	accelerationStructureReference         uint64
}

func (s *_vkAccelerationStructureMatrixMotionInstanceNV) Goify() *AccelerationStructureMatrixMotionInstanceNV {
	rval := &AccelerationStructureMatrixMotionInstanceNV{
		TransformT0:                            (TransformMatrixKHR)(s.transformT0),
		TransformT1:                            (TransformMatrixKHR)(s.transformT1),
		InstanceCustomIndex:                    (uint32)(s.instanceCustomIndex),
		Mask:                                   (uint32)(s.mask),
		InstanceShaderBindingTableRecordOffset: (uint32)(s.instanceShaderBindingTableRecordOffset),
		Flags:                                  (GeometryInstanceFlagsKHR)(s.flags),
		AccelerationStructureReference:         (uint64)(s.accelerationStructureReference),
	}
	return rval
}
func (s *AccelerationStructureMatrixMotionInstanceNV) Vulkanize() *_vkAccelerationStructureMatrixMotionInstanceNV {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureMatrixMotionInstanceNV{
		transformT0:                            (_vkTransformMatrixKHR)(s.TransformT0),             /*cb*/
		transformT1:                            (_vkTransformMatrixKHR)(s.TransformT1),             /*cb*/
		instanceCustomIndex:                    (uint32)(s.InstanceCustomIndex),                    /*cb*/
		mask:                                   (uint32)(s.Mask),                                   /*cb*/
		instanceShaderBindingTableRecordOffset: (uint32)(s.InstanceShaderBindingTableRecordOffset), /*cb*/
		flags:                                  (GeometryInstanceFlagsKHR)(s.Flags),                /*cb*/
		accelerationStructureReference:         (uint64)(s.AccelerationStructureReference),         /*cb*/
	}
	return rval
}

// AccelerationStructureMemoryRequirementsInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html
type AccelerationStructureMemoryRequirementsInfoNV struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV
	PNext                 unsafe.Pointer
	Typ                   AccelerationStructureMemoryRequirementsTypeNV
	AccelerationStructure AccelerationStructureNV
}

type _vkAccelerationStructureMemoryRequirementsInfoNV struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	typ                   AccelerationStructureMemoryRequirementsTypeNV
	accelerationStructure AccelerationStructureNV
}

func (s *_vkAccelerationStructureMemoryRequirementsInfoNV) Goify() *AccelerationStructureMemoryRequirementsInfoNV {
	rval := &AccelerationStructureMemoryRequirementsInfoNV{
		PNext:                 (unsafe.Pointer)(s.pNext),
		Typ:                   (AccelerationStructureMemoryRequirementsTypeNV)(s.typ),
		AccelerationStructure: (AccelerationStructureNV)(s.accelerationStructure),
	}
	return rval
}
func (s *AccelerationStructureMemoryRequirementsInfoNV) Vulkanize() *_vkAccelerationStructureMemoryRequirementsInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureMemoryRequirementsInfoNV{
		sType:                 STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                         /*cb*/
		typ:                   (AccelerationStructureMemoryRequirementsTypeNV)(s.Typ),            /*cb*/
		accelerationStructure: (AccelerationStructureNV)(s.AccelerationStructure),                /*cb*/
	}
	return rval
}

// AccelerationStructureMotionInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoNV.html
type AccelerationStructureMotionInfoNV struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV
	PNext        unsafe.Pointer
	MaxInstances uint32
	Flags        AccelerationStructureMotionInfoFlagsNV
}

type _vkAccelerationStructureMotionInfoNV struct {
	sType        StructureType
	pNext        unsafe.Pointer
	maxInstances uint32
	flags        AccelerationStructureMotionInfoFlagsNV
}

func (s *_vkAccelerationStructureMotionInfoNV) Goify() *AccelerationStructureMotionInfoNV {
	rval := &AccelerationStructureMotionInfoNV{
		PNext:        (unsafe.Pointer)(s.pNext),
		MaxInstances: (uint32)(s.maxInstances),
		Flags:        (AccelerationStructureMotionInfoFlagsNV)(s.flags),
	}
	return rval
}
func (s *AccelerationStructureMotionInfoNV) Vulkanize() *_vkAccelerationStructureMotionInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureMotionInfoNV{
		sType:        STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                            /*cb*/
		maxInstances: (uint32)(s.MaxInstances),                             /*cb*/
		flags:        (AccelerationStructureMotionInfoFlagsNV)(s.Flags),    /*cb*/
	}
	return rval
}

// AccelerationStructureMotionInstanceNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceNV.html
type AccelerationStructureMotionInstanceNV struct {
	Typ   AccelerationStructureMotionInstanceTypeNV
	Flags AccelerationStructureMotionInstanceFlagsNV
	Data  AccelerationStructureMotionInstanceDataNV
}

type _vkAccelerationStructureMotionInstanceNV struct {
	typ   AccelerationStructureMotionInstanceTypeNV
	flags AccelerationStructureMotionInstanceFlagsNV
	data  _vkAccelerationStructureMotionInstanceDataNV
}

func (s *_vkAccelerationStructureMotionInstanceNV) Goify() *AccelerationStructureMotionInstanceNV {
	rval := &AccelerationStructureMotionInstanceNV{
		Typ:   (AccelerationStructureMotionInstanceTypeNV)(s.typ),
		Flags: (AccelerationStructureMotionInstanceFlagsNV)(s.flags),
		// Can't Goify union member data
	}
	return rval
}
func (s *AccelerationStructureMotionInstanceNV) Vulkanize() *_vkAccelerationStructureMotionInstanceNV {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureMotionInstanceNV{
		typ:   (AccelerationStructureMotionInstanceTypeNV)(s.Typ),    /*cb*/
		flags: (AccelerationStructureMotionInstanceFlagsNV)(s.Flags), /*cb*/
		data:  *s.Data.Vulkanize(),                                   /*c union*/
	}
	return rval
}

// AccelerationStructureSRTMotionInstanceNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureSRTMotionInstanceNV.html
type AccelerationStructureSRTMotionInstanceNV struct {
	TransformT0                            SRTDataNV
	TransformT1                            SRTDataNV
	InstanceCustomIndex                    uint32
	Mask                                   uint32
	InstanceShaderBindingTableRecordOffset uint32
	Flags                                  GeometryInstanceFlagsKHR
	AccelerationStructureReference         uint64
}

type _vkAccelerationStructureSRTMotionInstanceNV struct {
	transformT0                            _vkSRTDataNV
	transformT1                            _vkSRTDataNV
	instanceCustomIndex                    uint32
	mask                                   uint32
	instanceShaderBindingTableRecordOffset uint32
	flags                                  GeometryInstanceFlagsKHR
	accelerationStructureReference         uint64
}

func (s *_vkAccelerationStructureSRTMotionInstanceNV) Goify() *AccelerationStructureSRTMotionInstanceNV {
	rval := &AccelerationStructureSRTMotionInstanceNV{
		TransformT0:                            (SRTDataNV)(s.transformT0),
		TransformT1:                            (SRTDataNV)(s.transformT1),
		InstanceCustomIndex:                    (uint32)(s.instanceCustomIndex),
		Mask:                                   (uint32)(s.mask),
		InstanceShaderBindingTableRecordOffset: (uint32)(s.instanceShaderBindingTableRecordOffset),
		Flags:                                  (GeometryInstanceFlagsKHR)(s.flags),
		AccelerationStructureReference:         (uint64)(s.accelerationStructureReference),
	}
	return rval
}
func (s *AccelerationStructureSRTMotionInstanceNV) Vulkanize() *_vkAccelerationStructureSRTMotionInstanceNV {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureSRTMotionInstanceNV{
		transformT0:                            (_vkSRTDataNV)(s.TransformT0),                      /*cb*/
		transformT1:                            (_vkSRTDataNV)(s.TransformT1),                      /*cb*/
		instanceCustomIndex:                    (uint32)(s.InstanceCustomIndex),                    /*cb*/
		mask:                                   (uint32)(s.Mask),                                   /*cb*/
		instanceShaderBindingTableRecordOffset: (uint32)(s.InstanceShaderBindingTableRecordOffset), /*cb*/
		flags:                                  (GeometryInstanceFlagsKHR)(s.Flags),                /*cb*/
		accelerationStructureReference:         (uint64)(s.AccelerationStructureReference),         /*cb*/
	}
	return rval
}

// AccelerationStructureTrianglesOpacityMicromapEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureTrianglesOpacityMicromapEXT.html
type AccelerationStructureTrianglesOpacityMicromapEXT struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT
	PNext        unsafe.Pointer
	IndexType    IndexType
	IndexBuffer  DeviceOrHostAddressConstKHR
	IndexStride  DeviceSize
	BaseTriangle uint32
	// usageCountsCount
	PUsageCounts  []MicromapUsageEXT
	PpUsageCounts []*MicromapUsageEXT
	Micromap      MicromapEXT
}

type _vkAccelerationStructureTrianglesOpacityMicromapEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	indexType        IndexType
	indexBuffer      _vkDeviceOrHostAddressConstKHR
	indexStride      DeviceSize
	baseTriangle     uint32
	usageCountsCount uint32
	pUsageCounts     *_vkMicromapUsageEXT
	ppUsageCounts    **_vkMicromapUsageEXT
	micromap         MicromapEXT
}

func (s *_vkAccelerationStructureTrianglesOpacityMicromapEXT) Goify() *AccelerationStructureTrianglesOpacityMicromapEXT {
	rval := &AccelerationStructureTrianglesOpacityMicromapEXT{
		PNext:     (unsafe.Pointer)(s.pNext),
		IndexType: (IndexType)(s.indexType),
		// Can't Goify union member indexBuffer
		IndexStride:  (DeviceSize)(s.indexStride),
		BaseTriangle: (uint32)(s.baseTriangle),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pUsageCounts in returned struct
		// Unexpected pointer member ppUsageCounts in returned struct
		Micromap: (MicromapEXT)(s.micromap),
	}
	return rval
}
func (s *AccelerationStructureTrianglesOpacityMicromapEXT) Vulkanize() *_vkAccelerationStructureTrianglesOpacityMicromapEXT {
	if s == nil {
		return nil
	}

	var psl_pUsageCounts *_vkMicromapUsageEXT
	if len(s.PUsageCounts) > 0 {
		psl_pUsageCounts = &s.PUsageCounts[0]
	}

	var psl_ppUsageCounts **_vkMicromapUsageEXT
	if len(s.PpUsageCounts) > 0 {
		psl_ppUsageCounts = &s.PpUsageCounts[0]
	}
	rval := &_vkAccelerationStructureTrianglesOpacityMicromapEXT{
		sType:         STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                            /*cb*/
		indexType:     (IndexType)(s.IndexType),                                             /*cb*/
		indexBuffer:   *s.IndexBuffer.Vulkanize(),                                           /*c union*/
		indexStride:   (DeviceSize)(s.IndexStride),                                          /*cb*/
		baseTriangle:  (uint32)(s.BaseTriangle),                                             /*cb*/
		pUsageCounts:  psl_pUsageCounts,                                                     /*c rem*/
		ppUsageCounts: psl_ppUsageCounts,                                                    /*c rem*/
		micromap:      (MicromapEXT)(s.Micromap),                                            /*cb*/
	}
	rval.usageCountsCount = 0 // c6-b
	if uint32(len(s.PUsageCounts)) > rval.usageCountsCount {
		rval.usageCountsCount = uint32(len(s.PUsageCounts))
	}
	if uint32(len(s.PpUsageCounts)) > rval.usageCountsCount {
		rval.usageCountsCount = uint32(len(s.PpUsageCounts))
	}
	return rval
}

// AccelerationStructureVersionInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureVersionInfoKHR.html
type AccelerationStructureVersionInfoKHR struct {
	// SType = STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR
	PNext        unsafe.Pointer
	PVersionData *uint8
}

type _vkAccelerationStructureVersionInfoKHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	pVersionData *uint8
}

func (s *_vkAccelerationStructureVersionInfoKHR) Goify() *AccelerationStructureVersionInfoKHR {
	rval := &AccelerationStructureVersionInfoKHR{
		PNext:        (unsafe.Pointer)(s.pNext),
		PVersionData: (*uint8)(s.pVersionData),
	}
	return rval
}
func (s *AccelerationStructureVersionInfoKHR) Vulkanize() *_vkAccelerationStructureVersionInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAccelerationStructureVersionInfoKHR{
		sType:        STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                              /*cb*/
		pVersionData: (*uint8)(s.PVersionData),                               /*cb*/
	}
	return rval
}

// AcquireNextImageInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireNextImageInfoKHR.html
type AcquireNextImageInfoKHR struct {
	// SType = STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR
	PNext      unsafe.Pointer
	Swapchain  SwapchainKHR
	Timeout    uint64
	Semaphore  Semaphore
	Fence      Fence
	DeviceMask uint32
}

type _vkAcquireNextImageInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	swapchain  SwapchainKHR
	timeout    uint64
	semaphore  Semaphore
	fence      Fence
	deviceMask uint32
}

func (s *_vkAcquireNextImageInfoKHR) Goify() *AcquireNextImageInfoKHR {
	rval := &AcquireNextImageInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		Swapchain:  (SwapchainKHR)(s.swapchain),
		Timeout:    (uint64)(s.timeout),
		Semaphore:  (Semaphore)(s.semaphore),
		Fence:      (Fence)(s.fence),
		DeviceMask: (uint32)(s.deviceMask),
	}
	return rval
}
func (s *AcquireNextImageInfoKHR) Vulkanize() *_vkAcquireNextImageInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAcquireNextImageInfoKHR{
		sType:      STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                  /*cb*/
		swapchain:  (SwapchainKHR)(s.Swapchain),                /*cb*/
		timeout:    (uint64)(s.Timeout),                        /*cb*/
		semaphore:  (Semaphore)(s.Semaphore),                   /*cb*/
		fence:      (Fence)(s.Fence),                           /*cb*/
		deviceMask: (uint32)(s.DeviceMask),                     /*cb*/
	}
	return rval
}

// AcquireProfilingLockInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireProfilingLockInfoKHR.html
type AcquireProfilingLockInfoKHR struct {
	// SType = STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR
	PNext unsafe.Pointer
	//  Acquire profiling lock flags;
	Flags   AcquireProfilingLockFlagsKHR
	Timeout uint64
}

type _vkAcquireProfilingLockInfoKHR struct {
	sType   StructureType
	pNext   unsafe.Pointer
	flags   AcquireProfilingLockFlagsKHR
	timeout uint64
}

func (s *_vkAcquireProfilingLockInfoKHR) Goify() *AcquireProfilingLockInfoKHR {
	rval := &AcquireProfilingLockInfoKHR{
		PNext:   (unsafe.Pointer)(s.pNext),
		Flags:   (AcquireProfilingLockFlagsKHR)(s.flags),
		Timeout: (uint64)(s.timeout),
	}
	return rval
}
func (s *AcquireProfilingLockInfoKHR) Vulkanize() *_vkAcquireProfilingLockInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkAcquireProfilingLockInfoKHR{
		sType:   STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR, /*c1*/
		pNext:   (unsafe.Pointer)(s.PNext),                      /*cb*/
		flags:   (AcquireProfilingLockFlagsKHR)(s.Flags),        /*cb*/
		timeout: (uint64)(s.Timeout),                            /*cb*/
	}
	return rval
}

// AllocationCallbacks: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAllocationCallbacks.html
type AllocationCallbacks struct {
	PUserData             unsafe.Pointer
	PfnAllocation         PFN_vkAllocationFunction
	PfnReallocation       PFN_vkReallocationFunction
	PfnFree               PFN_vkFreeFunction
	PfnInternalAllocation PFN_vkInternalAllocationNotification
	PfnInternalFree       PFN_vkInternalFreeNotification
}

type _vkAllocationCallbacks = AllocationCallbacks

func (s *_vkAllocationCallbacks) Goify() *AllocationCallbacks {
	rval := (*AllocationCallbacks)(s)
	return rval
}
func (s *AllocationCallbacks) Vulkanize() *_vkAllocationCallbacks {
	if s == nil {
		return nil
	}
	rval := (*_vkAllocationCallbacks)(s)
	return rval
}

// AmigoProfilingSubmitInfoSEC: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAmigoProfilingSubmitInfoSEC.html
type AmigoProfilingSubmitInfoSEC struct {
	// SType = STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC
	PNext               unsafe.Pointer
	FirstDrawTimestamp  uint64
	SwapBufferTimestamp uint64
}

type _vkAmigoProfilingSubmitInfoSEC struct {
	sType               StructureType
	pNext               unsafe.Pointer
	firstDrawTimestamp  uint64
	swapBufferTimestamp uint64
}

func (s *_vkAmigoProfilingSubmitInfoSEC) Goify() *AmigoProfilingSubmitInfoSEC {
	rval := &AmigoProfilingSubmitInfoSEC{
		PNext:               (unsafe.Pointer)(s.pNext),
		FirstDrawTimestamp:  (uint64)(s.firstDrawTimestamp),
		SwapBufferTimestamp: (uint64)(s.swapBufferTimestamp),
	}
	return rval
}
func (s *AmigoProfilingSubmitInfoSEC) Vulkanize() *_vkAmigoProfilingSubmitInfoSEC {
	if s == nil {
		return nil
	}
	rval := &_vkAmigoProfilingSubmitInfoSEC{
		sType:               STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                      /*cb*/
		firstDrawTimestamp:  (uint64)(s.FirstDrawTimestamp),                 /*cb*/
		swapBufferTimestamp: (uint64)(s.SwapBufferTimestamp),                /*cb*/
	}
	return rval
}

// ApplicationInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkApplicationInfo.html
type ApplicationInfo struct {
	// SType = STRUCTURE_TYPE_APPLICATION_INFO
	PNext              unsafe.Pointer
	PApplicationName   string
	ApplicationVersion uint32
	PEngineName        string
	EngineVersion      uint32
	ApiVersion         uint32
}

type _vkApplicationInfo struct {
	sType              StructureType
	pNext              unsafe.Pointer
	pApplicationName   *byte
	applicationVersion uint32
	pEngineName        *byte
	engineVersion      uint32
	apiVersion         uint32
}

func (s *_vkApplicationInfo) Goify() *ApplicationInfo {
	rval := &ApplicationInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected pointer member pApplicationName in returned struct
		ApplicationVersion: (uint32)(s.applicationVersion),
		// Unexpected pointer member pEngineName in returned struct
		EngineVersion: (uint32)(s.engineVersion),
		ApiVersion:    (uint32)(s.apiVersion),
	}
	return rval
}
func (s *ApplicationInfo) Vulkanize() *_vkApplicationInfo {
	if s == nil {
		return nil
	}
	rval := &_vkApplicationInfo{
		sType:              STRUCTURE_TYPE_APPLICATION_INFO,             /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                   /*cb*/
		pApplicationName:   sys_stringToBytePointer(s.PApplicationName), /*c rem*/
		applicationVersion: (uint32)(s.ApplicationVersion),              /*cb*/
		pEngineName:        sys_stringToBytePointer(s.PEngineName),      /*c rem*/
		engineVersion:      (uint32)(s.EngineVersion),                   /*cb*/
		apiVersion:         (uint32)(s.ApiVersion),                      /*cb*/
	}
	return rval
}

// ApplicationParametersEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkApplicationParametersEXT.html
type ApplicationParametersEXT struct {
	// SType = STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT
	PNext    unsafe.Pointer
	VendorID uint32
	DeviceID uint32
	Key      uint32
	Value    uint64
}

type _vkApplicationParametersEXT struct {
	sType    StructureType
	pNext    unsafe.Pointer
	vendorID uint32
	deviceID uint32
	key      uint32
	value    uint64
}

func (s *_vkApplicationParametersEXT) Goify() *ApplicationParametersEXT {
	rval := &ApplicationParametersEXT{
		PNext:    (unsafe.Pointer)(s.pNext),
		VendorID: (uint32)(s.vendorID),
		DeviceID: (uint32)(s.deviceID),
		Key:      (uint32)(s.key),
		Value:    (uint64)(s.value),
	}
	return rval
}
func (s *ApplicationParametersEXT) Vulkanize() *_vkApplicationParametersEXT {
	if s == nil {
		return nil
	}
	rval := &_vkApplicationParametersEXT{
		sType:    STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                 /*cb*/
		vendorID: (uint32)(s.VendorID),                      /*cb*/
		deviceID: (uint32)(s.DeviceID),                      /*cb*/
		key:      (uint32)(s.Key),                           /*cb*/
		value:    (uint64)(s.Value),                         /*cb*/
	}
	return rval
}

// AttachmentDescription: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription.html
type AttachmentDescription struct {
	Flags   AttachmentDescriptionFlags
	Format  Format
	Samples SampleCountFlagBits
	//  Load operation for color or depth data;
	LoadOp AttachmentLoadOp
	//  Store operation for color or depth data;
	StoreOp AttachmentStoreOp
	//  Load operation for stencil data;
	StencilLoadOp AttachmentLoadOp
	//  Store operation for stencil data;
	StencilStoreOp AttachmentStoreOp
	InitialLayout  ImageLayout
	FinalLayout    ImageLayout
}

type _vkAttachmentDescription = AttachmentDescription

func (s *_vkAttachmentDescription) Goify() *AttachmentDescription {
	rval := (*AttachmentDescription)(s)
	return rval
}
func (s *AttachmentDescription) Vulkanize() *_vkAttachmentDescription {
	if s == nil {
		return nil
	}
	rval := (*_vkAttachmentDescription)(s)
	return rval
}

// AttachmentDescription2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription2.html
type AttachmentDescription2 struct {
	// SType = STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2
	PNext   unsafe.Pointer
	Flags   AttachmentDescriptionFlags
	Format  Format
	Samples SampleCountFlagBits
	//  Load operation for color or depth data;
	LoadOp AttachmentLoadOp
	//  Store operation for color or depth data;
	StoreOp AttachmentStoreOp
	//  Load operation for stencil data;
	StencilLoadOp AttachmentLoadOp
	//  Store operation for stencil data;
	StencilStoreOp AttachmentStoreOp
	InitialLayout  ImageLayout
	FinalLayout    ImageLayout
}

type _vkAttachmentDescription2 struct {
	sType          StructureType
	pNext          unsafe.Pointer
	flags          AttachmentDescriptionFlags
	format         Format
	samples        SampleCountFlagBits
	loadOp         AttachmentLoadOp
	storeOp        AttachmentStoreOp
	stencilLoadOp  AttachmentLoadOp
	stencilStoreOp AttachmentStoreOp
	initialLayout  ImageLayout
	finalLayout    ImageLayout
}

func (s *_vkAttachmentDescription2) Goify() *AttachmentDescription2 {
	rval := &AttachmentDescription2{
		PNext:          (unsafe.Pointer)(s.pNext),
		Flags:          (AttachmentDescriptionFlags)(s.flags),
		Format:         (Format)(s.format),
		Samples:        (SampleCountFlagBits)(s.samples),
		LoadOp:         (AttachmentLoadOp)(s.loadOp),
		StoreOp:        (AttachmentStoreOp)(s.storeOp),
		StencilLoadOp:  (AttachmentLoadOp)(s.stencilLoadOp),
		StencilStoreOp: (AttachmentStoreOp)(s.stencilStoreOp),
		InitialLayout:  (ImageLayout)(s.initialLayout),
		FinalLayout:    (ImageLayout)(s.finalLayout),
	}
	return rval
}
func (s *AttachmentDescription2) Vulkanize() *_vkAttachmentDescription2 {
	if s == nil {
		return nil
	}
	rval := &_vkAttachmentDescription2{
		sType:          STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),               /*cb*/
		flags:          (AttachmentDescriptionFlags)(s.Flags),   /*cb*/
		format:         (Format)(s.Format),                      /*cb*/
		samples:        (SampleCountFlagBits)(s.Samples),        /*cb*/
		loadOp:         (AttachmentLoadOp)(s.LoadOp),            /*cb*/
		storeOp:        (AttachmentStoreOp)(s.StoreOp),          /*cb*/
		stencilLoadOp:  (AttachmentLoadOp)(s.StencilLoadOp),     /*cb*/
		stencilStoreOp: (AttachmentStoreOp)(s.StencilStoreOp),   /*cb*/
		initialLayout:  (ImageLayout)(s.InitialLayout),          /*cb*/
		finalLayout:    (ImageLayout)(s.FinalLayout),            /*cb*/
	}
	return rval
}

// AttachmentDescription2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription2KHR.html
type AttachmentDescription2KHR struct {
}

type _vkAttachmentDescription2KHR = AttachmentDescription2KHR

func (s *_vkAttachmentDescription2KHR) Goify() *AttachmentDescription2KHR {
	rval := (*AttachmentDescription2KHR)(s)
	return rval
}
func (s *AttachmentDescription2KHR) Vulkanize() *_vkAttachmentDescription2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkAttachmentDescription2KHR)(s)
	return rval
}

// AttachmentDescriptionStencilLayout: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionStencilLayout.html
type AttachmentDescriptionStencilLayout struct {
	// SType = STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT
	PNext                unsafe.Pointer
	StencilInitialLayout ImageLayout
	StencilFinalLayout   ImageLayout
}

type _vkAttachmentDescriptionStencilLayout struct {
	sType                StructureType
	pNext                unsafe.Pointer
	stencilInitialLayout ImageLayout
	stencilFinalLayout   ImageLayout
}

func (s *_vkAttachmentDescriptionStencilLayout) Goify() *AttachmentDescriptionStencilLayout {
	rval := &AttachmentDescriptionStencilLayout{
		PNext:                (unsafe.Pointer)(s.pNext),
		StencilInitialLayout: (ImageLayout)(s.stencilInitialLayout),
		StencilFinalLayout:   (ImageLayout)(s.stencilFinalLayout),
	}
	return rval
}
func (s *AttachmentDescriptionStencilLayout) Vulkanize() *_vkAttachmentDescriptionStencilLayout {
	if s == nil {
		return nil
	}
	rval := &_vkAttachmentDescriptionStencilLayout{
		sType:                STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                            /*cb*/
		stencilInitialLayout: (ImageLayout)(s.StencilInitialLayout),                /*cb*/
		stencilFinalLayout:   (ImageLayout)(s.StencilFinalLayout),                  /*cb*/
	}
	return rval
}

// AttachmentDescriptionStencilLayoutKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionStencilLayoutKHR.html
type AttachmentDescriptionStencilLayoutKHR struct {
}

type _vkAttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayoutKHR

func (s *_vkAttachmentDescriptionStencilLayoutKHR) Goify() *AttachmentDescriptionStencilLayoutKHR {
	rval := (*AttachmentDescriptionStencilLayoutKHR)(s)
	return rval
}
func (s *AttachmentDescriptionStencilLayoutKHR) Vulkanize() *_vkAttachmentDescriptionStencilLayoutKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkAttachmentDescriptionStencilLayoutKHR)(s)
	return rval
}

// AttachmentReference: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference.html
type AttachmentReference struct {
	Attachment uint32
	Layout     ImageLayout
}

type _vkAttachmentReference = AttachmentReference

func (s *_vkAttachmentReference) Goify() *AttachmentReference {
	rval := (*AttachmentReference)(s)
	return rval
}
func (s *AttachmentReference) Vulkanize() *_vkAttachmentReference {
	if s == nil {
		return nil
	}
	rval := (*_vkAttachmentReference)(s)
	return rval
}

// AttachmentReference2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference2.html
type AttachmentReference2 struct {
	// SType = STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2
	PNext      unsafe.Pointer
	Attachment uint32
	Layout     ImageLayout
	AspectMask ImageAspectFlags
}

type _vkAttachmentReference2 struct {
	sType      StructureType
	pNext      unsafe.Pointer
	attachment uint32
	layout     ImageLayout
	aspectMask ImageAspectFlags
}

func (s *_vkAttachmentReference2) Goify() *AttachmentReference2 {
	rval := &AttachmentReference2{
		PNext:      (unsafe.Pointer)(s.pNext),
		Attachment: (uint32)(s.attachment),
		Layout:     (ImageLayout)(s.layout),
		AspectMask: (ImageAspectFlags)(s.aspectMask),
	}
	return rval
}
func (s *AttachmentReference2) Vulkanize() *_vkAttachmentReference2 {
	if s == nil {
		return nil
	}
	rval := &_vkAttachmentReference2{
		sType:      STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),             /*cb*/
		attachment: (uint32)(s.Attachment),                /*cb*/
		layout:     (ImageLayout)(s.Layout),               /*cb*/
		aspectMask: (ImageAspectFlags)(s.AspectMask),      /*cb*/
	}
	return rval
}

// AttachmentReference2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference2KHR.html
type AttachmentReference2KHR struct {
}

type _vkAttachmentReference2KHR = AttachmentReference2KHR

func (s *_vkAttachmentReference2KHR) Goify() *AttachmentReference2KHR {
	rval := (*AttachmentReference2KHR)(s)
	return rval
}
func (s *AttachmentReference2KHR) Vulkanize() *_vkAttachmentReference2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkAttachmentReference2KHR)(s)
	return rval
}

// AttachmentReferenceStencilLayout: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReferenceStencilLayout.html
type AttachmentReferenceStencilLayout struct {
	// SType = STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT
	PNext         unsafe.Pointer
	StencilLayout ImageLayout
}

type _vkAttachmentReferenceStencilLayout struct {
	sType         StructureType
	pNext         unsafe.Pointer
	stencilLayout ImageLayout
}

func (s *_vkAttachmentReferenceStencilLayout) Goify() *AttachmentReferenceStencilLayout {
	rval := &AttachmentReferenceStencilLayout{
		PNext:         (unsafe.Pointer)(s.pNext),
		StencilLayout: (ImageLayout)(s.stencilLayout),
	}
	return rval
}
func (s *AttachmentReferenceStencilLayout) Vulkanize() *_vkAttachmentReferenceStencilLayout {
	if s == nil {
		return nil
	}
	rval := &_vkAttachmentReferenceStencilLayout{
		sType:         STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                          /*cb*/
		stencilLayout: (ImageLayout)(s.StencilLayout),                     /*cb*/
	}
	return rval
}

// AttachmentReferenceStencilLayoutKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReferenceStencilLayoutKHR.html
type AttachmentReferenceStencilLayoutKHR struct {
}

type _vkAttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayoutKHR

func (s *_vkAttachmentReferenceStencilLayoutKHR) Goify() *AttachmentReferenceStencilLayoutKHR {
	rval := (*AttachmentReferenceStencilLayoutKHR)(s)
	return rval
}
func (s *AttachmentReferenceStencilLayoutKHR) Vulkanize() *_vkAttachmentReferenceStencilLayoutKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkAttachmentReferenceStencilLayoutKHR)(s)
	return rval
}

// AttachmentSampleCountInfoAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleCountInfoAMD.html
type AttachmentSampleCountInfoAMD struct {
	// SType = STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD
	PNext unsafe.Pointer
	// colorAttachmentCount
	PColorAttachmentSamples       []SampleCountFlagBits
	DepthStencilAttachmentSamples SampleCountFlagBits
}

type _vkAttachmentSampleCountInfoAMD struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	colorAttachmentCount          uint32
	pColorAttachmentSamples       *SampleCountFlagBits
	depthStencilAttachmentSamples SampleCountFlagBits
}

func (s *_vkAttachmentSampleCountInfoAMD) Goify() *AttachmentSampleCountInfoAMD {
	rval := &AttachmentSampleCountInfoAMD{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pColorAttachmentSamples in returned struct
		DepthStencilAttachmentSamples: (SampleCountFlagBits)(s.depthStencilAttachmentSamples),
	}
	return rval
}
func (s *AttachmentSampleCountInfoAMD) Vulkanize() *_vkAttachmentSampleCountInfoAMD {
	if s == nil {
		return nil
	}

	var psl_pColorAttachmentSamples *SampleCountFlagBits
	if len(s.PColorAttachmentSamples) > 0 {
		psl_pColorAttachmentSamples = &s.PColorAttachmentSamples[0]
	}
	rval := &_vkAttachmentSampleCountInfoAMD{
		sType:                         STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD,        /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                              /*cb*/
		colorAttachmentCount:          uint32(len(s.PColorAttachmentSamples)),                 /*c6-a*/
		pColorAttachmentSamples:       psl_pColorAttachmentSamples,                            /*c rem*/
		depthStencilAttachmentSamples: (SampleCountFlagBits)(s.DepthStencilAttachmentSamples), /*cb*/
	}
	return rval
}

// AttachmentSampleCountInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleCountInfoNV.html
type AttachmentSampleCountInfoNV struct {
}

type _vkAttachmentSampleCountInfoNV = AttachmentSampleCountInfoNV

func (s *_vkAttachmentSampleCountInfoNV) Goify() *AttachmentSampleCountInfoNV {
	rval := (*AttachmentSampleCountInfoNV)(s)
	return rval
}
func (s *AttachmentSampleCountInfoNV) Vulkanize() *_vkAttachmentSampleCountInfoNV {
	if s == nil {
		return nil
	}
	rval := (*_vkAttachmentSampleCountInfoNV)(s)
	return rval
}

// AttachmentSampleLocationsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleLocationsEXT.html
type AttachmentSampleLocationsEXT struct {
	AttachmentIndex     uint32
	SampleLocationsInfo SampleLocationsInfoEXT
}

type _vkAttachmentSampleLocationsEXT struct {
	attachmentIndex     uint32
	sampleLocationsInfo _vkSampleLocationsInfoEXT
}

func (s *_vkAttachmentSampleLocationsEXT) Goify() *AttachmentSampleLocationsEXT {
	rval := &AttachmentSampleLocationsEXT{
		AttachmentIndex:     (uint32)(s.attachmentIndex),
		SampleLocationsInfo: *(s.sampleLocationsInfo.Goify()),
	}
	return rval
}
func (s *AttachmentSampleLocationsEXT) Vulkanize() *_vkAttachmentSampleLocationsEXT {
	if s == nil {
		return nil
	}
	rval := &_vkAttachmentSampleLocationsEXT{
		attachmentIndex:     (uint32)(s.AttachmentIndex),          /*cb*/
		sampleLocationsInfo: *(s.SampleLocationsInfo.Vulkanize()), /*c3*/
	}
	return rval
}

// BaseInStructure: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseInStructure.html
type BaseInStructure struct {
	SType StructureType
	PNext *BaseInStructure
}

type _vkBaseInStructure = BaseInStructure

func (s *_vkBaseInStructure) Goify() *BaseInStructure {
	rval := (*BaseInStructure)(s)
	return rval
}
func (s *BaseInStructure) Vulkanize() *_vkBaseInStructure {
	if s == nil {
		return nil
	}
	rval := (*_vkBaseInStructure)(s)
	return rval
}

// BaseOutStructure: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseOutStructure.html
type BaseOutStructure struct {
	SType StructureType
	PNext *BaseOutStructure
}

type _vkBaseOutStructure = BaseOutStructure

func (s *_vkBaseOutStructure) Goify() *BaseOutStructure {
	rval := (*BaseOutStructure)(s)
	return rval
}
func (s *BaseOutStructure) Vulkanize() *_vkBaseOutStructure {
	if s == nil {
		return nil
	}
	rval := (*_vkBaseOutStructure)(s)
	return rval
}

// BindAccelerationStructureMemoryInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindAccelerationStructureMemoryInfoNV.html
type BindAccelerationStructureMemoryInfoNV struct {
	// SType = STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV
	PNext                 unsafe.Pointer
	AccelerationStructure AccelerationStructureNV
	Memory                DeviceMemory
	MemoryOffset          DeviceSize
	// deviceIndexCount
	PDeviceIndices []uint32
}

type _vkBindAccelerationStructureMemoryInfoNV struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	accelerationStructure AccelerationStructureNV
	memory                DeviceMemory
	memoryOffset          DeviceSize
	deviceIndexCount      uint32
	pDeviceIndices        *uint32
}

func (s *_vkBindAccelerationStructureMemoryInfoNV) Goify() *BindAccelerationStructureMemoryInfoNV {
	rval := &BindAccelerationStructureMemoryInfoNV{
		PNext:                 (unsafe.Pointer)(s.pNext),
		AccelerationStructure: (AccelerationStructureNV)(s.accelerationStructure),
		Memory:                (DeviceMemory)(s.memory),
		MemoryOffset:          (DeviceSize)(s.memoryOffset),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDeviceIndices in returned struct
	}
	return rval
}
func (s *BindAccelerationStructureMemoryInfoNV) Vulkanize() *_vkBindAccelerationStructureMemoryInfoNV {
	if s == nil {
		return nil
	}

	var psl_pDeviceIndices *uint32
	if len(s.PDeviceIndices) > 0 {
		psl_pDeviceIndices = &s.PDeviceIndices[0]
	}
	rval := &_vkBindAccelerationStructureMemoryInfoNV{
		sType:                 STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                 /*cb*/
		accelerationStructure: (AccelerationStructureNV)(s.AccelerationStructure),        /*cb*/
		memory:                (DeviceMemory)(s.Memory),                                  /*cb*/
		memoryOffset:          (DeviceSize)(s.MemoryOffset),                              /*cb*/
		deviceIndexCount:      uint32(len(s.PDeviceIndices)),                             /*c6-a*/
		pDeviceIndices:        psl_pDeviceIndices,                                        /*c rem*/
	}
	return rval
}

// BindBufferMemoryDeviceGroupInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryDeviceGroupInfo.html
type BindBufferMemoryDeviceGroupInfo struct {
	// SType = STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO
	PNext unsafe.Pointer
	// deviceIndexCount
	PDeviceIndices []uint32
}

type _vkBindBufferMemoryDeviceGroupInfo struct {
	sType            StructureType
	pNext            unsafe.Pointer
	deviceIndexCount uint32
	pDeviceIndices   *uint32
}

func (s *_vkBindBufferMemoryDeviceGroupInfo) Goify() *BindBufferMemoryDeviceGroupInfo {
	rval := &BindBufferMemoryDeviceGroupInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDeviceIndices in returned struct
	}
	return rval
}
func (s *BindBufferMemoryDeviceGroupInfo) Vulkanize() *_vkBindBufferMemoryDeviceGroupInfo {
	if s == nil {
		return nil
	}

	var psl_pDeviceIndices *uint32
	if len(s.PDeviceIndices) > 0 {
		psl_pDeviceIndices = &s.PDeviceIndices[0]
	}
	rval := &_vkBindBufferMemoryDeviceGroupInfo{
		sType:            STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                           /*cb*/
		deviceIndexCount: uint32(len(s.PDeviceIndices)),                       /*c6-a*/
		pDeviceIndices:   psl_pDeviceIndices,                                  /*c rem*/
	}
	return rval
}

// BindBufferMemoryDeviceGroupInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryDeviceGroupInfoKHR.html
type BindBufferMemoryDeviceGroupInfoKHR struct {
}

type _vkBindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfoKHR

func (s *_vkBindBufferMemoryDeviceGroupInfoKHR) Goify() *BindBufferMemoryDeviceGroupInfoKHR {
	rval := (*BindBufferMemoryDeviceGroupInfoKHR)(s)
	return rval
}
func (s *BindBufferMemoryDeviceGroupInfoKHR) Vulkanize() *_vkBindBufferMemoryDeviceGroupInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBindBufferMemoryDeviceGroupInfoKHR)(s)
	return rval
}

// BindBufferMemoryInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryInfo.html
type BindBufferMemoryInfo struct {
	// SType = STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO
	PNext        unsafe.Pointer
	Buffer       Buffer
	Memory       DeviceMemory
	MemoryOffset DeviceSize
}

type _vkBindBufferMemoryInfo struct {
	sType        StructureType
	pNext        unsafe.Pointer
	buffer       Buffer
	memory       DeviceMemory
	memoryOffset DeviceSize
}

func (s *_vkBindBufferMemoryInfo) Goify() *BindBufferMemoryInfo {
	rval := &BindBufferMemoryInfo{
		PNext:        (unsafe.Pointer)(s.pNext),
		Buffer:       (Buffer)(s.buffer),
		Memory:       (DeviceMemory)(s.memory),
		MemoryOffset: (DeviceSize)(s.memoryOffset),
	}
	return rval
}
func (s *BindBufferMemoryInfo) Vulkanize() *_vkBindBufferMemoryInfo {
	if s == nil {
		return nil
	}
	rval := &_vkBindBufferMemoryInfo{
		sType:        STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),              /*cb*/
		buffer:       (Buffer)(s.Buffer),                     /*cb*/
		memory:       (DeviceMemory)(s.Memory),               /*cb*/
		memoryOffset: (DeviceSize)(s.MemoryOffset),           /*cb*/
	}
	return rval
}

// BindBufferMemoryInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryInfoKHR.html
type BindBufferMemoryInfoKHR struct {
}

type _vkBindBufferMemoryInfoKHR = BindBufferMemoryInfoKHR

func (s *_vkBindBufferMemoryInfoKHR) Goify() *BindBufferMemoryInfoKHR {
	rval := (*BindBufferMemoryInfoKHR)(s)
	return rval
}
func (s *BindBufferMemoryInfoKHR) Vulkanize() *_vkBindBufferMemoryInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBindBufferMemoryInfoKHR)(s)
	return rval
}

// BindImageMemoryDeviceGroupInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryDeviceGroupInfo.html
type BindImageMemoryDeviceGroupInfo struct {
	// SType = STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO
	PNext unsafe.Pointer
	// deviceIndexCount
	PDeviceIndices []uint32
	// splitInstanceBindRegionCount
	PSplitInstanceBindRegions []Rect2D
}

type _vkBindImageMemoryDeviceGroupInfo struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	deviceIndexCount             uint32
	pDeviceIndices               *uint32
	splitInstanceBindRegionCount uint32
	pSplitInstanceBindRegions    *_vkRect2D
}

func (s *_vkBindImageMemoryDeviceGroupInfo) Goify() *BindImageMemoryDeviceGroupInfo {
	rval := &BindImageMemoryDeviceGroupInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDeviceIndices in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSplitInstanceBindRegions in returned struct
	}
	return rval
}
func (s *BindImageMemoryDeviceGroupInfo) Vulkanize() *_vkBindImageMemoryDeviceGroupInfo {
	if s == nil {
		return nil
	}

	var psl_pDeviceIndices *uint32
	if len(s.PDeviceIndices) > 0 {
		psl_pDeviceIndices = &s.PDeviceIndices[0]
	}

	var psl_pSplitInstanceBindRegions *_vkRect2D
	if len(s.PSplitInstanceBindRegions) > 0 {
		sl_pSplitInstanceBindRegions := make([]_vkRect2D, len(s.PSplitInstanceBindRegions))
		for i, v := range s.PSplitInstanceBindRegions {
			sl_pSplitInstanceBindRegions[i] = *(v.Vulkanize())
		}
		psl_pSplitInstanceBindRegions = &sl_pSplitInstanceBindRegions[0]
	}
	rval := &_vkBindImageMemoryDeviceGroupInfo{
		sType:                        STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                          /*cb*/
		deviceIndexCount:             uint32(len(s.PDeviceIndices)),                      /*c6-a*/
		pDeviceIndices:               psl_pDeviceIndices,                                 /*c rem*/
		splitInstanceBindRegionCount: uint32(len(s.PSplitInstanceBindRegions)),           /*c6-a*/
		pSplitInstanceBindRegions:    psl_pSplitInstanceBindRegions,                      /*c rem*/
	}
	return rval
}

// BindImageMemoryDeviceGroupInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryDeviceGroupInfoKHR.html
type BindImageMemoryDeviceGroupInfoKHR struct {
}

type _vkBindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfoKHR

func (s *_vkBindImageMemoryDeviceGroupInfoKHR) Goify() *BindImageMemoryDeviceGroupInfoKHR {
	rval := (*BindImageMemoryDeviceGroupInfoKHR)(s)
	return rval
}
func (s *BindImageMemoryDeviceGroupInfoKHR) Vulkanize() *_vkBindImageMemoryDeviceGroupInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBindImageMemoryDeviceGroupInfoKHR)(s)
	return rval
}

// BindImageMemoryInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryInfo.html
type BindImageMemoryInfo struct {
	// SType = STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO
	PNext        unsafe.Pointer
	Image        Image
	Memory       DeviceMemory
	MemoryOffset DeviceSize
}

type _vkBindImageMemoryInfo struct {
	sType        StructureType
	pNext        unsafe.Pointer
	image        Image
	memory       DeviceMemory
	memoryOffset DeviceSize
}

func (s *_vkBindImageMemoryInfo) Goify() *BindImageMemoryInfo {
	rval := &BindImageMemoryInfo{
		PNext:        (unsafe.Pointer)(s.pNext),
		Image:        (Image)(s.image),
		Memory:       (DeviceMemory)(s.memory),
		MemoryOffset: (DeviceSize)(s.memoryOffset),
	}
	return rval
}
func (s *BindImageMemoryInfo) Vulkanize() *_vkBindImageMemoryInfo {
	if s == nil {
		return nil
	}
	rval := &_vkBindImageMemoryInfo{
		sType:        STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),             /*cb*/
		image:        (Image)(s.Image),                      /*cb*/
		memory:       (DeviceMemory)(s.Memory),              /*cb*/
		memoryOffset: (DeviceSize)(s.MemoryOffset),          /*cb*/
	}
	return rval
}

// BindImageMemoryInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryInfoKHR.html
type BindImageMemoryInfoKHR struct {
}

type _vkBindImageMemoryInfoKHR = BindImageMemoryInfoKHR

func (s *_vkBindImageMemoryInfoKHR) Goify() *BindImageMemoryInfoKHR {
	rval := (*BindImageMemoryInfoKHR)(s)
	return rval
}
func (s *BindImageMemoryInfoKHR) Vulkanize() *_vkBindImageMemoryInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBindImageMemoryInfoKHR)(s)
	return rval
}

// BindImageMemorySwapchainInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemorySwapchainInfoKHR.html
type BindImageMemorySwapchainInfoKHR struct {
	// SType = STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR
	PNext      unsafe.Pointer
	Swapchain  SwapchainKHR
	ImageIndex uint32
}

type _vkBindImageMemorySwapchainInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	swapchain  SwapchainKHR
	imageIndex uint32
}

func (s *_vkBindImageMemorySwapchainInfoKHR) Goify() *BindImageMemorySwapchainInfoKHR {
	rval := &BindImageMemorySwapchainInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		Swapchain:  (SwapchainKHR)(s.swapchain),
		ImageIndex: (uint32)(s.imageIndex),
	}
	return rval
}
func (s *BindImageMemorySwapchainInfoKHR) Vulkanize() *_vkBindImageMemorySwapchainInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkBindImageMemorySwapchainInfoKHR{
		sType:      STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                           /*cb*/
		swapchain:  (SwapchainKHR)(s.Swapchain),                         /*cb*/
		imageIndex: (uint32)(s.ImageIndex),                              /*cb*/
	}
	return rval
}

// BindImagePlaneMemoryInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImagePlaneMemoryInfo.html
type BindImagePlaneMemoryInfo struct {
	// SType = STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO
	PNext       unsafe.Pointer
	PlaneAspect ImageAspectFlagBits
}

type _vkBindImagePlaneMemoryInfo struct {
	sType       StructureType
	pNext       unsafe.Pointer
	planeAspect ImageAspectFlagBits
}

func (s *_vkBindImagePlaneMemoryInfo) Goify() *BindImagePlaneMemoryInfo {
	rval := &BindImagePlaneMemoryInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		PlaneAspect: (ImageAspectFlagBits)(s.planeAspect),
	}
	return rval
}
func (s *BindImagePlaneMemoryInfo) Vulkanize() *_vkBindImagePlaneMemoryInfo {
	if s == nil {
		return nil
	}
	rval := &_vkBindImagePlaneMemoryInfo{
		sType:       STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                   /*cb*/
		planeAspect: (ImageAspectFlagBits)(s.PlaneAspect),        /*cb*/
	}
	return rval
}

// BindImagePlaneMemoryInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImagePlaneMemoryInfoKHR.html
type BindImagePlaneMemoryInfoKHR struct {
}

type _vkBindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfoKHR

func (s *_vkBindImagePlaneMemoryInfoKHR) Goify() *BindImagePlaneMemoryInfoKHR {
	rval := (*BindImagePlaneMemoryInfoKHR)(s)
	return rval
}
func (s *BindImagePlaneMemoryInfoKHR) Vulkanize() *_vkBindImagePlaneMemoryInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBindImagePlaneMemoryInfoKHR)(s)
	return rval
}

// BindIndexBufferIndirectCommandNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html
type BindIndexBufferIndirectCommandNV struct {
	BufferAddress DeviceAddress
	Size          uint32
	IndexType     IndexType
}

type _vkBindIndexBufferIndirectCommandNV = BindIndexBufferIndirectCommandNV

func (s *_vkBindIndexBufferIndirectCommandNV) Goify() *BindIndexBufferIndirectCommandNV {
	rval := (*BindIndexBufferIndirectCommandNV)(s)
	return rval
}
func (s *BindIndexBufferIndirectCommandNV) Vulkanize() *_vkBindIndexBufferIndirectCommandNV {
	if s == nil {
		return nil
	}
	rval := (*_vkBindIndexBufferIndirectCommandNV)(s)
	return rval
}

// BindPipelineIndirectCommandNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindPipelineIndirectCommandNV.html
type BindPipelineIndirectCommandNV struct {
	PipelineAddress DeviceAddress
}

type _vkBindPipelineIndirectCommandNV = BindPipelineIndirectCommandNV

func (s *_vkBindPipelineIndirectCommandNV) Goify() *BindPipelineIndirectCommandNV {
	rval := (*BindPipelineIndirectCommandNV)(s)
	return rval
}
func (s *BindPipelineIndirectCommandNV) Vulkanize() *_vkBindPipelineIndirectCommandNV {
	if s == nil {
		return nil
	}
	rval := (*_vkBindPipelineIndirectCommandNV)(s)
	return rval
}

// BindShaderGroupIndirectCommandNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html
type BindShaderGroupIndirectCommandNV struct {
	GroupIndex uint32
}

type _vkBindShaderGroupIndirectCommandNV = BindShaderGroupIndirectCommandNV

func (s *_vkBindShaderGroupIndirectCommandNV) Goify() *BindShaderGroupIndirectCommandNV {
	rval := (*BindShaderGroupIndirectCommandNV)(s)
	return rval
}
func (s *BindShaderGroupIndirectCommandNV) Vulkanize() *_vkBindShaderGroupIndirectCommandNV {
	if s == nil {
		return nil
	}
	rval := (*_vkBindShaderGroupIndirectCommandNV)(s)
	return rval
}

// BindSparseInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindSparseInfo.html
type BindSparseInfo struct {
	// SType = STRUCTURE_TYPE_BIND_SPARSE_INFO
	PNext unsafe.Pointer
	// waitSemaphoreCount
	PWaitSemaphores []Semaphore
	// bufferBindCount
	PBufferBinds []SparseBufferMemoryBindInfo
	// imageOpaqueBindCount
	PImageOpaqueBinds []SparseImageOpaqueMemoryBindInfo
	// imageBindCount
	PImageBinds []SparseImageMemoryBindInfo
	// signalSemaphoreCount
	PSignalSemaphores []Semaphore
}

type _vkBindSparseInfo struct {
	sType                StructureType
	pNext                unsafe.Pointer
	waitSemaphoreCount   uint32
	pWaitSemaphores      *Semaphore
	bufferBindCount      uint32
	pBufferBinds         *_vkSparseBufferMemoryBindInfo
	imageOpaqueBindCount uint32
	pImageOpaqueBinds    *_vkSparseImageOpaqueMemoryBindInfo
	imageBindCount       uint32
	pImageBinds          *_vkSparseImageMemoryBindInfo
	signalSemaphoreCount uint32
	pSignalSemaphores    *Semaphore
}

func (s *_vkBindSparseInfo) Goify() *BindSparseInfo {
	rval := &BindSparseInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pWaitSemaphores in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pBufferBinds in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pImageOpaqueBinds in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pImageBinds in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSignalSemaphores in returned struct
	}
	return rval
}
func (s *BindSparseInfo) Vulkanize() *_vkBindSparseInfo {
	if s == nil {
		return nil
	}

	var psl_pWaitSemaphores *Semaphore
	if len(s.PWaitSemaphores) > 0 {
		psl_pWaitSemaphores = &s.PWaitSemaphores[0]
	}

	var psl_pBufferBinds *_vkSparseBufferMemoryBindInfo
	if len(s.PBufferBinds) > 0 {
		sl_pBufferBinds := make([]_vkSparseBufferMemoryBindInfo, len(s.PBufferBinds))
		for i, v := range s.PBufferBinds {
			sl_pBufferBinds[i] = *(v.Vulkanize())
		}
		psl_pBufferBinds = &sl_pBufferBinds[0]
	}

	var psl_pImageOpaqueBinds *_vkSparseImageOpaqueMemoryBindInfo
	if len(s.PImageOpaqueBinds) > 0 {
		sl_pImageOpaqueBinds := make([]_vkSparseImageOpaqueMemoryBindInfo, len(s.PImageOpaqueBinds))
		for i, v := range s.PImageOpaqueBinds {
			sl_pImageOpaqueBinds[i] = *(v.Vulkanize())
		}
		psl_pImageOpaqueBinds = &sl_pImageOpaqueBinds[0]
	}

	var psl_pImageBinds *_vkSparseImageMemoryBindInfo
	if len(s.PImageBinds) > 0 {
		sl_pImageBinds := make([]_vkSparseImageMemoryBindInfo, len(s.PImageBinds))
		for i, v := range s.PImageBinds {
			sl_pImageBinds[i] = *(v.Vulkanize())
		}
		psl_pImageBinds = &sl_pImageBinds[0]
	}

	var psl_pSignalSemaphores *Semaphore
	if len(s.PSignalSemaphores) > 0 {
		psl_pSignalSemaphores = &s.PSignalSemaphores[0]
	}
	rval := &_vkBindSparseInfo{
		sType:                STRUCTURE_TYPE_BIND_SPARSE_INFO,  /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),        /*cb*/
		waitSemaphoreCount:   uint32(len(s.PWaitSemaphores)),   /*c6-a*/
		pWaitSemaphores:      psl_pWaitSemaphores,              /*c rem*/
		bufferBindCount:      uint32(len(s.PBufferBinds)),      /*c6-a*/
		pBufferBinds:         psl_pBufferBinds,                 /*c rem*/
		imageOpaqueBindCount: uint32(len(s.PImageOpaqueBinds)), /*c6-a*/
		pImageOpaqueBinds:    psl_pImageOpaqueBinds,            /*c rem*/
		imageBindCount:       uint32(len(s.PImageBinds)),       /*c6-a*/
		pImageBinds:          psl_pImageBinds,                  /*c rem*/
		signalSemaphoreCount: uint32(len(s.PSignalSemaphores)), /*c6-a*/
		pSignalSemaphores:    psl_pSignalSemaphores,            /*c rem*/
	}
	return rval
}

// BindVertexBufferIndirectCommandNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html
type BindVertexBufferIndirectCommandNV struct {
	BufferAddress DeviceAddress
	Size          uint32
	Stride        uint32
}

type _vkBindVertexBufferIndirectCommandNV = BindVertexBufferIndirectCommandNV

func (s *_vkBindVertexBufferIndirectCommandNV) Goify() *BindVertexBufferIndirectCommandNV {
	rval := (*BindVertexBufferIndirectCommandNV)(s)
	return rval
}
func (s *BindVertexBufferIndirectCommandNV) Vulkanize() *_vkBindVertexBufferIndirectCommandNV {
	if s == nil {
		return nil
	}
	rval := (*_vkBindVertexBufferIndirectCommandNV)(s)
	return rval
}

// BindVideoSessionMemoryInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindVideoSessionMemoryInfoKHR.html
type BindVideoSessionMemoryInfoKHR struct {
	// SType = STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR
	PNext           unsafe.Pointer
	MemoryBindIndex uint32
	Memory          DeviceMemory
	MemoryOffset    DeviceSize
	MemorySize      DeviceSize
}

type _vkBindVideoSessionMemoryInfoKHR struct {
	sType           StructureType
	pNext           unsafe.Pointer
	memoryBindIndex uint32
	memory          DeviceMemory
	memoryOffset    DeviceSize
	memorySize      DeviceSize
}

func (s *_vkBindVideoSessionMemoryInfoKHR) Goify() *BindVideoSessionMemoryInfoKHR {
	rval := &BindVideoSessionMemoryInfoKHR{
		PNext:           (unsafe.Pointer)(s.pNext),
		MemoryBindIndex: (uint32)(s.memoryBindIndex),
		Memory:          (DeviceMemory)(s.memory),
		MemoryOffset:    (DeviceSize)(s.memoryOffset),
		MemorySize:      (DeviceSize)(s.memorySize),
	}
	return rval
}
func (s *BindVideoSessionMemoryInfoKHR) Vulkanize() *_vkBindVideoSessionMemoryInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkBindVideoSessionMemoryInfoKHR{
		sType:           STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                         /*cb*/
		memoryBindIndex: (uint32)(s.MemoryBindIndex),                       /*cb*/
		memory:          (DeviceMemory)(s.Memory),                          /*cb*/
		memoryOffset:    (DeviceSize)(s.MemoryOffset),                      /*cb*/
		memorySize:      (DeviceSize)(s.MemorySize),                        /*cb*/
	}
	return rval
}

// BlitImageCubicWeightsInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlitImageCubicWeightsInfoQCOM.html
type BlitImageCubicWeightsInfoQCOM struct {
	// SType = STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM
	PNext        unsafe.Pointer
	CubicWeights CubicFilterWeightsQCOM
}

type _vkBlitImageCubicWeightsInfoQCOM struct {
	sType        StructureType
	pNext        unsafe.Pointer
	cubicWeights CubicFilterWeightsQCOM
}

func (s *_vkBlitImageCubicWeightsInfoQCOM) Goify() *BlitImageCubicWeightsInfoQCOM {
	rval := &BlitImageCubicWeightsInfoQCOM{
		PNext:        (unsafe.Pointer)(s.pNext),
		CubicWeights: (CubicFilterWeightsQCOM)(s.cubicWeights),
	}
	return rval
}
func (s *BlitImageCubicWeightsInfoQCOM) Vulkanize() *_vkBlitImageCubicWeightsInfoQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkBlitImageCubicWeightsInfoQCOM{
		sType:        STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                         /*cb*/
		cubicWeights: (CubicFilterWeightsQCOM)(s.CubicWeights),          /*cb*/
	}
	return rval
}

// BlitImageInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlitImageInfo2.html
type BlitImageInfo2 struct {
	// SType = STRUCTURE_TYPE_BLIT_IMAGE_INFO_2
	PNext          unsafe.Pointer
	SrcImage       Image
	SrcImageLayout ImageLayout
	DstImage       Image
	DstImageLayout ImageLayout
	// regionCount
	PRegions []ImageBlit2
	Filter   Filter
}

type _vkBlitImageInfo2 struct {
	sType          StructureType
	pNext          unsafe.Pointer
	srcImage       Image
	srcImageLayout ImageLayout
	dstImage       Image
	dstImageLayout ImageLayout
	regionCount    uint32
	pRegions       *_vkImageBlit2
	filter         Filter
}

func (s *_vkBlitImageInfo2) Goify() *BlitImageInfo2 {
	rval := &BlitImageInfo2{
		PNext:          (unsafe.Pointer)(s.pNext),
		SrcImage:       (Image)(s.srcImage),
		SrcImageLayout: (ImageLayout)(s.srcImageLayout),
		DstImage:       (Image)(s.dstImage),
		DstImageLayout: (ImageLayout)(s.dstImageLayout),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
		Filter: (Filter)(s.filter),
	}
	return rval
}
func (s *BlitImageInfo2) Vulkanize() *_vkBlitImageInfo2 {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkImageBlit2
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkImageBlit2, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkBlitImageInfo2{
		sType:          STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),        /*cb*/
		srcImage:       (Image)(s.SrcImage),              /*cb*/
		srcImageLayout: (ImageLayout)(s.SrcImageLayout),  /*cb*/
		dstImage:       (Image)(s.DstImage),              /*cb*/
		dstImageLayout: (ImageLayout)(s.DstImageLayout),  /*cb*/
		regionCount:    uint32(len(s.PRegions)),          /*c6-a*/
		pRegions:       psl_pRegions,                     /*c rem*/
		filter:         (Filter)(s.Filter),               /*cb*/
	}
	return rval
}

// BlitImageInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlitImageInfo2KHR.html
type BlitImageInfo2KHR struct {
}

type _vkBlitImageInfo2KHR = BlitImageInfo2KHR

func (s *_vkBlitImageInfo2KHR) Goify() *BlitImageInfo2KHR {
	rval := (*BlitImageInfo2KHR)(s)
	return rval
}
func (s *BlitImageInfo2KHR) Vulkanize() *_vkBlitImageInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBlitImageInfo2KHR)(s)
	return rval
}

// BufferCaptureDescriptorDataInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCaptureDescriptorDataInfoEXT.html
type BufferCaptureDescriptorDataInfoEXT struct {
	// SType = STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
	PNext  unsafe.Pointer
	Buffer Buffer
}

type _vkBufferCaptureDescriptorDataInfoEXT struct {
	sType  StructureType
	pNext  unsafe.Pointer
	buffer Buffer
}

func (s *_vkBufferCaptureDescriptorDataInfoEXT) Goify() *BufferCaptureDescriptorDataInfoEXT {
	rval := &BufferCaptureDescriptorDataInfoEXT{
		PNext:  (unsafe.Pointer)(s.pNext),
		Buffer: (Buffer)(s.buffer),
	}
	return rval
}
func (s *BufferCaptureDescriptorDataInfoEXT) Vulkanize() *_vkBufferCaptureDescriptorDataInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkBufferCaptureDescriptorDataInfoEXT{
		sType:  STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                              /*cb*/
		buffer: (Buffer)(s.Buffer),                                     /*cb*/
	}
	return rval
}

// BufferCopy: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy.html
type BufferCopy struct {
	//  Specified in bytes;
	SrcOffset DeviceSize
	//  Specified in bytes;
	DstOffset DeviceSize
	//  Specified in bytes;
	Size DeviceSize
}

type _vkBufferCopy = BufferCopy

func (s *_vkBufferCopy) Goify() *BufferCopy {
	rval := (*BufferCopy)(s)
	return rval
}
func (s *BufferCopy) Vulkanize() *_vkBufferCopy {
	if s == nil {
		return nil
	}
	rval := (*_vkBufferCopy)(s)
	return rval
}

// BufferCopy2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy2.html
type BufferCopy2 struct {
	// SType = STRUCTURE_TYPE_BUFFER_COPY_2
	PNext unsafe.Pointer
	//  Specified in bytes;
	SrcOffset DeviceSize
	//  Specified in bytes;
	DstOffset DeviceSize
	//  Specified in bytes;
	Size DeviceSize
}

type _vkBufferCopy2 struct {
	sType     StructureType
	pNext     unsafe.Pointer
	srcOffset DeviceSize
	dstOffset DeviceSize
	size      DeviceSize
}

func (s *_vkBufferCopy2) Goify() *BufferCopy2 {
	rval := &BufferCopy2{
		PNext:     (unsafe.Pointer)(s.pNext),
		SrcOffset: (DeviceSize)(s.srcOffset),
		DstOffset: (DeviceSize)(s.dstOffset),
		Size:      (DeviceSize)(s.size),
	}
	return rval
}
func (s *BufferCopy2) Vulkanize() *_vkBufferCopy2 {
	if s == nil {
		return nil
	}
	rval := &_vkBufferCopy2{
		sType:     STRUCTURE_TYPE_BUFFER_COPY_2, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),    /*cb*/
		srcOffset: (DeviceSize)(s.SrcOffset),    /*cb*/
		dstOffset: (DeviceSize)(s.DstOffset),    /*cb*/
		size:      (DeviceSize)(s.Size),         /*cb*/
	}
	return rval
}

// BufferCopy2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy2KHR.html
type BufferCopy2KHR struct {
}

type _vkBufferCopy2KHR = BufferCopy2KHR

func (s *_vkBufferCopy2KHR) Goify() *BufferCopy2KHR {
	rval := (*BufferCopy2KHR)(s)
	return rval
}
func (s *BufferCopy2KHR) Vulkanize() *_vkBufferCopy2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBufferCopy2KHR)(s)
	return rval
}

// BufferCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCreateInfo.html
type BufferCreateInfo struct {
	// SType = STRUCTURE_TYPE_BUFFER_CREATE_INFO
	PNext unsafe.Pointer
	//  Buffer creation flags;
	Flags BufferCreateFlags
	//  Specified in bytes;
	Size DeviceSize
	//  Buffer usage flags;
	Usage       BufferUsageFlags
	SharingMode SharingMode
	// queueFamilyIndexCount
	PQueueFamilyIndices []uint32
}

type _vkBufferCreateInfo struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	flags                 BufferCreateFlags
	size                  DeviceSize
	usage                 BufferUsageFlags
	sharingMode           SharingMode
	queueFamilyIndexCount uint32
	pQueueFamilyIndices   *uint32
}

func (s *_vkBufferCreateInfo) Goify() *BufferCreateInfo {
	rval := &BufferCreateInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		Flags:       (BufferCreateFlags)(s.flags),
		Size:        (DeviceSize)(s.size),
		Usage:       (BufferUsageFlags)(s.usage),
		SharingMode: (SharingMode)(s.sharingMode),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pQueueFamilyIndices in returned struct
	}
	return rval
}
func (s *BufferCreateInfo) Vulkanize() *_vkBufferCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pQueueFamilyIndices *uint32
	if len(s.PQueueFamilyIndices) > 0 {
		psl_pQueueFamilyIndices = &s.PQueueFamilyIndices[0]
	}
	rval := &_vkBufferCreateInfo{
		sType:                 STRUCTURE_TYPE_BUFFER_CREATE_INFO,  /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),          /*cb*/
		flags:                 (BufferCreateFlags)(s.Flags),       /*cb*/
		size:                  (DeviceSize)(s.Size),               /*cb*/
		usage:                 (BufferUsageFlags)(s.Usage),        /*cb*/
		sharingMode:           (SharingMode)(s.SharingMode),       /*cb*/
		queueFamilyIndexCount: uint32(len(s.PQueueFamilyIndices)), /*c6-a*/
		pQueueFamilyIndices:   psl_pQueueFamilyIndices,            /*c rem*/
	}
	return rval
}

// BufferDeviceAddressCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressCreateInfoEXT.html
type BufferDeviceAddressCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT
	PNext         unsafe.Pointer
	DeviceAddress DeviceAddress
}

type _vkBufferDeviceAddressCreateInfoEXT struct {
	sType         StructureType
	pNext         unsafe.Pointer
	deviceAddress DeviceAddress
}

func (s *_vkBufferDeviceAddressCreateInfoEXT) Goify() *BufferDeviceAddressCreateInfoEXT {
	rval := &BufferDeviceAddressCreateInfoEXT{
		PNext:         (unsafe.Pointer)(s.pNext),
		DeviceAddress: (DeviceAddress)(s.deviceAddress),
	}
	return rval
}
func (s *BufferDeviceAddressCreateInfoEXT) Vulkanize() *_vkBufferDeviceAddressCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkBufferDeviceAddressCreateInfoEXT{
		sType:         STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                            /*cb*/
		deviceAddress: (DeviceAddress)(s.DeviceAddress),                     /*cb*/
	}
	return rval
}

// BufferDeviceAddressInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressInfo.html
type BufferDeviceAddressInfo struct {
	// SType = STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO
	PNext  unsafe.Pointer
	Buffer Buffer
}

type _vkBufferDeviceAddressInfo struct {
	sType  StructureType
	pNext  unsafe.Pointer
	buffer Buffer
}

func (s *_vkBufferDeviceAddressInfo) Goify() *BufferDeviceAddressInfo {
	rval := &BufferDeviceAddressInfo{
		PNext:  (unsafe.Pointer)(s.pNext),
		Buffer: (Buffer)(s.buffer),
	}
	return rval
}
func (s *BufferDeviceAddressInfo) Vulkanize() *_vkBufferDeviceAddressInfo {
	if s == nil {
		return nil
	}
	rval := &_vkBufferDeviceAddressInfo{
		sType:  STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                 /*cb*/
		buffer: (Buffer)(s.Buffer),                        /*cb*/
	}
	return rval
}

// BufferDeviceAddressInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressInfoEXT.html
type BufferDeviceAddressInfoEXT struct {
}

type _vkBufferDeviceAddressInfoEXT = BufferDeviceAddressInfoEXT

func (s *_vkBufferDeviceAddressInfoEXT) Goify() *BufferDeviceAddressInfoEXT {
	rval := (*BufferDeviceAddressInfoEXT)(s)
	return rval
}
func (s *BufferDeviceAddressInfoEXT) Vulkanize() *_vkBufferDeviceAddressInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkBufferDeviceAddressInfoEXT)(s)
	return rval
}

// BufferDeviceAddressInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressInfoKHR.html
type BufferDeviceAddressInfoKHR struct {
}

type _vkBufferDeviceAddressInfoKHR = BufferDeviceAddressInfoKHR

func (s *_vkBufferDeviceAddressInfoKHR) Goify() *BufferDeviceAddressInfoKHR {
	rval := (*BufferDeviceAddressInfoKHR)(s)
	return rval
}
func (s *BufferDeviceAddressInfoKHR) Vulkanize() *_vkBufferDeviceAddressInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBufferDeviceAddressInfoKHR)(s)
	return rval
}

// BufferImageCopy: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy.html
type BufferImageCopy struct {
	//  Specified in bytes;
	BufferOffset DeviceSize
	//  Specified in texels;
	BufferRowLength   uint32
	BufferImageHeight uint32
	ImageSubresource  ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	ImageOffset Offset3D
	//  Specified in pixels for both compressed and uncompressed images;
	ImageExtent Extent3D
}

type _vkBufferImageCopy struct {
	bufferOffset      DeviceSize
	bufferRowLength   uint32
	bufferImageHeight uint32
	imageSubresource  _vkImageSubresourceLayers
	imageOffset       _vkOffset3D
	imageExtent       _vkExtent3D
}

func (s *_vkBufferImageCopy) Goify() *BufferImageCopy {
	rval := &BufferImageCopy{
		BufferOffset:      (DeviceSize)(s.bufferOffset),
		BufferRowLength:   (uint32)(s.bufferRowLength),
		BufferImageHeight: (uint32)(s.bufferImageHeight),
		ImageSubresource:  (ImageSubresourceLayers)(s.imageSubresource),
		ImageOffset:       (Offset3D)(s.imageOffset),
		ImageExtent:       (Extent3D)(s.imageExtent),
	}
	return rval
}
func (s *BufferImageCopy) Vulkanize() *_vkBufferImageCopy {
	if s == nil {
		return nil
	}
	rval := &_vkBufferImageCopy{
		bufferOffset:      (DeviceSize)(s.BufferOffset),                    /*cb*/
		bufferRowLength:   (uint32)(s.BufferRowLength),                     /*cb*/
		bufferImageHeight: (uint32)(s.BufferImageHeight),                   /*cb*/
		imageSubresource:  (_vkImageSubresourceLayers)(s.ImageSubresource), /*cb*/
		imageOffset:       (_vkOffset3D)(s.ImageOffset),                    /*cb*/
		imageExtent:       (_vkExtent3D)(s.ImageExtent),                    /*cb*/
	}
	return rval
}

// BufferImageCopy2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy2.html
type BufferImageCopy2 struct {
	// SType = STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2
	PNext unsafe.Pointer
	//  Specified in bytes;
	BufferOffset DeviceSize
	//  Specified in texels;
	BufferRowLength   uint32
	BufferImageHeight uint32
	ImageSubresource  ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	ImageOffset Offset3D
	//  Specified in pixels for both compressed and uncompressed images;
	ImageExtent Extent3D
}

type _vkBufferImageCopy2 struct {
	sType             StructureType
	pNext             unsafe.Pointer
	bufferOffset      DeviceSize
	bufferRowLength   uint32
	bufferImageHeight uint32
	imageSubresource  _vkImageSubresourceLayers
	imageOffset       _vkOffset3D
	imageExtent       _vkExtent3D
}

func (s *_vkBufferImageCopy2) Goify() *BufferImageCopy2 {
	rval := &BufferImageCopy2{
		PNext:             (unsafe.Pointer)(s.pNext),
		BufferOffset:      (DeviceSize)(s.bufferOffset),
		BufferRowLength:   (uint32)(s.bufferRowLength),
		BufferImageHeight: (uint32)(s.bufferImageHeight),
		ImageSubresource:  (ImageSubresourceLayers)(s.imageSubresource),
		ImageOffset:       (Offset3D)(s.imageOffset),
		ImageExtent:       (Extent3D)(s.imageExtent),
	}
	return rval
}
func (s *BufferImageCopy2) Vulkanize() *_vkBufferImageCopy2 {
	if s == nil {
		return nil
	}
	rval := &_vkBufferImageCopy2{
		sType:             STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2,              /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                       /*cb*/
		bufferOffset:      (DeviceSize)(s.BufferOffset),                    /*cb*/
		bufferRowLength:   (uint32)(s.BufferRowLength),                     /*cb*/
		bufferImageHeight: (uint32)(s.BufferImageHeight),                   /*cb*/
		imageSubresource:  (_vkImageSubresourceLayers)(s.ImageSubresource), /*cb*/
		imageOffset:       (_vkOffset3D)(s.ImageOffset),                    /*cb*/
		imageExtent:       (_vkExtent3D)(s.ImageExtent),                    /*cb*/
	}
	return rval
}

// BufferImageCopy2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy2KHR.html
type BufferImageCopy2KHR struct {
}

type _vkBufferImageCopy2KHR = BufferImageCopy2KHR

func (s *_vkBufferImageCopy2KHR) Goify() *BufferImageCopy2KHR {
	rval := (*BufferImageCopy2KHR)(s)
	return rval
}
func (s *BufferImageCopy2KHR) Vulkanize() *_vkBufferImageCopy2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBufferImageCopy2KHR)(s)
	return rval
}

// BufferMemoryBarrier: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier.html
type BufferMemoryBarrier struct {
	// SType = STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
	PNext unsafe.Pointer
	//  Memory accesses from the source of the dependency to synchronize;
	SrcAccessMask AccessFlags
	//  Memory accesses from the destination of the dependency to synchronize;
	DstAccessMask AccessFlags
	//  Queue family to transition ownership from;
	SrcQueueFamilyIndex uint32
	//  Queue family to transition ownership to;
	DstQueueFamilyIndex uint32
	//  Buffer to sync;
	Buffer Buffer
	//  Offset within the buffer to sync;
	Offset DeviceSize
	//  Amount of bytes to sync;
	Size DeviceSize
}

type _vkBufferMemoryBarrier struct {
	sType               StructureType
	pNext               unsafe.Pointer
	srcAccessMask       AccessFlags
	dstAccessMask       AccessFlags
	srcQueueFamilyIndex uint32
	dstQueueFamilyIndex uint32
	buffer              Buffer
	offset              DeviceSize
	size                DeviceSize
}

func (s *_vkBufferMemoryBarrier) Goify() *BufferMemoryBarrier {
	rval := &BufferMemoryBarrier{
		PNext:               (unsafe.Pointer)(s.pNext),
		SrcAccessMask:       (AccessFlags)(s.srcAccessMask),
		DstAccessMask:       (AccessFlags)(s.dstAccessMask),
		SrcQueueFamilyIndex: (uint32)(s.srcQueueFamilyIndex),
		DstQueueFamilyIndex: (uint32)(s.dstQueueFamilyIndex),
		Buffer:              (Buffer)(s.buffer),
		Offset:              (DeviceSize)(s.offset),
		Size:                (DeviceSize)(s.size),
	}
	return rval
}
func (s *BufferMemoryBarrier) Vulkanize() *_vkBufferMemoryBarrier {
	if s == nil {
		return nil
	}
	rval := &_vkBufferMemoryBarrier{
		sType:               STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),            /*cb*/
		srcAccessMask:       (AccessFlags)(s.SrcAccessMask),       /*cb*/
		dstAccessMask:       (AccessFlags)(s.DstAccessMask),       /*cb*/
		srcQueueFamilyIndex: (uint32)(s.SrcQueueFamilyIndex),      /*cb*/
		dstQueueFamilyIndex: (uint32)(s.DstQueueFamilyIndex),      /*cb*/
		buffer:              (Buffer)(s.Buffer),                   /*cb*/
		offset:              (DeviceSize)(s.Offset),               /*cb*/
		size:                (DeviceSize)(s.Size),                 /*cb*/
	}
	return rval
}

// BufferMemoryBarrier2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier2.html
type BufferMemoryBarrier2 struct {
	// SType = STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2
	PNext               unsafe.Pointer
	SrcStageMask        PipelineStageFlags2
	SrcAccessMask       AccessFlags2
	DstStageMask        PipelineStageFlags2
	DstAccessMask       AccessFlags2
	SrcQueueFamilyIndex uint32
	DstQueueFamilyIndex uint32
	Buffer              Buffer
	Offset              DeviceSize
	Size                DeviceSize
}

type _vkBufferMemoryBarrier2 struct {
	sType               StructureType
	pNext               unsafe.Pointer
	srcStageMask        PipelineStageFlags2
	srcAccessMask       AccessFlags2
	dstStageMask        PipelineStageFlags2
	dstAccessMask       AccessFlags2
	srcQueueFamilyIndex uint32
	dstQueueFamilyIndex uint32
	buffer              Buffer
	offset              DeviceSize
	size                DeviceSize
}

func (s *_vkBufferMemoryBarrier2) Goify() *BufferMemoryBarrier2 {
	rval := &BufferMemoryBarrier2{
		PNext:               (unsafe.Pointer)(s.pNext),
		SrcStageMask:        (PipelineStageFlags2)(s.srcStageMask),
		SrcAccessMask:       (AccessFlags2)(s.srcAccessMask),
		DstStageMask:        (PipelineStageFlags2)(s.dstStageMask),
		DstAccessMask:       (AccessFlags2)(s.dstAccessMask),
		SrcQueueFamilyIndex: (uint32)(s.srcQueueFamilyIndex),
		DstQueueFamilyIndex: (uint32)(s.dstQueueFamilyIndex),
		Buffer:              (Buffer)(s.buffer),
		Offset:              (DeviceSize)(s.offset),
		Size:                (DeviceSize)(s.size),
	}
	return rval
}
func (s *BufferMemoryBarrier2) Vulkanize() *_vkBufferMemoryBarrier2 {
	if s == nil {
		return nil
	}
	rval := &_vkBufferMemoryBarrier2{
		sType:               STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),              /*cb*/
		srcStageMask:        (PipelineStageFlags2)(s.SrcStageMask),  /*cb*/
		srcAccessMask:       (AccessFlags2)(s.SrcAccessMask),        /*cb*/
		dstStageMask:        (PipelineStageFlags2)(s.DstStageMask),  /*cb*/
		dstAccessMask:       (AccessFlags2)(s.DstAccessMask),        /*cb*/
		srcQueueFamilyIndex: (uint32)(s.SrcQueueFamilyIndex),        /*cb*/
		dstQueueFamilyIndex: (uint32)(s.DstQueueFamilyIndex),        /*cb*/
		buffer:              (Buffer)(s.Buffer),                     /*cb*/
		offset:              (DeviceSize)(s.Offset),                 /*cb*/
		size:                (DeviceSize)(s.Size),                   /*cb*/
	}
	return rval
}

// BufferMemoryBarrier2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier2KHR.html
type BufferMemoryBarrier2KHR struct {
}

type _vkBufferMemoryBarrier2KHR = BufferMemoryBarrier2KHR

func (s *_vkBufferMemoryBarrier2KHR) Goify() *BufferMemoryBarrier2KHR {
	rval := (*BufferMemoryBarrier2KHR)(s)
	return rval
}
func (s *BufferMemoryBarrier2KHR) Vulkanize() *_vkBufferMemoryBarrier2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBufferMemoryBarrier2KHR)(s)
	return rval
}

// BufferMemoryRequirementsInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryRequirementsInfo2.html
type BufferMemoryRequirementsInfo2 struct {
	// SType = STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2
	PNext  unsafe.Pointer
	Buffer Buffer
}

type _vkBufferMemoryRequirementsInfo2 struct {
	sType  StructureType
	pNext  unsafe.Pointer
	buffer Buffer
}

func (s *_vkBufferMemoryRequirementsInfo2) Goify() *BufferMemoryRequirementsInfo2 {
	rval := &BufferMemoryRequirementsInfo2{
		PNext:  (unsafe.Pointer)(s.pNext),
		Buffer: (Buffer)(s.buffer),
	}
	return rval
}
func (s *BufferMemoryRequirementsInfo2) Vulkanize() *_vkBufferMemoryRequirementsInfo2 {
	if s == nil {
		return nil
	}
	rval := &_vkBufferMemoryRequirementsInfo2{
		sType:  STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                        /*cb*/
		buffer: (Buffer)(s.Buffer),                               /*cb*/
	}
	return rval
}

// BufferMemoryRequirementsInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryRequirementsInfo2KHR.html
type BufferMemoryRequirementsInfo2KHR struct {
}

type _vkBufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2KHR

func (s *_vkBufferMemoryRequirementsInfo2KHR) Goify() *BufferMemoryRequirementsInfo2KHR {
	rval := (*BufferMemoryRequirementsInfo2KHR)(s)
	return rval
}
func (s *BufferMemoryRequirementsInfo2KHR) Vulkanize() *_vkBufferMemoryRequirementsInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBufferMemoryRequirementsInfo2KHR)(s)
	return rval
}

// BufferOpaqueCaptureAddressCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html
type BufferOpaqueCaptureAddressCreateInfo struct {
	// SType = STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO
	PNext                unsafe.Pointer
	OpaqueCaptureAddress uint64
}

type _vkBufferOpaqueCaptureAddressCreateInfo struct {
	sType                StructureType
	pNext                unsafe.Pointer
	opaqueCaptureAddress uint64
}

func (s *_vkBufferOpaqueCaptureAddressCreateInfo) Goify() *BufferOpaqueCaptureAddressCreateInfo {
	rval := &BufferOpaqueCaptureAddressCreateInfo{
		PNext:                (unsafe.Pointer)(s.pNext),
		OpaqueCaptureAddress: (uint64)(s.opaqueCaptureAddress),
	}
	return rval
}
func (s *BufferOpaqueCaptureAddressCreateInfo) Vulkanize() *_vkBufferOpaqueCaptureAddressCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkBufferOpaqueCaptureAddressCreateInfo{
		sType:                STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                /*cb*/
		opaqueCaptureAddress: (uint64)(s.OpaqueCaptureAddress),                         /*cb*/
	}
	return rval
}

// BufferOpaqueCaptureAddressCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferOpaqueCaptureAddressCreateInfoKHR.html
type BufferOpaqueCaptureAddressCreateInfoKHR struct {
}

type _vkBufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfoKHR

func (s *_vkBufferOpaqueCaptureAddressCreateInfoKHR) Goify() *BufferOpaqueCaptureAddressCreateInfoKHR {
	rval := (*BufferOpaqueCaptureAddressCreateInfoKHR)(s)
	return rval
}
func (s *BufferOpaqueCaptureAddressCreateInfoKHR) Vulkanize() *_vkBufferOpaqueCaptureAddressCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkBufferOpaqueCaptureAddressCreateInfoKHR)(s)
	return rval
}

// BufferUsageFlags2CreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferUsageFlags2CreateInfoKHR.html
type BufferUsageFlags2CreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR
	PNext unsafe.Pointer
	Usage BufferUsageFlags2KHR
}

type _vkBufferUsageFlags2CreateInfoKHR struct {
	sType StructureType
	pNext unsafe.Pointer
	usage BufferUsageFlags2KHR
}

func (s *_vkBufferUsageFlags2CreateInfoKHR) Goify() *BufferUsageFlags2CreateInfoKHR {
	rval := &BufferUsageFlags2CreateInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		Usage: (BufferUsageFlags2KHR)(s.usage),
	}
	return rval
}
func (s *BufferUsageFlags2CreateInfoKHR) Vulkanize() *_vkBufferUsageFlags2CreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkBufferUsageFlags2CreateInfoKHR{
		sType: STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                           /*cb*/
		usage: (BufferUsageFlags2KHR)(s.Usage),                     /*cb*/
	}
	return rval
}

// BufferViewCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateInfo.html
type BufferViewCreateInfo struct {
	// SType = STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
	PNext  unsafe.Pointer
	Flags  BufferViewCreateFlags
	Buffer Buffer
	//  Optionally specifies format of elements;
	Format Format
	//  Specified in bytes;
	Offset DeviceSize
	//  View size specified in bytes;
	Rang DeviceSize
}

type _vkBufferViewCreateInfo struct {
	sType  StructureType
	pNext  unsafe.Pointer
	flags  BufferViewCreateFlags
	buffer Buffer
	format Format
	offset DeviceSize
	rang   DeviceSize
}

func (s *_vkBufferViewCreateInfo) Goify() *BufferViewCreateInfo {
	rval := &BufferViewCreateInfo{
		PNext:  (unsafe.Pointer)(s.pNext),
		Flags:  (BufferViewCreateFlags)(s.flags),
		Buffer: (Buffer)(s.buffer),
		Format: (Format)(s.format),
		Offset: (DeviceSize)(s.offset),
		Rang:   (DeviceSize)(s.rang),
	}
	return rval
}
func (s *BufferViewCreateInfo) Vulkanize() *_vkBufferViewCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkBufferViewCreateInfo{
		sType:  STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),              /*cb*/
		flags:  (BufferViewCreateFlags)(s.Flags),       /*cb*/
		buffer: (Buffer)(s.Buffer),                     /*cb*/
		format: (Format)(s.Format),                     /*cb*/
		offset: (DeviceSize)(s.Offset),                 /*cb*/
		rang:   (DeviceSize)(s.Rang),                   /*cb*/
	}
	return rval
}

// CalibratedTimestampInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCalibratedTimestampInfoEXT.html
type CalibratedTimestampInfoEXT struct {
	// SType = STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT
	PNext      unsafe.Pointer
	TimeDomain TimeDomainEXT
}

type _vkCalibratedTimestampInfoEXT struct {
	sType      StructureType
	pNext      unsafe.Pointer
	timeDomain TimeDomainEXT
}

func (s *_vkCalibratedTimestampInfoEXT) Goify() *CalibratedTimestampInfoEXT {
	rval := &CalibratedTimestampInfoEXT{
		PNext:      (unsafe.Pointer)(s.pNext),
		TimeDomain: (TimeDomainEXT)(s.timeDomain),
	}
	return rval
}
func (s *CalibratedTimestampInfoEXT) Vulkanize() *_vkCalibratedTimestampInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkCalibratedTimestampInfoEXT{
		sType:      STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                    /*cb*/
		timeDomain: (TimeDomainEXT)(s.TimeDomain),                /*cb*/
	}
	return rval
}

// CheckpointData2NV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointData2NV.html
type CheckpointData2NV struct {
	// SType = STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV
	PNext             unsafe.Pointer
	Stage             PipelineStageFlags2
	PCheckpointMarker unsafe.Pointer
}

// WARNING - struct CheckpointData2NV is returned only, which is not yet handled in the binding
type _vkCheckpointData2NV struct {
	sType             StructureType
	pNext             unsafe.Pointer
	stage             PipelineStageFlags2
	pCheckpointMarker unsafe.Pointer
}

func (s *_vkCheckpointData2NV) Goify() *CheckpointData2NV {
	rval := &CheckpointData2NV{
		PNext:             (unsafe.Pointer)(s.pNext),
		Stage:             (PipelineStageFlags2)(s.stage),
		PCheckpointMarker: (unsafe.Pointer)(s.pCheckpointMarker),
	}
	return rval
}
func (s *CheckpointData2NV) Vulkanize() *_vkCheckpointData2NV {
	if s == nil {
		return nil
	}
	rval := &_vkCheckpointData2NV{
		sType:             STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV,   /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),             /*cb*/
		stage:             (PipelineStageFlags2)(s.Stage),        /*cb*/
		pCheckpointMarker: (unsafe.Pointer)(s.PCheckpointMarker), /*cb*/
	}
	return rval
}

// CheckpointDataNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointDataNV.html
type CheckpointDataNV struct {
	// SType = STRUCTURE_TYPE_CHECKPOINT_DATA_NV
	PNext             unsafe.Pointer
	Stage             PipelineStageFlagBits
	PCheckpointMarker unsafe.Pointer
}

// WARNING - struct CheckpointDataNV is returned only, which is not yet handled in the binding
type _vkCheckpointDataNV struct {
	sType             StructureType
	pNext             unsafe.Pointer
	stage             PipelineStageFlagBits
	pCheckpointMarker unsafe.Pointer
}

func (s *_vkCheckpointDataNV) Goify() *CheckpointDataNV {
	rval := &CheckpointDataNV{
		PNext:             (unsafe.Pointer)(s.pNext),
		Stage:             (PipelineStageFlagBits)(s.stage),
		PCheckpointMarker: (unsafe.Pointer)(s.pCheckpointMarker),
	}
	return rval
}
func (s *CheckpointDataNV) Vulkanize() *_vkCheckpointDataNV {
	if s == nil {
		return nil
	}
	rval := &_vkCheckpointDataNV{
		sType:             STRUCTURE_TYPE_CHECKPOINT_DATA_NV,     /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),             /*cb*/
		stage:             (PipelineStageFlagBits)(s.Stage),      /*cb*/
		pCheckpointMarker: (unsafe.Pointer)(s.PCheckpointMarker), /*cb*/
	}
	return rval
}

// ClearAttachment: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearAttachment.html
type ClearAttachment struct {
	AspectMask      ImageAspectFlags
	ColorAttachment uint32
	ClearValue      ClearValue
}

type _vkClearAttachment struct {
	aspectMask      ImageAspectFlags
	colorAttachment uint32
	clearValue      _vkClearValue
}

func (s *_vkClearAttachment) Goify() *ClearAttachment {
	rval := &ClearAttachment{
		AspectMask:      (ImageAspectFlags)(s.aspectMask),
		ColorAttachment: (uint32)(s.colorAttachment),
		// Can't Goify union member clearValue
	}
	return rval
}
func (s *ClearAttachment) Vulkanize() *_vkClearAttachment {
	if s == nil {
		return nil
	}
	rval := &_vkClearAttachment{
		aspectMask:      (ImageAspectFlags)(s.AspectMask), /*cb*/
		colorAttachment: (uint32)(s.ColorAttachment),      /*cb*/
		clearValue:      *s.ClearValue.Vulkanize(),        /*c union*/
	}
	return rval
}

// ClearDepthStencilValue: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearDepthStencilValue.html
type ClearDepthStencilValue struct {
	Depth   float32
	Stencil uint32
}

type _vkClearDepthStencilValue = ClearDepthStencilValue

func (s *_vkClearDepthStencilValue) Goify() *ClearDepthStencilValue {
	rval := (*ClearDepthStencilValue)(s)
	return rval
}
func (s *ClearDepthStencilValue) Vulkanize() *_vkClearDepthStencilValue {
	if s == nil {
		return nil
	}
	rval := (*_vkClearDepthStencilValue)(s)
	return rval
}

// ClearRect: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearRect.html
type ClearRect struct {
	Rect           Rect2D
	BaseArrayLayer uint32
	LayerCount     uint32
}

type _vkClearRect struct {
	rect           _vkRect2D
	baseArrayLayer uint32
	layerCount     uint32
}

func (s *_vkClearRect) Goify() *ClearRect {
	rval := &ClearRect{
		Rect:           *(s.rect.Goify()),
		BaseArrayLayer: (uint32)(s.baseArrayLayer),
		LayerCount:     (uint32)(s.layerCount),
	}
	return rval
}
func (s *ClearRect) Vulkanize() *_vkClearRect {
	if s == nil {
		return nil
	}
	rval := &_vkClearRect{
		rect:           *(s.Rect.Vulkanize()),      /*c3*/
		baseArrayLayer: (uint32)(s.BaseArrayLayer), /*cb*/
		layerCount:     (uint32)(s.LayerCount),     /*cb*/
	}
	return rval
}

// CoarseSampleLocationNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleLocationNV.html
type CoarseSampleLocationNV struct {
	PixelX uint32
	PixelY uint32
	Sample uint32
}

type _vkCoarseSampleLocationNV = CoarseSampleLocationNV

func (s *_vkCoarseSampleLocationNV) Goify() *CoarseSampleLocationNV {
	rval := (*CoarseSampleLocationNV)(s)
	return rval
}
func (s *CoarseSampleLocationNV) Vulkanize() *_vkCoarseSampleLocationNV {
	if s == nil {
		return nil
	}
	rval := (*_vkCoarseSampleLocationNV)(s)
	return rval
}

// CoarseSampleOrderCustomNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleOrderCustomNV.html
type CoarseSampleOrderCustomNV struct {
	ShadingRate ShadingRatePaletteEntryNV
	SampleCount uint32
	// sampleLocationCount
	PSampleLocations []CoarseSampleLocationNV
}

type _vkCoarseSampleOrderCustomNV struct {
	shadingRate         ShadingRatePaletteEntryNV
	sampleCount         uint32
	sampleLocationCount uint32
	pSampleLocations    *_vkCoarseSampleLocationNV
}

func (s *_vkCoarseSampleOrderCustomNV) Goify() *CoarseSampleOrderCustomNV {
	rval := &CoarseSampleOrderCustomNV{
		ShadingRate: (ShadingRatePaletteEntryNV)(s.shadingRate),
		SampleCount: (uint32)(s.sampleCount),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSampleLocations in returned struct
	}
	return rval
}
func (s *CoarseSampleOrderCustomNV) Vulkanize() *_vkCoarseSampleOrderCustomNV {
	if s == nil {
		return nil
	}

	var psl_pSampleLocations *_vkCoarseSampleLocationNV
	if len(s.PSampleLocations) > 0 {
		psl_pSampleLocations = &s.PSampleLocations[0]
	}
	rval := &_vkCoarseSampleOrderCustomNV{
		shadingRate:         (ShadingRatePaletteEntryNV)(s.ShadingRate), /*cb*/
		sampleCount:         (uint32)(s.SampleCount),                    /*cb*/
		sampleLocationCount: uint32(len(s.PSampleLocations)),            /*c6-a*/
		pSampleLocations:    psl_pSampleLocations,                       /*c rem*/
	}
	return rval
}

// ColorBlendAdvancedEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorBlendAdvancedEXT.html
type ColorBlendAdvancedEXT struct {
	AdvancedBlendOp  BlendOp
	SrcPremultiplied bool
	DstPremultiplied bool
	BlendOverlap     BlendOverlapEXT
	ClampResults     bool
}

type _vkColorBlendAdvancedEXT struct {
	advancedBlendOp  BlendOp
	srcPremultiplied Bool32
	dstPremultiplied Bool32
	blendOverlap     BlendOverlapEXT
	clampResults     Bool32
}

func (s *_vkColorBlendAdvancedEXT) Goify() *ColorBlendAdvancedEXT {
	rval := &ColorBlendAdvancedEXT{
		AdvancedBlendOp:  (BlendOp)(s.advancedBlendOp),
		SrcPremultiplied: translatePublic_Bool32(s.srcPremultiplied), /*default*/
		DstPremultiplied: translatePublic_Bool32(s.dstPremultiplied), /*default*/
		BlendOverlap:     (BlendOverlapEXT)(s.blendOverlap),
		ClampResults:     translatePublic_Bool32(s.clampResults), /*default*/
	}
	return rval
}
func (s *ColorBlendAdvancedEXT) Vulkanize() *_vkColorBlendAdvancedEXT {
	if s == nil {
		return nil
	}
	rval := &_vkColorBlendAdvancedEXT{
		advancedBlendOp:  (BlendOp)(s.AdvancedBlendOp),                 /*cb*/
		srcPremultiplied: translateInternal_Bool32(s.SrcPremultiplied), /*default*/
		dstPremultiplied: translateInternal_Bool32(s.DstPremultiplied), /*default*/
		blendOverlap:     (BlendOverlapEXT)(s.BlendOverlap),            /*cb*/
		clampResults:     translateInternal_Bool32(s.ClampResults),     /*default*/
	}
	return rval
}

// ColorBlendEquationEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorBlendEquationEXT.html
type ColorBlendEquationEXT struct {
	SrcColorBlendFactor BlendFactor
	DstColorBlendFactor BlendFactor
	ColorBlendOp        BlendOp
	SrcAlphaBlendFactor BlendFactor
	DstAlphaBlendFactor BlendFactor
	AlphaBlendOp        BlendOp
}

type _vkColorBlendEquationEXT = ColorBlendEquationEXT

func (s *_vkColorBlendEquationEXT) Goify() *ColorBlendEquationEXT {
	rval := (*ColorBlendEquationEXT)(s)
	return rval
}
func (s *ColorBlendEquationEXT) Vulkanize() *_vkColorBlendEquationEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkColorBlendEquationEXT)(s)
	return rval
}

// CommandBufferAllocateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferAllocateInfo.html
type CommandBufferAllocateInfo struct {
	// SType = STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
	PNext              unsafe.Pointer
	CommandPool        CommandPool
	Level              CommandBufferLevel
	CommandBufferCount uint32
}

type _vkCommandBufferAllocateInfo struct {
	sType              StructureType
	pNext              unsafe.Pointer
	commandPool        CommandPool
	level              CommandBufferLevel
	commandBufferCount uint32
}

func (s *_vkCommandBufferAllocateInfo) Goify() *CommandBufferAllocateInfo {
	rval := &CommandBufferAllocateInfo{
		PNext:              (unsafe.Pointer)(s.pNext),
		CommandPool:        (CommandPool)(s.commandPool),
		Level:              (CommandBufferLevel)(s.level),
		CommandBufferCount: (uint32)(s.commandBufferCount),
	}
	return rval
}
func (s *CommandBufferAllocateInfo) Vulkanize() *_vkCommandBufferAllocateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkCommandBufferAllocateInfo{
		sType:              STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                   /*cb*/
		commandPool:        (CommandPool)(s.CommandPool),                /*cb*/
		level:              (CommandBufferLevel)(s.Level),               /*cb*/
		commandBufferCount: (uint32)(s.CommandBufferCount),              /*cb*/
	}
	return rval
}

// CommandBufferBeginInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferBeginInfo.html
type CommandBufferBeginInfo struct {
	// SType = STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
	PNext unsafe.Pointer
	//  Command buffer usage flags;
	Flags CommandBufferUsageFlags
	//  Pointer to inheritance info for secondary command buffers;
	PInheritanceInfo *CommandBufferInheritanceInfo
}

type _vkCommandBufferBeginInfo struct {
	sType            StructureType
	pNext            unsafe.Pointer
	flags            CommandBufferUsageFlags
	pInheritanceInfo *_vkCommandBufferInheritanceInfo
}

func (s *_vkCommandBufferBeginInfo) Goify() *CommandBufferBeginInfo {
	rval := &CommandBufferBeginInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (CommandBufferUsageFlags)(s.flags),
		// Unexpected pointer member pInheritanceInfo in returned struct
	}
	return rval
}
func (s *CommandBufferBeginInfo) Vulkanize() *_vkCommandBufferBeginInfo {
	if s == nil {
		return nil
	}
	rval := &_vkCommandBufferBeginInfo{
		sType:            STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                /*cb*/
		flags:            (CommandBufferUsageFlags)(s.Flags),       /*cb*/
		pInheritanceInfo: (s.PInheritanceInfo.Vulkanize()),         /*c rem*/
	}
	return rval
}

// CommandBufferInheritanceConditionalRenderingInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html
type CommandBufferInheritanceConditionalRenderingInfoEXT struct {
	// SType = STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT
	PNext unsafe.Pointer
	//  Whether this secondary command buffer may be executed during an active conditional rendering;
	ConditionalRenderingEnable bool
}

type _vkCommandBufferInheritanceConditionalRenderingInfoEXT struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	conditionalRenderingEnable Bool32
}

func (s *_vkCommandBufferInheritanceConditionalRenderingInfoEXT) Goify() *CommandBufferInheritanceConditionalRenderingInfoEXT {
	rval := &CommandBufferInheritanceConditionalRenderingInfoEXT{
		PNext:                      (unsafe.Pointer)(s.pNext),
		ConditionalRenderingEnable: translatePublic_Bool32(s.conditionalRenderingEnable), /*default*/
	}
	return rval
}
func (s *CommandBufferInheritanceConditionalRenderingInfoEXT) Vulkanize() *_vkCommandBufferInheritanceConditionalRenderingInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkCommandBufferInheritanceConditionalRenderingInfoEXT{
		sType:                      STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                                /*cb*/
		conditionalRenderingEnable: translateInternal_Bool32(s.ConditionalRenderingEnable),                   /*default*/
	}
	return rval
}

// CommandBufferInheritanceInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceInfo.html
type CommandBufferInheritanceInfo struct {
	// SType = STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
	PNext unsafe.Pointer
	//  Render pass for secondary command buffers;
	RenderPass RenderPass
	Subpass    uint32
	//  Framebuffer for secondary command buffers;
	Framebuffer Framebuffer
	//  Whether this secondary command buffer may be executed during an occlusion query;
	OcclusionQueryEnable bool
	//  Query flags used by this secondary command buffer, if executed during an occlusion query;
	QueryFlags QueryControlFlags
	//  Pipeline statistics that may be counted for this secondary command buffer;
	PipelineStatistics QueryPipelineStatisticFlags
}

type _vkCommandBufferInheritanceInfo struct {
	sType                StructureType
	pNext                unsafe.Pointer
	renderPass           RenderPass
	subpass              uint32
	framebuffer          Framebuffer
	occlusionQueryEnable Bool32
	queryFlags           QueryControlFlags
	pipelineStatistics   QueryPipelineStatisticFlags
}

func (s *_vkCommandBufferInheritanceInfo) Goify() *CommandBufferInheritanceInfo {
	rval := &CommandBufferInheritanceInfo{
		PNext:                (unsafe.Pointer)(s.pNext),
		RenderPass:           (RenderPass)(s.renderPass),
		Subpass:              (uint32)(s.subpass),
		Framebuffer:          (Framebuffer)(s.framebuffer),
		OcclusionQueryEnable: translatePublic_Bool32(s.occlusionQueryEnable), /*default*/
		QueryFlags:           (QueryControlFlags)(s.queryFlags),
		PipelineStatistics:   (QueryPipelineStatisticFlags)(s.pipelineStatistics),
	}
	return rval
}
func (s *CommandBufferInheritanceInfo) Vulkanize() *_vkCommandBufferInheritanceInfo {
	if s == nil {
		return nil
	}
	rval := &_vkCommandBufferInheritanceInfo{
		sType:                STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,      /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                           /*cb*/
		renderPass:           (RenderPass)(s.RenderPass),                          /*cb*/
		subpass:              (uint32)(s.Subpass),                                 /*cb*/
		framebuffer:          (Framebuffer)(s.Framebuffer),                        /*cb*/
		occlusionQueryEnable: translateInternal_Bool32(s.OcclusionQueryEnable),    /*default*/
		queryFlags:           (QueryControlFlags)(s.QueryFlags),                   /*cb*/
		pipelineStatistics:   (QueryPipelineStatisticFlags)(s.PipelineStatistics), /*cb*/
	}
	return rval
}

// CommandBufferInheritanceRenderPassTransformInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html
type CommandBufferInheritanceRenderPassTransformInfoQCOM struct {
	// SType = STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM
	//  Pointer to next structure;
	PNext      unsafe.Pointer
	Transform  SurfaceTransformFlagBitsKHR
	RenderArea Rect2D
}

type _vkCommandBufferInheritanceRenderPassTransformInfoQCOM struct {
	sType      StructureType
	pNext      unsafe.Pointer
	transform  SurfaceTransformFlagBitsKHR
	renderArea _vkRect2D
}

func (s *_vkCommandBufferInheritanceRenderPassTransformInfoQCOM) Goify() *CommandBufferInheritanceRenderPassTransformInfoQCOM {
	rval := &CommandBufferInheritanceRenderPassTransformInfoQCOM{
		PNext:      (unsafe.Pointer)(s.pNext),
		Transform:  (SurfaceTransformFlagBitsKHR)(s.transform),
		RenderArea: *(s.renderArea.Goify()),
	}
	return rval
}
func (s *CommandBufferInheritanceRenderPassTransformInfoQCOM) Vulkanize() *_vkCommandBufferInheritanceRenderPassTransformInfoQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkCommandBufferInheritanceRenderPassTransformInfoQCOM{
		sType:      STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                                                 /*cb*/
		transform:  (SurfaceTransformFlagBitsKHR)(s.Transform),                                /*cb*/
		renderArea: *(s.RenderArea.Vulkanize()),                                               /*c3*/
	}
	return rval
}

// CommandBufferInheritanceRenderingInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderingInfoKHR.html
type CommandBufferInheritanceRenderingInfoKHR struct {
}

type _vkCommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfoKHR

func (s *_vkCommandBufferInheritanceRenderingInfoKHR) Goify() *CommandBufferInheritanceRenderingInfoKHR {
	rval := (*CommandBufferInheritanceRenderingInfoKHR)(s)
	return rval
}
func (s *CommandBufferInheritanceRenderingInfoKHR) Vulkanize() *_vkCommandBufferInheritanceRenderingInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkCommandBufferInheritanceRenderingInfoKHR)(s)
	return rval
}

// CommandBufferInheritanceViewportScissorInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html
type CommandBufferInheritanceViewportScissorInfoNV struct {
	// SType = STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV
	PNext              unsafe.Pointer
	ViewportScissor2D  bool
	ViewportDepthCount uint32
	PViewportDepths    *Viewport
}

type _vkCommandBufferInheritanceViewportScissorInfoNV struct {
	sType              StructureType
	pNext              unsafe.Pointer
	viewportScissor2D  Bool32
	viewportDepthCount uint32
	pViewportDepths    *_vkViewport
}

func (s *_vkCommandBufferInheritanceViewportScissorInfoNV) Goify() *CommandBufferInheritanceViewportScissorInfoNV {
	rval := &CommandBufferInheritanceViewportScissorInfoNV{
		PNext:              (unsafe.Pointer)(s.pNext),
		ViewportScissor2D:  translatePublic_Bool32(s.viewportScissor2D), /*default*/
		ViewportDepthCount: (uint32)(s.viewportDepthCount),
		PViewportDepths:    (*Viewport)(s.pViewportDepths),
	}
	return rval
}
func (s *CommandBufferInheritanceViewportScissorInfoNV) Vulkanize() *_vkCommandBufferInheritanceViewportScissorInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkCommandBufferInheritanceViewportScissorInfoNV{
		sType:              STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                          /*cb*/
		viewportScissor2D:  translateInternal_Bool32(s.ViewportScissor2D),                      /*default*/
		viewportDepthCount: (uint32)(s.ViewportDepthCount),                                     /*cb*/
		pViewportDepths:    (*_vkViewport)(s.PViewportDepths),                                  /*cb*/
	}
	return rval
}

// CommandBufferSubmitInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferSubmitInfo.html
type CommandBufferSubmitInfo struct {
	// SType = STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO
	PNext         unsafe.Pointer
	CommandBuffer CommandBuffer
	DeviceMask    uint32
}

type _vkCommandBufferSubmitInfo struct {
	sType         StructureType
	pNext         unsafe.Pointer
	commandBuffer CommandBuffer
	deviceMask    uint32
}

func (s *_vkCommandBufferSubmitInfo) Goify() *CommandBufferSubmitInfo {
	rval := &CommandBufferSubmitInfo{
		PNext:         (unsafe.Pointer)(s.pNext),
		CommandBuffer: (CommandBuffer)(s.commandBuffer),
		DeviceMask:    (uint32)(s.deviceMask),
	}
	return rval
}
func (s *CommandBufferSubmitInfo) Vulkanize() *_vkCommandBufferSubmitInfo {
	if s == nil {
		return nil
	}
	rval := &_vkCommandBufferSubmitInfo{
		sType:         STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                 /*cb*/
		commandBuffer: (CommandBuffer)(s.CommandBuffer),          /*cb*/
		deviceMask:    (uint32)(s.DeviceMask),                    /*cb*/
	}
	return rval
}

// CommandBufferSubmitInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferSubmitInfoKHR.html
type CommandBufferSubmitInfoKHR struct {
}

type _vkCommandBufferSubmitInfoKHR = CommandBufferSubmitInfoKHR

func (s *_vkCommandBufferSubmitInfoKHR) Goify() *CommandBufferSubmitInfoKHR {
	rval := (*CommandBufferSubmitInfoKHR)(s)
	return rval
}
func (s *CommandBufferSubmitInfoKHR) Vulkanize() *_vkCommandBufferSubmitInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkCommandBufferSubmitInfoKHR)(s)
	return rval
}

// CommandPoolCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolCreateInfo.html
type CommandPoolCreateInfo struct {
	// SType = STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
	PNext unsafe.Pointer
	//  Command pool creation flags;
	Flags            CommandPoolCreateFlags
	QueueFamilyIndex uint32
}

type _vkCommandPoolCreateInfo struct {
	sType            StructureType
	pNext            unsafe.Pointer
	flags            CommandPoolCreateFlags
	queueFamilyIndex uint32
}

func (s *_vkCommandPoolCreateInfo) Goify() *CommandPoolCreateInfo {
	rval := &CommandPoolCreateInfo{
		PNext:            (unsafe.Pointer)(s.pNext),
		Flags:            (CommandPoolCreateFlags)(s.flags),
		QueueFamilyIndex: (uint32)(s.queueFamilyIndex),
	}
	return rval
}
func (s *CommandPoolCreateInfo) Vulkanize() *_vkCommandPoolCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkCommandPoolCreateInfo{
		sType:            STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),               /*cb*/
		flags:            (CommandPoolCreateFlags)(s.Flags),       /*cb*/
		queueFamilyIndex: (uint32)(s.QueueFamilyIndex),            /*cb*/
	}
	return rval
}

// ComponentMapping: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComponentMapping.html
type ComponentMapping struct {
	R ComponentSwizzle
	G ComponentSwizzle
	B ComponentSwizzle
	A ComponentSwizzle
}

type _vkComponentMapping = ComponentMapping

func (s *_vkComponentMapping) Goify() *ComponentMapping {
	rval := (*ComponentMapping)(s)
	return rval
}
func (s *ComponentMapping) Vulkanize() *_vkComponentMapping {
	if s == nil {
		return nil
	}
	rval := (*_vkComponentMapping)(s)
	return rval
}

// ComputePipelineCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComputePipelineCreateInfo.html
type ComputePipelineCreateInfo struct {
	// SType = STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
	PNext unsafe.Pointer
	//  Pipeline creation flags;
	Flags PipelineCreateFlags
	Stage PipelineShaderStageCreateInfo
	//  Interface layout of the pipeline;
	Layout PipelineLayout
	//  If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of;
	BasePipelineHandle Pipeline
	//  If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of;
	BasePipelineIndex int32
}

type _vkComputePipelineCreateInfo struct {
	sType              StructureType
	pNext              unsafe.Pointer
	flags              PipelineCreateFlags
	stage              _vkPipelineShaderStageCreateInfo
	layout             PipelineLayout
	basePipelineHandle Pipeline
	basePipelineIndex  int32
}

func (s *_vkComputePipelineCreateInfo) Goify() *ComputePipelineCreateInfo {
	rval := &ComputePipelineCreateInfo{
		PNext:              (unsafe.Pointer)(s.pNext),
		Flags:              (PipelineCreateFlags)(s.flags),
		Stage:              *(s.stage.Goify()),
		Layout:             (PipelineLayout)(s.layout),
		BasePipelineHandle: (Pipeline)(s.basePipelineHandle),
		BasePipelineIndex:  (int32)(s.basePipelineIndex),
	}
	return rval
}
func (s *ComputePipelineCreateInfo) Vulkanize() *_vkComputePipelineCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkComputePipelineCreateInfo{
		sType:              STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                   /*cb*/
		flags:              (PipelineCreateFlags)(s.Flags),              /*cb*/
		stage:              *(s.Stage.Vulkanize()),                      /*c3*/
		layout:             (PipelineLayout)(s.Layout),                  /*cb*/
		basePipelineHandle: (Pipeline)(s.BasePipelineHandle),            /*cb*/
		basePipelineIndex:  (int32)(s.BasePipelineIndex),                /*cb*/
	}
	return rval
}

// ComputePipelineIndirectBufferInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComputePipelineIndirectBufferInfoNV.html
type ComputePipelineIndirectBufferInfoNV struct {
	// SType = STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV
	PNext                              unsafe.Pointer
	DeviceAddress                      DeviceAddress
	Size                               DeviceSize
	PipelineDeviceAddressCaptureReplay DeviceAddress
}

type _vkComputePipelineIndirectBufferInfoNV struct {
	sType                              StructureType
	pNext                              unsafe.Pointer
	deviceAddress                      DeviceAddress
	size                               DeviceSize
	pipelineDeviceAddressCaptureReplay DeviceAddress
}

func (s *_vkComputePipelineIndirectBufferInfoNV) Goify() *ComputePipelineIndirectBufferInfoNV {
	rval := &ComputePipelineIndirectBufferInfoNV{
		PNext:                              (unsafe.Pointer)(s.pNext),
		DeviceAddress:                      (DeviceAddress)(s.deviceAddress),
		Size:                               (DeviceSize)(s.size),
		PipelineDeviceAddressCaptureReplay: (DeviceAddress)(s.pipelineDeviceAddressCaptureReplay),
	}
	return rval
}
func (s *ComputePipelineIndirectBufferInfoNV) Vulkanize() *_vkComputePipelineIndirectBufferInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkComputePipelineIndirectBufferInfoNV{
		sType:                              STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV, /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                               /*cb*/
		deviceAddress:                      (DeviceAddress)(s.DeviceAddress),                        /*cb*/
		size:                               (DeviceSize)(s.Size),                                    /*cb*/
		pipelineDeviceAddressCaptureReplay: (DeviceAddress)(s.PipelineDeviceAddressCaptureReplay),   /*cb*/
	}
	return rval
}

// ConditionalRenderingBeginInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConditionalRenderingBeginInfoEXT.html
type ConditionalRenderingBeginInfoEXT struct {
	// SType = STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT
	PNext  unsafe.Pointer
	Buffer Buffer
	Offset DeviceSize
	Flags  ConditionalRenderingFlagsEXT
}

type _vkConditionalRenderingBeginInfoEXT struct {
	sType  StructureType
	pNext  unsafe.Pointer
	buffer Buffer
	offset DeviceSize
	flags  ConditionalRenderingFlagsEXT
}

func (s *_vkConditionalRenderingBeginInfoEXT) Goify() *ConditionalRenderingBeginInfoEXT {
	rval := &ConditionalRenderingBeginInfoEXT{
		PNext:  (unsafe.Pointer)(s.pNext),
		Buffer: (Buffer)(s.buffer),
		Offset: (DeviceSize)(s.offset),
		Flags:  (ConditionalRenderingFlagsEXT)(s.flags),
	}
	return rval
}
func (s *ConditionalRenderingBeginInfoEXT) Vulkanize() *_vkConditionalRenderingBeginInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkConditionalRenderingBeginInfoEXT{
		sType:  STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                           /*cb*/
		buffer: (Buffer)(s.Buffer),                                  /*cb*/
		offset: (DeviceSize)(s.Offset),                              /*cb*/
		flags:  (ConditionalRenderingFlagsEXT)(s.Flags),             /*cb*/
	}
	return rval
}

// ConformanceVersion: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConformanceVersion.html
type ConformanceVersion struct {
	Major    uint8
	Minor    uint8
	Subminor uint8
	Patch    uint8
}

type _vkConformanceVersion = ConformanceVersion

func (s *_vkConformanceVersion) Goify() *ConformanceVersion {
	rval := (*ConformanceVersion)(s)
	return rval
}
func (s *ConformanceVersion) Vulkanize() *_vkConformanceVersion {
	if s == nil {
		return nil
	}
	rval := (*_vkConformanceVersion)(s)
	return rval
}

// ConformanceVersionKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConformanceVersionKHR.html
type ConformanceVersionKHR struct {
}

type _vkConformanceVersionKHR = ConformanceVersionKHR

func (s *_vkConformanceVersionKHR) Goify() *ConformanceVersionKHR {
	rval := (*ConformanceVersionKHR)(s)
	return rval
}
func (s *ConformanceVersionKHR) Vulkanize() *_vkConformanceVersionKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkConformanceVersionKHR)(s)
	return rval
}

// CooperativeMatrixPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCooperativeMatrixPropertiesKHR.html
type CooperativeMatrixPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR
	PNext                  unsafe.Pointer
	MSize                  uint32
	NSize                  uint32
	KSize                  uint32
	AType                  ComponentTypeKHR
	BType                  ComponentTypeKHR
	CType                  ComponentTypeKHR
	ResultType             ComponentTypeKHR
	SaturatingAccumulation bool
	Scope                  ScopeKHR
}

type _vkCooperativeMatrixPropertiesKHR struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	MSize                  uint32
	NSize                  uint32
	KSize                  uint32
	AType                  ComponentTypeKHR
	BType                  ComponentTypeKHR
	CType                  ComponentTypeKHR
	ResultType             ComponentTypeKHR
	saturatingAccumulation Bool32
	scope                  ScopeKHR
}

func (s *_vkCooperativeMatrixPropertiesKHR) Goify() *CooperativeMatrixPropertiesKHR {
	rval := &CooperativeMatrixPropertiesKHR{
		PNext:                  (unsafe.Pointer)(s.pNext),
		MSize:                  (uint32)(s.MSize),
		NSize:                  (uint32)(s.NSize),
		KSize:                  (uint32)(s.KSize),
		AType:                  (ComponentTypeKHR)(s.AType),
		BType:                  (ComponentTypeKHR)(s.BType),
		CType:                  (ComponentTypeKHR)(s.CType),
		ResultType:             (ComponentTypeKHR)(s.ResultType),
		SaturatingAccumulation: translatePublic_Bool32(s.saturatingAccumulation), /*default*/
		Scope:                  (ScopeKHR)(s.scope),
	}
	return rval
}
func (s *CooperativeMatrixPropertiesKHR) Vulkanize() *_vkCooperativeMatrixPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkCooperativeMatrixPropertiesKHR{
		sType:                  STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR,   /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                          /*cb*/
		MSize:                  (uint32)(s.MSize),                                  /*cb*/
		NSize:                  (uint32)(s.NSize),                                  /*cb*/
		KSize:                  (uint32)(s.KSize),                                  /*cb*/
		AType:                  (ComponentTypeKHR)(s.AType),                        /*cb*/
		BType:                  (ComponentTypeKHR)(s.BType),                        /*cb*/
		CType:                  (ComponentTypeKHR)(s.CType),                        /*cb*/
		ResultType:             (ComponentTypeKHR)(s.ResultType),                   /*cb*/
		saturatingAccumulation: translateInternal_Bool32(s.SaturatingAccumulation), /*default*/
		scope:                  (ScopeKHR)(s.Scope),                                /*cb*/
	}
	return rval
}

// CooperativeMatrixPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCooperativeMatrixPropertiesNV.html
type CooperativeMatrixPropertiesNV struct {
	// SType = STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV
	PNext unsafe.Pointer
	MSize uint32
	NSize uint32
	KSize uint32
	AType ComponentTypeNV
	BType ComponentTypeNV
	CType ComponentTypeNV
	DType ComponentTypeNV
	Scope ScopeNV
}

type _vkCooperativeMatrixPropertiesNV struct {
	sType StructureType
	pNext unsafe.Pointer
	MSize uint32
	NSize uint32
	KSize uint32
	AType ComponentTypeNV
	BType ComponentTypeNV
	CType ComponentTypeNV
	DType ComponentTypeNV
	scope ScopeNV
}

func (s *_vkCooperativeMatrixPropertiesNV) Goify() *CooperativeMatrixPropertiesNV {
	rval := &CooperativeMatrixPropertiesNV{
		PNext: (unsafe.Pointer)(s.pNext),
		MSize: (uint32)(s.MSize),
		NSize: (uint32)(s.NSize),
		KSize: (uint32)(s.KSize),
		AType: (ComponentTypeNV)(s.AType),
		BType: (ComponentTypeNV)(s.BType),
		CType: (ComponentTypeNV)(s.CType),
		DType: (ComponentTypeNV)(s.DType),
		Scope: (ScopeNV)(s.scope),
	}
	return rval
}
func (s *CooperativeMatrixPropertiesNV) Vulkanize() *_vkCooperativeMatrixPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkCooperativeMatrixPropertiesNV{
		sType: STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                       /*cb*/
		MSize: (uint32)(s.MSize),                               /*cb*/
		NSize: (uint32)(s.NSize),                               /*cb*/
		KSize: (uint32)(s.KSize),                               /*cb*/
		AType: (ComponentTypeNV)(s.AType),                      /*cb*/
		BType: (ComponentTypeNV)(s.BType),                      /*cb*/
		CType: (ComponentTypeNV)(s.CType),                      /*cb*/
		DType: (ComponentTypeNV)(s.DType),                      /*cb*/
		scope: (ScopeNV)(s.Scope),                              /*cb*/
	}
	return rval
}

// CopyAccelerationStructureInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureInfoKHR.html
type CopyAccelerationStructureInfoKHR struct {
	// SType = STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR
	PNext unsafe.Pointer
	Src   AccelerationStructureKHR
	Dst   AccelerationStructureKHR
	Mode  CopyAccelerationStructureModeKHR
}

type _vkCopyAccelerationStructureInfoKHR struct {
	sType StructureType
	pNext unsafe.Pointer
	src   AccelerationStructureKHR
	dst   AccelerationStructureKHR
	mode  CopyAccelerationStructureModeKHR
}

func (s *_vkCopyAccelerationStructureInfoKHR) Goify() *CopyAccelerationStructureInfoKHR {
	rval := &CopyAccelerationStructureInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		Src:   (AccelerationStructureKHR)(s.src),
		Dst:   (AccelerationStructureKHR)(s.dst),
		Mode:  (CopyAccelerationStructureModeKHR)(s.mode),
	}
	return rval
}
func (s *CopyAccelerationStructureInfoKHR) Vulkanize() *_vkCopyAccelerationStructureInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkCopyAccelerationStructureInfoKHR{
		sType: STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                           /*cb*/
		src:   (AccelerationStructureKHR)(s.Src),                   /*cb*/
		dst:   (AccelerationStructureKHR)(s.Dst),                   /*cb*/
		mode:  (CopyAccelerationStructureModeKHR)(s.Mode),          /*cb*/
	}
	return rval
}

// CopyAccelerationStructureToMemoryInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html
type CopyAccelerationStructureToMemoryInfoKHR struct {
	// SType = STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR
	PNext unsafe.Pointer
	Src   AccelerationStructureKHR
	Dst   DeviceOrHostAddressKHR
	Mode  CopyAccelerationStructureModeKHR
}

type _vkCopyAccelerationStructureToMemoryInfoKHR struct {
	sType StructureType
	pNext unsafe.Pointer
	src   AccelerationStructureKHR
	dst   _vkDeviceOrHostAddressKHR
	mode  CopyAccelerationStructureModeKHR
}

func (s *_vkCopyAccelerationStructureToMemoryInfoKHR) Goify() *CopyAccelerationStructureToMemoryInfoKHR {
	rval := &CopyAccelerationStructureToMemoryInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		Src:   (AccelerationStructureKHR)(s.src),
		// Can't Goify union member dst
		Mode: (CopyAccelerationStructureModeKHR)(s.mode),
	}
	return rval
}
func (s *CopyAccelerationStructureToMemoryInfoKHR) Vulkanize() *_vkCopyAccelerationStructureToMemoryInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkCopyAccelerationStructureToMemoryInfoKHR{
		sType: STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                     /*cb*/
		src:   (AccelerationStructureKHR)(s.Src),                             /*cb*/
		dst:   *s.Dst.Vulkanize(),                                            /*c union*/
		mode:  (CopyAccelerationStructureModeKHR)(s.Mode),                    /*cb*/
	}
	return rval
}

// CopyBufferInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferInfo2.html
type CopyBufferInfo2 struct {
	// SType = STRUCTURE_TYPE_COPY_BUFFER_INFO_2
	PNext     unsafe.Pointer
	SrcBuffer Buffer
	DstBuffer Buffer
	// regionCount
	PRegions []BufferCopy2
}

type _vkCopyBufferInfo2 struct {
	sType       StructureType
	pNext       unsafe.Pointer
	srcBuffer   Buffer
	dstBuffer   Buffer
	regionCount uint32
	pRegions    *_vkBufferCopy2
}

func (s *_vkCopyBufferInfo2) Goify() *CopyBufferInfo2 {
	rval := &CopyBufferInfo2{
		PNext:     (unsafe.Pointer)(s.pNext),
		SrcBuffer: (Buffer)(s.srcBuffer),
		DstBuffer: (Buffer)(s.dstBuffer),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *CopyBufferInfo2) Vulkanize() *_vkCopyBufferInfo2 {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkBufferCopy2
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkBufferCopy2, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkCopyBufferInfo2{
		sType:       STRUCTURE_TYPE_COPY_BUFFER_INFO_2, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),         /*cb*/
		srcBuffer:   (Buffer)(s.SrcBuffer),             /*cb*/
		dstBuffer:   (Buffer)(s.DstBuffer),             /*cb*/
		regionCount: uint32(len(s.PRegions)),           /*c6-a*/
		pRegions:    psl_pRegions,                      /*c rem*/
	}
	return rval
}

// CopyBufferInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferInfo2KHR.html
type CopyBufferInfo2KHR struct {
}

type _vkCopyBufferInfo2KHR = CopyBufferInfo2KHR

func (s *_vkCopyBufferInfo2KHR) Goify() *CopyBufferInfo2KHR {
	rval := (*CopyBufferInfo2KHR)(s)
	return rval
}
func (s *CopyBufferInfo2KHR) Vulkanize() *_vkCopyBufferInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkCopyBufferInfo2KHR)(s)
	return rval
}

// CopyBufferToImageInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferToImageInfo2.html
type CopyBufferToImageInfo2 struct {
	// SType = STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2
	PNext          unsafe.Pointer
	SrcBuffer      Buffer
	DstImage       Image
	DstImageLayout ImageLayout
	// regionCount
	PRegions []BufferImageCopy2
}

type _vkCopyBufferToImageInfo2 struct {
	sType          StructureType
	pNext          unsafe.Pointer
	srcBuffer      Buffer
	dstImage       Image
	dstImageLayout ImageLayout
	regionCount    uint32
	pRegions       *_vkBufferImageCopy2
}

func (s *_vkCopyBufferToImageInfo2) Goify() *CopyBufferToImageInfo2 {
	rval := &CopyBufferToImageInfo2{
		PNext:          (unsafe.Pointer)(s.pNext),
		SrcBuffer:      (Buffer)(s.srcBuffer),
		DstImage:       (Image)(s.dstImage),
		DstImageLayout: (ImageLayout)(s.dstImageLayout),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *CopyBufferToImageInfo2) Vulkanize() *_vkCopyBufferToImageInfo2 {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkBufferImageCopy2
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkBufferImageCopy2, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkCopyBufferToImageInfo2{
		sType:          STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                  /*cb*/
		srcBuffer:      (Buffer)(s.SrcBuffer),                      /*cb*/
		dstImage:       (Image)(s.DstImage),                        /*cb*/
		dstImageLayout: (ImageLayout)(s.DstImageLayout),            /*cb*/
		regionCount:    uint32(len(s.PRegions)),                    /*c6-a*/
		pRegions:       psl_pRegions,                               /*c rem*/
	}
	return rval
}

// CopyBufferToImageInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferToImageInfo2KHR.html
type CopyBufferToImageInfo2KHR struct {
}

type _vkCopyBufferToImageInfo2KHR = CopyBufferToImageInfo2KHR

func (s *_vkCopyBufferToImageInfo2KHR) Goify() *CopyBufferToImageInfo2KHR {
	rval := (*CopyBufferToImageInfo2KHR)(s)
	return rval
}
func (s *CopyBufferToImageInfo2KHR) Vulkanize() *_vkCopyBufferToImageInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkCopyBufferToImageInfo2KHR)(s)
	return rval
}

// CopyCommandTransformInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyCommandTransformInfoQCOM.html
type CopyCommandTransformInfoQCOM struct {
	// SType = STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM
	PNext     unsafe.Pointer
	Transform SurfaceTransformFlagBitsKHR
}

type _vkCopyCommandTransformInfoQCOM struct {
	sType     StructureType
	pNext     unsafe.Pointer
	transform SurfaceTransformFlagBitsKHR
}

func (s *_vkCopyCommandTransformInfoQCOM) Goify() *CopyCommandTransformInfoQCOM {
	rval := &CopyCommandTransformInfoQCOM{
		PNext:     (unsafe.Pointer)(s.pNext),
		Transform: (SurfaceTransformFlagBitsKHR)(s.transform),
	}
	return rval
}
func (s *CopyCommandTransformInfoQCOM) Vulkanize() *_vkCopyCommandTransformInfoQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkCopyCommandTransformInfoQCOM{
		sType:     STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                       /*cb*/
		transform: (SurfaceTransformFlagBitsKHR)(s.Transform),      /*cb*/
	}
	return rval
}

// CopyDescriptorSet: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyDescriptorSet.html
type CopyDescriptorSet struct {
	// SType = STRUCTURE_TYPE_COPY_DESCRIPTOR_SET
	PNext unsafe.Pointer
	//  Source descriptor set;
	SrcSet DescriptorSet
	//  Binding within the source descriptor set to copy from;
	SrcBinding uint32
	//  Array element within the source binding to copy from;
	SrcArrayElement uint32
	//  Destination descriptor set;
	DstSet DescriptorSet
	//  Binding within the destination descriptor set to copy to;
	DstBinding uint32
	//  Array element within the destination binding to copy to;
	DstArrayElement uint32
	//  Number of descriptors to write (determines the size of the array pointed by pDescriptors);
	DescriptorCount uint32
}

type _vkCopyDescriptorSet struct {
	sType           StructureType
	pNext           unsafe.Pointer
	srcSet          DescriptorSet
	srcBinding      uint32
	srcArrayElement uint32
	dstSet          DescriptorSet
	dstBinding      uint32
	dstArrayElement uint32
	descriptorCount uint32
}

func (s *_vkCopyDescriptorSet) Goify() *CopyDescriptorSet {
	rval := &CopyDescriptorSet{
		PNext:           (unsafe.Pointer)(s.pNext),
		SrcSet:          (DescriptorSet)(s.srcSet),
		SrcBinding:      (uint32)(s.srcBinding),
		SrcArrayElement: (uint32)(s.srcArrayElement),
		DstSet:          (DescriptorSet)(s.dstSet),
		DstBinding:      (uint32)(s.dstBinding),
		DstArrayElement: (uint32)(s.dstArrayElement),
		DescriptorCount: (uint32)(s.descriptorCount),
	}
	return rval
}
func (s *CopyDescriptorSet) Vulkanize() *_vkCopyDescriptorSet {
	if s == nil {
		return nil
	}
	rval := &_vkCopyDescriptorSet{
		sType:           STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),          /*cb*/
		srcSet:          (DescriptorSet)(s.SrcSet),          /*cb*/
		srcBinding:      (uint32)(s.SrcBinding),             /*cb*/
		srcArrayElement: (uint32)(s.SrcArrayElement),        /*cb*/
		dstSet:          (DescriptorSet)(s.DstSet),          /*cb*/
		dstBinding:      (uint32)(s.DstBinding),             /*cb*/
		dstArrayElement: (uint32)(s.DstArrayElement),        /*cb*/
		descriptorCount: (uint32)(s.DescriptorCount),        /*cb*/
	}
	return rval
}

// CopyImageInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageInfo2.html
type CopyImageInfo2 struct {
	// SType = STRUCTURE_TYPE_COPY_IMAGE_INFO_2
	PNext          unsafe.Pointer
	SrcImage       Image
	SrcImageLayout ImageLayout
	DstImage       Image
	DstImageLayout ImageLayout
	// regionCount
	PRegions []ImageCopy2
}

type _vkCopyImageInfo2 struct {
	sType          StructureType
	pNext          unsafe.Pointer
	srcImage       Image
	srcImageLayout ImageLayout
	dstImage       Image
	dstImageLayout ImageLayout
	regionCount    uint32
	pRegions       *_vkImageCopy2
}

func (s *_vkCopyImageInfo2) Goify() *CopyImageInfo2 {
	rval := &CopyImageInfo2{
		PNext:          (unsafe.Pointer)(s.pNext),
		SrcImage:       (Image)(s.srcImage),
		SrcImageLayout: (ImageLayout)(s.srcImageLayout),
		DstImage:       (Image)(s.dstImage),
		DstImageLayout: (ImageLayout)(s.dstImageLayout),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *CopyImageInfo2) Vulkanize() *_vkCopyImageInfo2 {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkImageCopy2
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkImageCopy2, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkCopyImageInfo2{
		sType:          STRUCTURE_TYPE_COPY_IMAGE_INFO_2, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),        /*cb*/
		srcImage:       (Image)(s.SrcImage),              /*cb*/
		srcImageLayout: (ImageLayout)(s.SrcImageLayout),  /*cb*/
		dstImage:       (Image)(s.DstImage),              /*cb*/
		dstImageLayout: (ImageLayout)(s.DstImageLayout),  /*cb*/
		regionCount:    uint32(len(s.PRegions)),          /*c6-a*/
		pRegions:       psl_pRegions,                     /*c rem*/
	}
	return rval
}

// CopyImageInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageInfo2KHR.html
type CopyImageInfo2KHR struct {
}

type _vkCopyImageInfo2KHR = CopyImageInfo2KHR

func (s *_vkCopyImageInfo2KHR) Goify() *CopyImageInfo2KHR {
	rval := (*CopyImageInfo2KHR)(s)
	return rval
}
func (s *CopyImageInfo2KHR) Vulkanize() *_vkCopyImageInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkCopyImageInfo2KHR)(s)
	return rval
}

// CopyImageToBufferInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageToBufferInfo2.html
type CopyImageToBufferInfo2 struct {
	// SType = STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2
	PNext          unsafe.Pointer
	SrcImage       Image
	SrcImageLayout ImageLayout
	DstBuffer      Buffer
	// regionCount
	PRegions []BufferImageCopy2
}

type _vkCopyImageToBufferInfo2 struct {
	sType          StructureType
	pNext          unsafe.Pointer
	srcImage       Image
	srcImageLayout ImageLayout
	dstBuffer      Buffer
	regionCount    uint32
	pRegions       *_vkBufferImageCopy2
}

func (s *_vkCopyImageToBufferInfo2) Goify() *CopyImageToBufferInfo2 {
	rval := &CopyImageToBufferInfo2{
		PNext:          (unsafe.Pointer)(s.pNext),
		SrcImage:       (Image)(s.srcImage),
		SrcImageLayout: (ImageLayout)(s.srcImageLayout),
		DstBuffer:      (Buffer)(s.dstBuffer),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *CopyImageToBufferInfo2) Vulkanize() *_vkCopyImageToBufferInfo2 {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkBufferImageCopy2
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkBufferImageCopy2, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkCopyImageToBufferInfo2{
		sType:          STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                  /*cb*/
		srcImage:       (Image)(s.SrcImage),                        /*cb*/
		srcImageLayout: (ImageLayout)(s.SrcImageLayout),            /*cb*/
		dstBuffer:      (Buffer)(s.DstBuffer),                      /*cb*/
		regionCount:    uint32(len(s.PRegions)),                    /*c6-a*/
		pRegions:       psl_pRegions,                               /*c rem*/
	}
	return rval
}

// CopyImageToBufferInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageToBufferInfo2KHR.html
type CopyImageToBufferInfo2KHR struct {
}

type _vkCopyImageToBufferInfo2KHR = CopyImageToBufferInfo2KHR

func (s *_vkCopyImageToBufferInfo2KHR) Goify() *CopyImageToBufferInfo2KHR {
	rval := (*CopyImageToBufferInfo2KHR)(s)
	return rval
}
func (s *CopyImageToBufferInfo2KHR) Vulkanize() *_vkCopyImageToBufferInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkCopyImageToBufferInfo2KHR)(s)
	return rval
}

// CopyImageToImageInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageToImageInfoEXT.html
type CopyImageToImageInfoEXT struct {
	// SType = STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT
	PNext          unsafe.Pointer
	Flags          HostImageCopyFlagsEXT
	SrcImage       Image
	SrcImageLayout ImageLayout
	DstImage       Image
	DstImageLayout ImageLayout
	// regionCount
	PRegions []ImageCopy2
}

type _vkCopyImageToImageInfoEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	flags          HostImageCopyFlagsEXT
	srcImage       Image
	srcImageLayout ImageLayout
	dstImage       Image
	dstImageLayout ImageLayout
	regionCount    uint32
	pRegions       *_vkImageCopy2
}

func (s *_vkCopyImageToImageInfoEXT) Goify() *CopyImageToImageInfoEXT {
	rval := &CopyImageToImageInfoEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		Flags:          (HostImageCopyFlagsEXT)(s.flags),
		SrcImage:       (Image)(s.srcImage),
		SrcImageLayout: (ImageLayout)(s.srcImageLayout),
		DstImage:       (Image)(s.dstImage),
		DstImageLayout: (ImageLayout)(s.dstImageLayout),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *CopyImageToImageInfoEXT) Vulkanize() *_vkCopyImageToImageInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkImageCopy2
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkImageCopy2, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkCopyImageToImageInfoEXT{
		sType:          STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                   /*cb*/
		flags:          (HostImageCopyFlagsEXT)(s.Flags),            /*cb*/
		srcImage:       (Image)(s.SrcImage),                         /*cb*/
		srcImageLayout: (ImageLayout)(s.SrcImageLayout),             /*cb*/
		dstImage:       (Image)(s.DstImage),                         /*cb*/
		dstImageLayout: (ImageLayout)(s.DstImageLayout),             /*cb*/
		regionCount:    uint32(len(s.PRegions)),                     /*c6-a*/
		pRegions:       psl_pRegions,                                /*c rem*/
	}
	return rval
}

// CopyImageToMemoryInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageToMemoryInfoEXT.html
type CopyImageToMemoryInfoEXT struct {
	// SType = STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT
	PNext          unsafe.Pointer
	Flags          HostImageCopyFlagsEXT
	SrcImage       Image
	SrcImageLayout ImageLayout
	// regionCount
	PRegions []ImageToMemoryCopyEXT
}

type _vkCopyImageToMemoryInfoEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	flags          HostImageCopyFlagsEXT
	srcImage       Image
	srcImageLayout ImageLayout
	regionCount    uint32
	pRegions       *_vkImageToMemoryCopyEXT
}

func (s *_vkCopyImageToMemoryInfoEXT) Goify() *CopyImageToMemoryInfoEXT {
	rval := &CopyImageToMemoryInfoEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		Flags:          (HostImageCopyFlagsEXT)(s.flags),
		SrcImage:       (Image)(s.srcImage),
		SrcImageLayout: (ImageLayout)(s.srcImageLayout),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *CopyImageToMemoryInfoEXT) Vulkanize() *_vkCopyImageToMemoryInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkImageToMemoryCopyEXT
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkImageToMemoryCopyEXT, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkCopyImageToMemoryInfoEXT{
		sType:          STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                    /*cb*/
		flags:          (HostImageCopyFlagsEXT)(s.Flags),             /*cb*/
		srcImage:       (Image)(s.SrcImage),                          /*cb*/
		srcImageLayout: (ImageLayout)(s.SrcImageLayout),              /*cb*/
		regionCount:    uint32(len(s.PRegions)),                      /*c6-a*/
		pRegions:       psl_pRegions,                                 /*c rem*/
	}
	return rval
}

// CopyMemoryIndirectCommandNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryIndirectCommandNV.html
type CopyMemoryIndirectCommandNV struct {
	SrcAddress DeviceAddress
	DstAddress DeviceAddress
	//  Specified in bytes;
	Size DeviceSize
}

type _vkCopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandNV

func (s *_vkCopyMemoryIndirectCommandNV) Goify() *CopyMemoryIndirectCommandNV {
	rval := (*CopyMemoryIndirectCommandNV)(s)
	return rval
}
func (s *CopyMemoryIndirectCommandNV) Vulkanize() *_vkCopyMemoryIndirectCommandNV {
	if s == nil {
		return nil
	}
	rval := (*_vkCopyMemoryIndirectCommandNV)(s)
	return rval
}

// CopyMemoryToAccelerationStructureInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html
type CopyMemoryToAccelerationStructureInfoKHR struct {
	// SType = STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR
	PNext unsafe.Pointer
	Src   DeviceOrHostAddressConstKHR
	Dst   AccelerationStructureKHR
	Mode  CopyAccelerationStructureModeKHR
}

type _vkCopyMemoryToAccelerationStructureInfoKHR struct {
	sType StructureType
	pNext unsafe.Pointer
	src   _vkDeviceOrHostAddressConstKHR
	dst   AccelerationStructureKHR
	mode  CopyAccelerationStructureModeKHR
}

func (s *_vkCopyMemoryToAccelerationStructureInfoKHR) Goify() *CopyMemoryToAccelerationStructureInfoKHR {
	rval := &CopyMemoryToAccelerationStructureInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Can't Goify union member src
		Dst:  (AccelerationStructureKHR)(s.dst),
		Mode: (CopyAccelerationStructureModeKHR)(s.mode),
	}
	return rval
}
func (s *CopyMemoryToAccelerationStructureInfoKHR) Vulkanize() *_vkCopyMemoryToAccelerationStructureInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkCopyMemoryToAccelerationStructureInfoKHR{
		sType: STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                     /*cb*/
		src:   *s.Src.Vulkanize(),                                            /*c union*/
		dst:   (AccelerationStructureKHR)(s.Dst),                             /*cb*/
		mode:  (CopyAccelerationStructureModeKHR)(s.Mode),                    /*cb*/
	}
	return rval
}

// CopyMemoryToImageIndirectCommandNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToImageIndirectCommandNV.html
type CopyMemoryToImageIndirectCommandNV struct {
	SrcAddress DeviceAddress
	//  Specified in texels;
	BufferRowLength   uint32
	BufferImageHeight uint32
	ImageSubresource  ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	ImageOffset Offset3D
	//  Specified in pixels for both compressed and uncompressed images;
	ImageExtent Extent3D
}

type _vkCopyMemoryToImageIndirectCommandNV struct {
	srcAddress        DeviceAddress
	bufferRowLength   uint32
	bufferImageHeight uint32
	imageSubresource  _vkImageSubresourceLayers
	imageOffset       _vkOffset3D
	imageExtent       _vkExtent3D
}

func (s *_vkCopyMemoryToImageIndirectCommandNV) Goify() *CopyMemoryToImageIndirectCommandNV {
	rval := &CopyMemoryToImageIndirectCommandNV{
		SrcAddress:        (DeviceAddress)(s.srcAddress),
		BufferRowLength:   (uint32)(s.bufferRowLength),
		BufferImageHeight: (uint32)(s.bufferImageHeight),
		ImageSubresource:  (ImageSubresourceLayers)(s.imageSubresource),
		ImageOffset:       (Offset3D)(s.imageOffset),
		ImageExtent:       (Extent3D)(s.imageExtent),
	}
	return rval
}
func (s *CopyMemoryToImageIndirectCommandNV) Vulkanize() *_vkCopyMemoryToImageIndirectCommandNV {
	if s == nil {
		return nil
	}
	rval := &_vkCopyMemoryToImageIndirectCommandNV{
		srcAddress:        (DeviceAddress)(s.SrcAddress),                   /*cb*/
		bufferRowLength:   (uint32)(s.BufferRowLength),                     /*cb*/
		bufferImageHeight: (uint32)(s.BufferImageHeight),                   /*cb*/
		imageSubresource:  (_vkImageSubresourceLayers)(s.ImageSubresource), /*cb*/
		imageOffset:       (_vkOffset3D)(s.ImageOffset),                    /*cb*/
		imageExtent:       (_vkExtent3D)(s.ImageExtent),                    /*cb*/
	}
	return rval
}

// CopyMemoryToImageInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToImageInfoEXT.html
type CopyMemoryToImageInfoEXT struct {
	// SType = STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT
	PNext          unsafe.Pointer
	Flags          HostImageCopyFlagsEXT
	DstImage       Image
	DstImageLayout ImageLayout
	// regionCount
	PRegions []MemoryToImageCopyEXT
}

type _vkCopyMemoryToImageInfoEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	flags          HostImageCopyFlagsEXT
	dstImage       Image
	dstImageLayout ImageLayout
	regionCount    uint32
	pRegions       *_vkMemoryToImageCopyEXT
}

func (s *_vkCopyMemoryToImageInfoEXT) Goify() *CopyMemoryToImageInfoEXT {
	rval := &CopyMemoryToImageInfoEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		Flags:          (HostImageCopyFlagsEXT)(s.flags),
		DstImage:       (Image)(s.dstImage),
		DstImageLayout: (ImageLayout)(s.dstImageLayout),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *CopyMemoryToImageInfoEXT) Vulkanize() *_vkCopyMemoryToImageInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkMemoryToImageCopyEXT
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkMemoryToImageCopyEXT, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkCopyMemoryToImageInfoEXT{
		sType:          STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                    /*cb*/
		flags:          (HostImageCopyFlagsEXT)(s.Flags),             /*cb*/
		dstImage:       (Image)(s.DstImage),                          /*cb*/
		dstImageLayout: (ImageLayout)(s.DstImageLayout),              /*cb*/
		regionCount:    uint32(len(s.PRegions)),                      /*c6-a*/
		pRegions:       psl_pRegions,                                 /*c rem*/
	}
	return rval
}

// CopyMemoryToMicromapInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToMicromapInfoEXT.html
type CopyMemoryToMicromapInfoEXT struct {
	// SType = STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT
	PNext unsafe.Pointer
	Src   DeviceOrHostAddressConstKHR
	Dst   MicromapEXT
	Mode  CopyMicromapModeEXT
}

type _vkCopyMemoryToMicromapInfoEXT struct {
	sType StructureType
	pNext unsafe.Pointer
	src   _vkDeviceOrHostAddressConstKHR
	dst   MicromapEXT
	mode  CopyMicromapModeEXT
}

func (s *_vkCopyMemoryToMicromapInfoEXT) Goify() *CopyMemoryToMicromapInfoEXT {
	rval := &CopyMemoryToMicromapInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Can't Goify union member src
		Dst:  (MicromapEXT)(s.dst),
		Mode: (CopyMicromapModeEXT)(s.mode),
	}
	return rval
}
func (s *CopyMemoryToMicromapInfoEXT) Vulkanize() *_vkCopyMemoryToMicromapInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkCopyMemoryToMicromapInfoEXT{
		sType: STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                       /*cb*/
		src:   *s.Src.Vulkanize(),                              /*c union*/
		dst:   (MicromapEXT)(s.Dst),                            /*cb*/
		mode:  (CopyMicromapModeEXT)(s.Mode),                   /*cb*/
	}
	return rval
}

// CopyMicromapInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMicromapInfoEXT.html
type CopyMicromapInfoEXT struct {
	// SType = STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT
	PNext unsafe.Pointer
	Src   MicromapEXT
	Dst   MicromapEXT
	Mode  CopyMicromapModeEXT
}

type _vkCopyMicromapInfoEXT struct {
	sType StructureType
	pNext unsafe.Pointer
	src   MicromapEXT
	dst   MicromapEXT
	mode  CopyMicromapModeEXT
}

func (s *_vkCopyMicromapInfoEXT) Goify() *CopyMicromapInfoEXT {
	rval := &CopyMicromapInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		Src:   (MicromapEXT)(s.src),
		Dst:   (MicromapEXT)(s.dst),
		Mode:  (CopyMicromapModeEXT)(s.mode),
	}
	return rval
}
func (s *CopyMicromapInfoEXT) Vulkanize() *_vkCopyMicromapInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkCopyMicromapInfoEXT{
		sType: STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),             /*cb*/
		src:   (MicromapEXT)(s.Src),                  /*cb*/
		dst:   (MicromapEXT)(s.Dst),                  /*cb*/
		mode:  (CopyMicromapModeEXT)(s.Mode),         /*cb*/
	}
	return rval
}

// CopyMicromapToMemoryInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMicromapToMemoryInfoEXT.html
type CopyMicromapToMemoryInfoEXT struct {
	// SType = STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT
	PNext unsafe.Pointer
	Src   MicromapEXT
	Dst   DeviceOrHostAddressKHR
	Mode  CopyMicromapModeEXT
}

type _vkCopyMicromapToMemoryInfoEXT struct {
	sType StructureType
	pNext unsafe.Pointer
	src   MicromapEXT
	dst   _vkDeviceOrHostAddressKHR
	mode  CopyMicromapModeEXT
}

func (s *_vkCopyMicromapToMemoryInfoEXT) Goify() *CopyMicromapToMemoryInfoEXT {
	rval := &CopyMicromapToMemoryInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		Src:   (MicromapEXT)(s.src),
		// Can't Goify union member dst
		Mode: (CopyMicromapModeEXT)(s.mode),
	}
	return rval
}
func (s *CopyMicromapToMemoryInfoEXT) Vulkanize() *_vkCopyMicromapToMemoryInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkCopyMicromapToMemoryInfoEXT{
		sType: STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                       /*cb*/
		src:   (MicromapEXT)(s.Src),                            /*cb*/
		dst:   *s.Dst.Vulkanize(),                              /*c union*/
		mode:  (CopyMicromapModeEXT)(s.Mode),                   /*cb*/
	}
	return rval
}

// CuFunctionCreateInfoNVX: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionCreateInfoNVX.html
type CuFunctionCreateInfoNVX struct {
	// SType = STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX
	PNext  unsafe.Pointer
	Module CuModuleNVX
	PName  string
}

type _vkCuFunctionCreateInfoNVX struct {
	sType  StructureType
	pNext  unsafe.Pointer
	module CuModuleNVX
	pName  *byte
}

func (s *_vkCuFunctionCreateInfoNVX) Goify() *CuFunctionCreateInfoNVX {
	rval := &CuFunctionCreateInfoNVX{
		PNext:  (unsafe.Pointer)(s.pNext),
		Module: (CuModuleNVX)(s.module),
		// Unexpected pointer member pName in returned struct
	}
	return rval
}
func (s *CuFunctionCreateInfoNVX) Vulkanize() *_vkCuFunctionCreateInfoNVX {
	if s == nil {
		return nil
	}
	rval := &_vkCuFunctionCreateInfoNVX{
		sType:  STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                  /*cb*/
		module: (CuModuleNVX)(s.Module),                    /*cb*/
		pName:  sys_stringToBytePointer(s.PName),           /*c rem*/
	}
	return rval
}

// CuLaunchInfoNVX: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuLaunchInfoNVX.html
type CuLaunchInfoNVX struct {
	// SType = STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX
	PNext          unsafe.Pointer
	Function       CuFunctionNVX
	GridDimX       uint32
	GridDimY       uint32
	GridDimZ       uint32
	BlockDimX      uint32
	BlockDimY      uint32
	BlockDimZ      uint32
	SharedMemBytes uint32
	// paramCount
	PParams []*byte
	// extraCount
	PExtras []*byte
}

type _vkCuLaunchInfoNVX struct {
	sType          StructureType
	pNext          unsafe.Pointer
	function       CuFunctionNVX
	gridDimX       uint32
	gridDimY       uint32
	gridDimZ       uint32
	blockDimX      uint32
	blockDimY      uint32
	blockDimZ      uint32
	sharedMemBytes uint32
	paramCount     uintptr
	pParams        **byte
	extraCount     uintptr
	pExtras        **byte
}

func (s *_vkCuLaunchInfoNVX) Goify() *CuLaunchInfoNVX {
	rval := &CuLaunchInfoNVX{
		PNext:          (unsafe.Pointer)(s.pNext),
		Function:       (CuFunctionNVX)(s.function),
		GridDimX:       (uint32)(s.gridDimX),
		GridDimY:       (uint32)(s.gridDimY),
		GridDimZ:       (uint32)(s.gridDimZ),
		BlockDimX:      (uint32)(s.blockDimX),
		BlockDimY:      (uint32)(s.blockDimY),
		BlockDimZ:      (uint32)(s.blockDimZ),
		SharedMemBytes: (uint32)(s.sharedMemBytes),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pParams in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pExtras in returned struct
	}
	return rval
}
func (s *CuLaunchInfoNVX) Vulkanize() *_vkCuLaunchInfoNVX {
	if s == nil {
		return nil
	}

	var psl_pParams **byte
	if len(s.PParams) > 0 {
		psl_pParams = &s.PParams[0]
	}

	var psl_pExtras **byte
	if len(s.PExtras) > 0 {
		psl_pExtras = &s.PExtras[0]
	}
	rval := &_vkCuLaunchInfoNVX{
		sType:          STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),         /*cb*/
		function:       (CuFunctionNVX)(s.Function),       /*cb*/
		gridDimX:       (uint32)(s.GridDimX),              /*cb*/
		gridDimY:       (uint32)(s.GridDimY),              /*cb*/
		gridDimZ:       (uint32)(s.GridDimZ),              /*cb*/
		blockDimX:      (uint32)(s.BlockDimX),             /*cb*/
		blockDimY:      (uint32)(s.BlockDimY),             /*cb*/
		blockDimZ:      (uint32)(s.BlockDimZ),             /*cb*/
		sharedMemBytes: (uint32)(s.SharedMemBytes),        /*cb*/
		paramCount:     uintptr(len(s.PParams)),           /*c6-a*/
		pParams:        psl_pParams,                       /*c rem*/
		extraCount:     uintptr(len(s.PExtras)),           /*c6-a*/
		pExtras:        psl_pExtras,                       /*c rem*/
	}
	return rval
}

// CuModuleCreateInfoNVX: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleCreateInfoNVX.html
type CuModuleCreateInfoNVX struct {
	// SType = STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX
	PNext    unsafe.Pointer
	DataSize uintptr
	PData    unsafe.Pointer
}

type _vkCuModuleCreateInfoNVX struct {
	sType    StructureType
	pNext    unsafe.Pointer
	dataSize uintptr
	pData    unsafe.Pointer
}

func (s *_vkCuModuleCreateInfoNVX) Goify() *CuModuleCreateInfoNVX {
	rval := &CuModuleCreateInfoNVX{
		PNext:    (unsafe.Pointer)(s.pNext),
		DataSize: (uintptr)(s.dataSize),
		PData:    (unsafe.Pointer)(s.pData),
	}
	return rval
}
func (s *CuModuleCreateInfoNVX) Vulkanize() *_vkCuModuleCreateInfoNVX {
	if s == nil {
		return nil
	}
	rval := &_vkCuModuleCreateInfoNVX{
		sType:    STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                /*cb*/
		dataSize: (uintptr)(s.DataSize),                    /*cb*/
		pData:    (unsafe.Pointer)(s.PData),                /*cb*/
	}
	return rval
}

// CudaFunctionCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCudaFunctionCreateInfoNV.html
type CudaFunctionCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV
	PNext  unsafe.Pointer
	Module CudaModuleNV
	PName  string
}

type _vkCudaFunctionCreateInfoNV struct {
	sType  StructureType
	pNext  unsafe.Pointer
	module CudaModuleNV
	pName  *byte
}

func (s *_vkCudaFunctionCreateInfoNV) Goify() *CudaFunctionCreateInfoNV {
	rval := &CudaFunctionCreateInfoNV{
		PNext:  (unsafe.Pointer)(s.pNext),
		Module: (CudaModuleNV)(s.module),
		// Unexpected pointer member pName in returned struct
	}
	return rval
}
func (s *CudaFunctionCreateInfoNV) Vulkanize() *_vkCudaFunctionCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkCudaFunctionCreateInfoNV{
		sType:  STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                   /*cb*/
		module: (CudaModuleNV)(s.Module),                    /*cb*/
		pName:  sys_stringToBytePointer(s.PName),            /*c rem*/
	}
	return rval
}

// CudaLaunchInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCudaLaunchInfoNV.html
type CudaLaunchInfoNV struct {
	// SType = STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV
	PNext          unsafe.Pointer
	Function       CudaFunctionNV
	GridDimX       uint32
	GridDimY       uint32
	GridDimZ       uint32
	BlockDimX      uint32
	BlockDimY      uint32
	BlockDimZ      uint32
	SharedMemBytes uint32
	// paramCount
	PParams []*byte
	// extraCount
	PExtras []*byte
}

type _vkCudaLaunchInfoNV struct {
	sType          StructureType
	pNext          unsafe.Pointer
	function       CudaFunctionNV
	gridDimX       uint32
	gridDimY       uint32
	gridDimZ       uint32
	blockDimX      uint32
	blockDimY      uint32
	blockDimZ      uint32
	sharedMemBytes uint32
	paramCount     uintptr
	pParams        **byte
	extraCount     uintptr
	pExtras        **byte
}

func (s *_vkCudaLaunchInfoNV) Goify() *CudaLaunchInfoNV {
	rval := &CudaLaunchInfoNV{
		PNext:          (unsafe.Pointer)(s.pNext),
		Function:       (CudaFunctionNV)(s.function),
		GridDimX:       (uint32)(s.gridDimX),
		GridDimY:       (uint32)(s.gridDimY),
		GridDimZ:       (uint32)(s.gridDimZ),
		BlockDimX:      (uint32)(s.blockDimX),
		BlockDimY:      (uint32)(s.blockDimY),
		BlockDimZ:      (uint32)(s.blockDimZ),
		SharedMemBytes: (uint32)(s.sharedMemBytes),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pParams in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pExtras in returned struct
	}
	return rval
}
func (s *CudaLaunchInfoNV) Vulkanize() *_vkCudaLaunchInfoNV {
	if s == nil {
		return nil
	}

	var psl_pParams **byte
	if len(s.PParams) > 0 {
		psl_pParams = &s.PParams[0]
	}

	var psl_pExtras **byte
	if len(s.PExtras) > 0 {
		psl_pExtras = &s.PExtras[0]
	}
	rval := &_vkCudaLaunchInfoNV{
		sType:          STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),          /*cb*/
		function:       (CudaFunctionNV)(s.Function),       /*cb*/
		gridDimX:       (uint32)(s.GridDimX),               /*cb*/
		gridDimY:       (uint32)(s.GridDimY),               /*cb*/
		gridDimZ:       (uint32)(s.GridDimZ),               /*cb*/
		blockDimX:      (uint32)(s.BlockDimX),              /*cb*/
		blockDimY:      (uint32)(s.BlockDimY),              /*cb*/
		blockDimZ:      (uint32)(s.BlockDimZ),              /*cb*/
		sharedMemBytes: (uint32)(s.SharedMemBytes),         /*cb*/
		paramCount:     uintptr(len(s.PParams)),            /*c6-a*/
		pParams:        psl_pParams,                        /*c rem*/
		extraCount:     uintptr(len(s.PExtras)),            /*c6-a*/
		pExtras:        psl_pExtras,                        /*c rem*/
	}
	return rval
}

// CudaModuleCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCudaModuleCreateInfoNV.html
type CudaModuleCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV
	PNext    unsafe.Pointer
	DataSize uintptr
	PData    unsafe.Pointer
}

type _vkCudaModuleCreateInfoNV struct {
	sType    StructureType
	pNext    unsafe.Pointer
	dataSize uintptr
	pData    unsafe.Pointer
}

func (s *_vkCudaModuleCreateInfoNV) Goify() *CudaModuleCreateInfoNV {
	rval := &CudaModuleCreateInfoNV{
		PNext:    (unsafe.Pointer)(s.pNext),
		DataSize: (uintptr)(s.dataSize),
		PData:    (unsafe.Pointer)(s.pData),
	}
	return rval
}
func (s *CudaModuleCreateInfoNV) Vulkanize() *_vkCudaModuleCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkCudaModuleCreateInfoNV{
		sType:    STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                 /*cb*/
		dataSize: (uintptr)(s.DataSize),                     /*cb*/
		pData:    (unsafe.Pointer)(s.PData),                 /*cb*/
	}
	return rval
}

// DebugMarkerMarkerInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerMarkerInfoEXT.html
type DebugMarkerMarkerInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT
	PNext unsafe.Pointer
	//  Name of the debug marker;
	PMarkerName string
	//  Optional color for debug marker;
	Color [4]float32
}

type _vkDebugMarkerMarkerInfoEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	pMarkerName *byte
	color       [4]float32
}

func (s *_vkDebugMarkerMarkerInfoEXT) Goify() *DebugMarkerMarkerInfoEXT {
	rval := &DebugMarkerMarkerInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected pointer member pMarkerName in returned struct
		Color: ([4]float32)(s.color),
	}
	return rval
}
func (s *DebugMarkerMarkerInfoEXT) Vulkanize() *_vkDebugMarkerMarkerInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDebugMarkerMarkerInfoEXT{
		sType:       STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                   /*cb*/
		pMarkerName: sys_stringToBytePointer(s.PMarkerName),      /*c rem*/
		color:       ([4]float32)(s.Color),                       /*cb*/
	}
	return rval
}

// DebugMarkerObjectNameInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectNameInfoEXT.html
type DebugMarkerObjectNameInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT
	PNext unsafe.Pointer
	//  The type of the object;
	ObjectType DebugReportObjectTypeEXT
	//  The handle of the object, cast to uint64_t;
	Object uint64
	//  Name to apply to the object;
	PObjectName string
}

type _vkDebugMarkerObjectNameInfoEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	objectType  DebugReportObjectTypeEXT
	object      uint64
	pObjectName *byte
}

func (s *_vkDebugMarkerObjectNameInfoEXT) Goify() *DebugMarkerObjectNameInfoEXT {
	rval := &DebugMarkerObjectNameInfoEXT{
		PNext:      (unsafe.Pointer)(s.pNext),
		ObjectType: (DebugReportObjectTypeEXT)(s.objectType),
		Object:     (uint64)(s.object),
		// Unexpected pointer member pObjectName in returned struct
	}
	return rval
}
func (s *DebugMarkerObjectNameInfoEXT) Vulkanize() *_vkDebugMarkerObjectNameInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDebugMarkerObjectNameInfoEXT{
		sType:       STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                        /*cb*/
		objectType:  (DebugReportObjectTypeEXT)(s.ObjectType),         /*cb*/
		object:      (uint64)(s.Object),                               /*cb*/
		pObjectName: sys_stringToBytePointer(s.PObjectName),           /*c rem*/
	}
	return rval
}

// DebugMarkerObjectTagInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectTagInfoEXT.html
type DebugMarkerObjectTagInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT
	PNext unsafe.Pointer
	//  The type of the object;
	ObjectType DebugReportObjectTypeEXT
	//  The handle of the object, cast to uint64_t;
	Object uint64
	//  The name of the tag to set on the object;
	TagName uint64
	//  The length in bytes of the tag data;
	TagSize uintptr
	//  Tag data to attach to the object;
	PTag unsafe.Pointer
}

type _vkDebugMarkerObjectTagInfoEXT struct {
	sType      StructureType
	pNext      unsafe.Pointer
	objectType DebugReportObjectTypeEXT
	object     uint64
	tagName    uint64
	tagSize    uintptr
	pTag       unsafe.Pointer
}

func (s *_vkDebugMarkerObjectTagInfoEXT) Goify() *DebugMarkerObjectTagInfoEXT {
	rval := &DebugMarkerObjectTagInfoEXT{
		PNext:      (unsafe.Pointer)(s.pNext),
		ObjectType: (DebugReportObjectTypeEXT)(s.objectType),
		Object:     (uint64)(s.object),
		TagName:    (uint64)(s.tagName),
		TagSize:    (uintptr)(s.tagSize),
		PTag:       (unsafe.Pointer)(s.pTag),
	}
	return rval
}
func (s *DebugMarkerObjectTagInfoEXT) Vulkanize() *_vkDebugMarkerObjectTagInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDebugMarkerObjectTagInfoEXT{
		sType:      STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                       /*cb*/
		objectType: (DebugReportObjectTypeEXT)(s.ObjectType),        /*cb*/
		object:     (uint64)(s.Object),                              /*cb*/
		tagName:    (uint64)(s.TagName),                             /*cb*/
		tagSize:    (uintptr)(s.TagSize),                            /*cb*/
		pTag:       (unsafe.Pointer)(s.PTag),                        /*cb*/
	}
	return rval
}

// DebugReportCallbackCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackCreateInfoEXT.html
type DebugReportCallbackCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
	PNext unsafe.Pointer
	//  Indicates which events call this callback;
	Flags DebugReportFlagsEXT
	//  Function pointer of a callback function;
	PfnCallback PFN_vkDebugReportCallbackEXT
	//  User data provided to callback function;
	PUserData unsafe.Pointer
}

type _vkDebugReportCallbackCreateInfoEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	flags       DebugReportFlagsEXT
	pfnCallback PFN_vkDebugReportCallbackEXT
	pUserData   unsafe.Pointer
}

func (s *_vkDebugReportCallbackCreateInfoEXT) Goify() *DebugReportCallbackCreateInfoEXT {
	rval := &DebugReportCallbackCreateInfoEXT{
		PNext:       (unsafe.Pointer)(s.pNext),
		Flags:       (DebugReportFlagsEXT)(s.flags),
		PfnCallback: (PFN_vkDebugReportCallbackEXT)(s.pfnCallback),
		PUserData:   (unsafe.Pointer)(s.pUserData),
	}
	return rval
}
func (s *DebugReportCallbackCreateInfoEXT) Vulkanize() *_vkDebugReportCallbackCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDebugReportCallbackCreateInfoEXT{
		sType:       STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                            /*cb*/
		flags:       (DebugReportFlagsEXT)(s.Flags),                       /*cb*/
		pfnCallback: (PFN_vkDebugReportCallbackEXT)(s.PfnCallback),        /*cb*/
		pUserData:   (unsafe.Pointer)(s.PUserData),                        /*cb*/
	}
	return rval
}

// DebugUtilsLabelEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsLabelEXT.html
type DebugUtilsLabelEXT struct {
	// SType = STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT
	PNext      unsafe.Pointer
	PLabelName string
	Color      [4]float32
}

type _vkDebugUtilsLabelEXT struct {
	sType      StructureType
	pNext      unsafe.Pointer
	pLabelName *byte
	color      [4]float32
}

func (s *_vkDebugUtilsLabelEXT) Goify() *DebugUtilsLabelEXT {
	rval := &DebugUtilsLabelEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected pointer member pLabelName in returned struct
		Color: ([4]float32)(s.color),
	}
	return rval
}
func (s *DebugUtilsLabelEXT) Vulkanize() *_vkDebugUtilsLabelEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDebugUtilsLabelEXT{
		sType:      STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT,  /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),             /*cb*/
		pLabelName: sys_stringToBytePointer(s.PLabelName), /*c rem*/
		color:      ([4]float32)(s.Color),                 /*cb*/
	}
	return rval
}

// DebugUtilsMessengerCallbackDataEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataEXT.html
type DebugUtilsMessengerCallbackDataEXT struct {
	// SType = STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT
	PNext           unsafe.Pointer
	Flags           DebugUtilsMessengerCallbackDataFlagsEXT
	PMessageIdName  string
	MessageIdNumber int32
	PMessage        string
	// queueLabelCount
	PQueueLabels []DebugUtilsLabelEXT
	// cmdBufLabelCount
	PCmdBufLabels []DebugUtilsLabelEXT
	// objectCount
	PObjects []DebugUtilsObjectNameInfoEXT
}

type _vkDebugUtilsMessengerCallbackDataEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	flags            DebugUtilsMessengerCallbackDataFlagsEXT
	pMessageIdName   *byte
	messageIdNumber  int32
	pMessage         *byte
	queueLabelCount  uint32
	pQueueLabels     *_vkDebugUtilsLabelEXT
	cmdBufLabelCount uint32
	pCmdBufLabels    *_vkDebugUtilsLabelEXT
	objectCount      uint32
	pObjects         *_vkDebugUtilsObjectNameInfoEXT
}

func (s *_vkDebugUtilsMessengerCallbackDataEXT) Goify() *DebugUtilsMessengerCallbackDataEXT {
	rval := &DebugUtilsMessengerCallbackDataEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (DebugUtilsMessengerCallbackDataFlagsEXT)(s.flags),
		// Unexpected pointer member pMessageIdName in returned struct
		MessageIdNumber: (int32)(s.messageIdNumber),
		// Unexpected pointer member pMessage in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pQueueLabels in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCmdBufLabels in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pObjects in returned struct
	}
	return rval
}
func (s *DebugUtilsMessengerCallbackDataEXT) Vulkanize() *_vkDebugUtilsMessengerCallbackDataEXT {
	if s == nil {
		return nil
	}

	var psl_pQueueLabels *_vkDebugUtilsLabelEXT
	if len(s.PQueueLabels) > 0 {
		sl_pQueueLabels := make([]_vkDebugUtilsLabelEXT, len(s.PQueueLabels))
		for i, v := range s.PQueueLabels {
			sl_pQueueLabels[i] = *(v.Vulkanize())
		}
		psl_pQueueLabels = &sl_pQueueLabels[0]
	}

	var psl_pCmdBufLabels *_vkDebugUtilsLabelEXT
	if len(s.PCmdBufLabels) > 0 {
		sl_pCmdBufLabels := make([]_vkDebugUtilsLabelEXT, len(s.PCmdBufLabels))
		for i, v := range s.PCmdBufLabels {
			sl_pCmdBufLabels[i] = *(v.Vulkanize())
		}
		psl_pCmdBufLabels = &sl_pCmdBufLabels[0]
	}

	var psl_pObjects *_vkDebugUtilsObjectNameInfoEXT
	if len(s.PObjects) > 0 {
		sl_pObjects := make([]_vkDebugUtilsObjectNameInfoEXT, len(s.PObjects))
		for i, v := range s.PObjects {
			sl_pObjects[i] = *(v.Vulkanize())
		}
		psl_pObjects = &sl_pObjects[0]
	}
	rval := &_vkDebugUtilsMessengerCallbackDataEXT{
		sType:            STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                              /*cb*/
		flags:            (DebugUtilsMessengerCallbackDataFlagsEXT)(s.Flags),     /*cb*/
		pMessageIdName:   sys_stringToBytePointer(s.PMessageIdName),              /*c rem*/
		messageIdNumber:  (int32)(s.MessageIdNumber),                             /*cb*/
		pMessage:         sys_stringToBytePointer(s.PMessage),                    /*c rem*/
		queueLabelCount:  uint32(len(s.PQueueLabels)),                            /*c6-a*/
		pQueueLabels:     psl_pQueueLabels,                                       /*c rem*/
		cmdBufLabelCount: uint32(len(s.PCmdBufLabels)),                           /*c6-a*/
		pCmdBufLabels:    psl_pCmdBufLabels,                                      /*c rem*/
		objectCount:      uint32(len(s.PObjects)),                                /*c6-a*/
		pObjects:         psl_pObjects,                                           /*c rem*/
	}
	return rval
}

// DebugUtilsMessengerCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateInfoEXT.html
type DebugUtilsMessengerCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT
	PNext           unsafe.Pointer
	Flags           DebugUtilsMessengerCreateFlagsEXT
	MessageSeverity DebugUtilsMessageSeverityFlagsEXT
	MessageType     DebugUtilsMessageTypeFlagsEXT
	PfnUserCallback PFN_vkDebugUtilsMessengerCallbackEXT
	PUserData       unsafe.Pointer
}

type _vkDebugUtilsMessengerCreateInfoEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           DebugUtilsMessengerCreateFlagsEXT
	messageSeverity DebugUtilsMessageSeverityFlagsEXT
	messageType     DebugUtilsMessageTypeFlagsEXT
	pfnUserCallback PFN_vkDebugUtilsMessengerCallbackEXT
	pUserData       unsafe.Pointer
}

func (s *_vkDebugUtilsMessengerCreateInfoEXT) Goify() *DebugUtilsMessengerCreateInfoEXT {
	rval := &DebugUtilsMessengerCreateInfoEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		Flags:           (DebugUtilsMessengerCreateFlagsEXT)(s.flags),
		MessageSeverity: (DebugUtilsMessageSeverityFlagsEXT)(s.messageSeverity),
		MessageType:     (DebugUtilsMessageTypeFlagsEXT)(s.messageType),
		PfnUserCallback: (PFN_vkDebugUtilsMessengerCallbackEXT)(s.pfnUserCallback),
		PUserData:       (unsafe.Pointer)(s.pUserData),
	}
	return rval
}
func (s *DebugUtilsMessengerCreateInfoEXT) Vulkanize() *_vkDebugUtilsMessengerCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDebugUtilsMessengerCreateInfoEXT{
		sType:           STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,      /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                 /*cb*/
		flags:           (DebugUtilsMessengerCreateFlagsEXT)(s.Flags),              /*cb*/
		messageSeverity: (DebugUtilsMessageSeverityFlagsEXT)(s.MessageSeverity),    /*cb*/
		messageType:     (DebugUtilsMessageTypeFlagsEXT)(s.MessageType),            /*cb*/
		pfnUserCallback: (PFN_vkDebugUtilsMessengerCallbackEXT)(s.PfnUserCallback), /*cb*/
		pUserData:       (unsafe.Pointer)(s.PUserData),                             /*cb*/
	}
	return rval
}

// DebugUtilsObjectNameInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectNameInfoEXT.html
type DebugUtilsObjectNameInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT
	PNext        unsafe.Pointer
	ObjectType   ObjectType
	ObjectHandle uint64
	PObjectName  string
}

type _vkDebugUtilsObjectNameInfoEXT struct {
	sType        StructureType
	pNext        unsafe.Pointer
	objectType   ObjectType
	objectHandle uint64
	pObjectName  *byte
}

func (s *_vkDebugUtilsObjectNameInfoEXT) Goify() *DebugUtilsObjectNameInfoEXT {
	rval := &DebugUtilsObjectNameInfoEXT{
		PNext:        (unsafe.Pointer)(s.pNext),
		ObjectType:   (ObjectType)(s.objectType),
		ObjectHandle: (uint64)(s.objectHandle),
		// Unexpected pointer member pObjectName in returned struct
	}
	return rval
}
func (s *DebugUtilsObjectNameInfoEXT) Vulkanize() *_vkDebugUtilsObjectNameInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDebugUtilsObjectNameInfoEXT{
		sType:        STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                       /*cb*/
		objectType:   (ObjectType)(s.ObjectType),                      /*cb*/
		objectHandle: (uint64)(s.ObjectHandle),                        /*cb*/
		pObjectName:  sys_stringToBytePointer(s.PObjectName),          /*c rem*/
	}
	return rval
}

// DebugUtilsObjectTagInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectTagInfoEXT.html
type DebugUtilsObjectTagInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT
	PNext        unsafe.Pointer
	ObjectType   ObjectType
	ObjectHandle uint64
	TagName      uint64
	TagSize      uintptr
	PTag         unsafe.Pointer
}

type _vkDebugUtilsObjectTagInfoEXT struct {
	sType        StructureType
	pNext        unsafe.Pointer
	objectType   ObjectType
	objectHandle uint64
	tagName      uint64
	tagSize      uintptr
	pTag         unsafe.Pointer
}

func (s *_vkDebugUtilsObjectTagInfoEXT) Goify() *DebugUtilsObjectTagInfoEXT {
	rval := &DebugUtilsObjectTagInfoEXT{
		PNext:        (unsafe.Pointer)(s.pNext),
		ObjectType:   (ObjectType)(s.objectType),
		ObjectHandle: (uint64)(s.objectHandle),
		TagName:      (uint64)(s.tagName),
		TagSize:      (uintptr)(s.tagSize),
		PTag:         (unsafe.Pointer)(s.pTag),
	}
	return rval
}
func (s *DebugUtilsObjectTagInfoEXT) Vulkanize() *_vkDebugUtilsObjectTagInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDebugUtilsObjectTagInfoEXT{
		sType:        STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                      /*cb*/
		objectType:   (ObjectType)(s.ObjectType),                     /*cb*/
		objectHandle: (uint64)(s.ObjectHandle),                       /*cb*/
		tagName:      (uint64)(s.TagName),                            /*cb*/
		tagSize:      (uintptr)(s.TagSize),                           /*cb*/
		pTag:         (unsafe.Pointer)(s.PTag),                       /*cb*/
	}
	return rval
}

// DecompressMemoryRegionNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDecompressMemoryRegionNV.html
type DecompressMemoryRegionNV struct {
	SrcAddress DeviceAddress
	DstAddress DeviceAddress
	//  Specified in bytes;
	CompressedSize DeviceSize
	//  Specified in bytes;
	DecompressedSize    DeviceSize
	DecompressionMethod MemoryDecompressionMethodFlagsNV
}

type _vkDecompressMemoryRegionNV = DecompressMemoryRegionNV

func (s *_vkDecompressMemoryRegionNV) Goify() *DecompressMemoryRegionNV {
	rval := (*DecompressMemoryRegionNV)(s)
	return rval
}
func (s *DecompressMemoryRegionNV) Vulkanize() *_vkDecompressMemoryRegionNV {
	if s == nil {
		return nil
	}
	rval := (*_vkDecompressMemoryRegionNV)(s)
	return rval
}

// DedicatedAllocationBufferCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationBufferCreateInfoNV.html
type DedicatedAllocationBufferCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV
	PNext unsafe.Pointer
	//  Whether this buffer uses a dedicated allocation;
	DedicatedAllocation bool
}

type _vkDedicatedAllocationBufferCreateInfoNV struct {
	sType               StructureType
	pNext               unsafe.Pointer
	dedicatedAllocation Bool32
}

func (s *_vkDedicatedAllocationBufferCreateInfoNV) Goify() *DedicatedAllocationBufferCreateInfoNV {
	rval := &DedicatedAllocationBufferCreateInfoNV{
		PNext:               (unsafe.Pointer)(s.pNext),
		DedicatedAllocation: translatePublic_Bool32(s.dedicatedAllocation), /*default*/
	}
	return rval
}
func (s *DedicatedAllocationBufferCreateInfoNV) Vulkanize() *_vkDedicatedAllocationBufferCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkDedicatedAllocationBufferCreateInfoNV{
		sType:               STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                 /*cb*/
		dedicatedAllocation: translateInternal_Bool32(s.DedicatedAllocation),           /*default*/
	}
	return rval
}

// DedicatedAllocationImageCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationImageCreateInfoNV.html
type DedicatedAllocationImageCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV
	PNext unsafe.Pointer
	//  Whether this image uses a dedicated allocation;
	DedicatedAllocation bool
}

type _vkDedicatedAllocationImageCreateInfoNV struct {
	sType               StructureType
	pNext               unsafe.Pointer
	dedicatedAllocation Bool32
}

func (s *_vkDedicatedAllocationImageCreateInfoNV) Goify() *DedicatedAllocationImageCreateInfoNV {
	rval := &DedicatedAllocationImageCreateInfoNV{
		PNext:               (unsafe.Pointer)(s.pNext),
		DedicatedAllocation: translatePublic_Bool32(s.dedicatedAllocation), /*default*/
	}
	return rval
}
func (s *DedicatedAllocationImageCreateInfoNV) Vulkanize() *_vkDedicatedAllocationImageCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkDedicatedAllocationImageCreateInfoNV{
		sType:               STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                /*cb*/
		dedicatedAllocation: translateInternal_Bool32(s.DedicatedAllocation),          /*default*/
	}
	return rval
}

// DedicatedAllocationMemoryAllocateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html
type DedicatedAllocationMemoryAllocateInfoNV struct {
	// SType = STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV
	PNext unsafe.Pointer
	//  Image that this allocation will be bound to;
	Image Image
	//  Buffer that this allocation will be bound to;
	Buffer Buffer
}

type _vkDedicatedAllocationMemoryAllocateInfoNV struct {
	sType  StructureType
	pNext  unsafe.Pointer
	image  Image
	buffer Buffer
}

func (s *_vkDedicatedAllocationMemoryAllocateInfoNV) Goify() *DedicatedAllocationMemoryAllocateInfoNV {
	rval := &DedicatedAllocationMemoryAllocateInfoNV{
		PNext:  (unsafe.Pointer)(s.pNext),
		Image:  (Image)(s.image),
		Buffer: (Buffer)(s.buffer),
	}
	return rval
}
func (s *DedicatedAllocationMemoryAllocateInfoNV) Vulkanize() *_vkDedicatedAllocationMemoryAllocateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkDedicatedAllocationMemoryAllocateInfoNV{
		sType:  STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                                   /*cb*/
		image:  (Image)(s.Image),                                            /*cb*/
		buffer: (Buffer)(s.Buffer),                                          /*cb*/
	}
	return rval
}

// DependencyInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyInfo.html
type DependencyInfo struct {
	// SType = STRUCTURE_TYPE_DEPENDENCY_INFO
	PNext           unsafe.Pointer
	DependencyFlags DependencyFlags
	// memoryBarrierCount
	PMemoryBarriers []MemoryBarrier2
	// bufferMemoryBarrierCount
	PBufferMemoryBarriers []BufferMemoryBarrier2
	// imageMemoryBarrierCount
	PImageMemoryBarriers []ImageMemoryBarrier2
}

type _vkDependencyInfo struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	dependencyFlags          DependencyFlags
	memoryBarrierCount       uint32
	pMemoryBarriers          *_vkMemoryBarrier2
	bufferMemoryBarrierCount uint32
	pBufferMemoryBarriers    *_vkBufferMemoryBarrier2
	imageMemoryBarrierCount  uint32
	pImageMemoryBarriers     *_vkImageMemoryBarrier2
}

func (s *_vkDependencyInfo) Goify() *DependencyInfo {
	rval := &DependencyInfo{
		PNext:           (unsafe.Pointer)(s.pNext),
		DependencyFlags: (DependencyFlags)(s.dependencyFlags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pMemoryBarriers in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pBufferMemoryBarriers in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pImageMemoryBarriers in returned struct
	}
	return rval
}
func (s *DependencyInfo) Vulkanize() *_vkDependencyInfo {
	if s == nil {
		return nil
	}

	var psl_pMemoryBarriers *_vkMemoryBarrier2
	if len(s.PMemoryBarriers) > 0 {
		sl_pMemoryBarriers := make([]_vkMemoryBarrier2, len(s.PMemoryBarriers))
		for i, v := range s.PMemoryBarriers {
			sl_pMemoryBarriers[i] = *(v.Vulkanize())
		}
		psl_pMemoryBarriers = &sl_pMemoryBarriers[0]
	}

	var psl_pBufferMemoryBarriers *_vkBufferMemoryBarrier2
	if len(s.PBufferMemoryBarriers) > 0 {
		sl_pBufferMemoryBarriers := make([]_vkBufferMemoryBarrier2, len(s.PBufferMemoryBarriers))
		for i, v := range s.PBufferMemoryBarriers {
			sl_pBufferMemoryBarriers[i] = *(v.Vulkanize())
		}
		psl_pBufferMemoryBarriers = &sl_pBufferMemoryBarriers[0]
	}

	var psl_pImageMemoryBarriers *_vkImageMemoryBarrier2
	if len(s.PImageMemoryBarriers) > 0 {
		sl_pImageMemoryBarriers := make([]_vkImageMemoryBarrier2, len(s.PImageMemoryBarriers))
		for i, v := range s.PImageMemoryBarriers {
			sl_pImageMemoryBarriers[i] = *(v.Vulkanize())
		}
		psl_pImageMemoryBarriers = &sl_pImageMemoryBarriers[0]
	}
	rval := &_vkDependencyInfo{
		sType:                    STRUCTURE_TYPE_DEPENDENCY_INFO,       /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),            /*cb*/
		dependencyFlags:          (DependencyFlags)(s.DependencyFlags), /*cb*/
		memoryBarrierCount:       uint32(len(s.PMemoryBarriers)),       /*c6-a*/
		pMemoryBarriers:          psl_pMemoryBarriers,                  /*c rem*/
		bufferMemoryBarrierCount: uint32(len(s.PBufferMemoryBarriers)), /*c6-a*/
		pBufferMemoryBarriers:    psl_pBufferMemoryBarriers,            /*c rem*/
		imageMemoryBarrierCount:  uint32(len(s.PImageMemoryBarriers)),  /*c6-a*/
		pImageMemoryBarriers:     psl_pImageMemoryBarriers,             /*c rem*/
	}
	return rval
}

// DependencyInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyInfoKHR.html
type DependencyInfoKHR struct {
}

type _vkDependencyInfoKHR = DependencyInfoKHR

func (s *_vkDependencyInfoKHR) Goify() *DependencyInfoKHR {
	rval := (*DependencyInfoKHR)(s)
	return rval
}
func (s *DependencyInfoKHR) Vulkanize() *_vkDependencyInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDependencyInfoKHR)(s)
	return rval
}

// DepthBiasInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDepthBiasInfoEXT.html
type DepthBiasInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT
	PNext                   unsafe.Pointer
	DepthBiasConstantFactor float32
	DepthBiasClamp          float32
	DepthBiasSlopeFactor    float32
}

type _vkDepthBiasInfoEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	depthBiasConstantFactor float32
	depthBiasClamp          float32
	depthBiasSlopeFactor    float32
}

func (s *_vkDepthBiasInfoEXT) Goify() *DepthBiasInfoEXT {
	rval := &DepthBiasInfoEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		DepthBiasConstantFactor: (float32)(s.depthBiasConstantFactor),
		DepthBiasClamp:          (float32)(s.depthBiasClamp),
		DepthBiasSlopeFactor:    (float32)(s.depthBiasSlopeFactor),
	}
	return rval
}
func (s *DepthBiasInfoEXT) Vulkanize() *_vkDepthBiasInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDepthBiasInfoEXT{
		sType:                   STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT,   /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),            /*cb*/
		depthBiasConstantFactor: (float32)(s.DepthBiasConstantFactor), /*cb*/
		depthBiasClamp:          (float32)(s.DepthBiasClamp),          /*cb*/
		depthBiasSlopeFactor:    (float32)(s.DepthBiasSlopeFactor),    /*cb*/
	}
	return rval
}

// DepthBiasRepresentationInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDepthBiasRepresentationInfoEXT.html
type DepthBiasRepresentationInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT
	PNext                   unsafe.Pointer
	DepthBiasRepresentation DepthBiasRepresentationEXT
	DepthBiasExact          bool
}

type _vkDepthBiasRepresentationInfoEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	depthBiasRepresentation DepthBiasRepresentationEXT
	depthBiasExact          Bool32
}

func (s *_vkDepthBiasRepresentationInfoEXT) Goify() *DepthBiasRepresentationInfoEXT {
	rval := &DepthBiasRepresentationInfoEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		DepthBiasRepresentation: (DepthBiasRepresentationEXT)(s.depthBiasRepresentation),
		DepthBiasExact:          translatePublic_Bool32(s.depthBiasExact), /*default*/
	}
	return rval
}
func (s *DepthBiasRepresentationInfoEXT) Vulkanize() *_vkDepthBiasRepresentationInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDepthBiasRepresentationInfoEXT{
		sType:                   STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT,       /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                               /*cb*/
		depthBiasRepresentation: (DepthBiasRepresentationEXT)(s.DepthBiasRepresentation), /*cb*/
		depthBiasExact:          translateInternal_Bool32(s.DepthBiasExact),              /*default*/
	}
	return rval
}

// DescriptorAddressInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorAddressInfoEXT.html
type DescriptorAddressInfoEXT struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT
	PNext   unsafe.Pointer
	Address DeviceAddress
	Rang    DeviceSize
	Format  Format
}

type _vkDescriptorAddressInfoEXT struct {
	sType   StructureType
	pNext   unsafe.Pointer
	address DeviceAddress
	rang    DeviceSize
	format  Format
}

func (s *_vkDescriptorAddressInfoEXT) Goify() *DescriptorAddressInfoEXT {
	rval := &DescriptorAddressInfoEXT{
		PNext:   (unsafe.Pointer)(s.pNext),
		Address: (DeviceAddress)(s.address),
		Rang:    (DeviceSize)(s.rang),
		Format:  (Format)(s.format),
	}
	return rval
}
func (s *DescriptorAddressInfoEXT) Vulkanize() *_vkDescriptorAddressInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDescriptorAddressInfoEXT{
		sType:   STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT, /*c1*/
		pNext:   (unsafe.Pointer)(s.PNext),                  /*cb*/
		address: (DeviceAddress)(s.Address),                 /*cb*/
		rang:    (DeviceSize)(s.Rang),                       /*cb*/
		format:  (Format)(s.Format),                         /*cb*/
	}
	return rval
}

// DescriptorBufferBindingInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferBindingInfoEXT.html
type DescriptorBufferBindingInfoEXT struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT
	PNext   unsafe.Pointer
	Address DeviceAddress
	Usage   BufferUsageFlags
}

type _vkDescriptorBufferBindingInfoEXT struct {
	sType   StructureType
	pNext   unsafe.Pointer
	address DeviceAddress
	usage   BufferUsageFlags
}

func (s *_vkDescriptorBufferBindingInfoEXT) Goify() *DescriptorBufferBindingInfoEXT {
	rval := &DescriptorBufferBindingInfoEXT{
		PNext:   (unsafe.Pointer)(s.pNext),
		Address: (DeviceAddress)(s.address),
		Usage:   (BufferUsageFlags)(s.usage),
	}
	return rval
}
func (s *DescriptorBufferBindingInfoEXT) Vulkanize() *_vkDescriptorBufferBindingInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDescriptorBufferBindingInfoEXT{
		sType:   STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT, /*c1*/
		pNext:   (unsafe.Pointer)(s.PNext),                         /*cb*/
		address: (DeviceAddress)(s.Address),                        /*cb*/
		usage:   (BufferUsageFlags)(s.Usage),                       /*cb*/
	}
	return rval
}

// DescriptorBufferBindingPushDescriptorBufferHandleEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.html
type DescriptorBufferBindingPushDescriptorBufferHandleEXT struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT
	PNext  unsafe.Pointer
	Buffer Buffer
}

type _vkDescriptorBufferBindingPushDescriptorBufferHandleEXT struct {
	sType  StructureType
	pNext  unsafe.Pointer
	buffer Buffer
}

func (s *_vkDescriptorBufferBindingPushDescriptorBufferHandleEXT) Goify() *DescriptorBufferBindingPushDescriptorBufferHandleEXT {
	rval := &DescriptorBufferBindingPushDescriptorBufferHandleEXT{
		PNext:  (unsafe.Pointer)(s.pNext),
		Buffer: (Buffer)(s.buffer),
	}
	return rval
}
func (s *DescriptorBufferBindingPushDescriptorBufferHandleEXT) Vulkanize() *_vkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDescriptorBufferBindingPushDescriptorBufferHandleEXT{
		sType:  STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                                                  /*cb*/
		buffer: (Buffer)(s.Buffer),                                                         /*cb*/
	}
	return rval
}

// DescriptorBufferInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferInfo.html
type DescriptorBufferInfo struct {
	//  Buffer used for this descriptor slot.;
	Buffer Buffer
	//  Base offset from buffer start in bytes to update in the descriptor set.;
	Offset DeviceSize
	//  Size in bytes of the buffer resource for this descriptor update.;
	Rang DeviceSize
}

type _vkDescriptorBufferInfo = DescriptorBufferInfo

func (s *_vkDescriptorBufferInfo) Goify() *DescriptorBufferInfo {
	rval := (*DescriptorBufferInfo)(s)
	return rval
}
func (s *DescriptorBufferInfo) Vulkanize() *_vkDescriptorBufferInfo {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorBufferInfo)(s)
	return rval
}

// DescriptorGetInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorGetInfoEXT.html
type DescriptorGetInfoEXT struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT
	PNext unsafe.Pointer
	Typ   DescriptorType
	Data  DescriptorDataEXT
}

type _vkDescriptorGetInfoEXT struct {
	sType StructureType
	pNext unsafe.Pointer
	typ   DescriptorType
	data  _vkDescriptorDataEXT
}

func (s *_vkDescriptorGetInfoEXT) Goify() *DescriptorGetInfoEXT {
	rval := &DescriptorGetInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		Typ:   (DescriptorType)(s.typ),
		// Can't Goify union member data
	}
	return rval
}
func (s *DescriptorGetInfoEXT) Vulkanize() *_vkDescriptorGetInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDescriptorGetInfoEXT{
		sType: STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),              /*cb*/
		typ:   (DescriptorType)(s.Typ),                /*cb*/
		data:  *s.Data.Vulkanize(),                    /*c union*/
	}
	return rval
}

// DescriptorImageInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorImageInfo.html
type DescriptorImageInfo struct {
	//  Sampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise.;
	Sampler Sampler
	//  Image view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise.;
	ImageView ImageView
	//  Layout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE).;
	ImageLayout ImageLayout
}

type _vkDescriptorImageInfo = DescriptorImageInfo

func (s *_vkDescriptorImageInfo) Goify() *DescriptorImageInfo {
	rval := (*DescriptorImageInfo)(s)
	return rval
}
func (s *DescriptorImageInfo) Vulkanize() *_vkDescriptorImageInfo {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorImageInfo)(s)
	return rval
}

// DescriptorPoolCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolCreateInfo.html
type DescriptorPoolCreateInfo struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
	PNext   unsafe.Pointer
	Flags   DescriptorPoolCreateFlags
	MaxSets uint32
	// poolSizeCount
	PPoolSizes []DescriptorPoolSize
}

type _vkDescriptorPoolCreateInfo struct {
	sType         StructureType
	pNext         unsafe.Pointer
	flags         DescriptorPoolCreateFlags
	maxSets       uint32
	poolSizeCount uint32
	pPoolSizes    *_vkDescriptorPoolSize
}

func (s *_vkDescriptorPoolCreateInfo) Goify() *DescriptorPoolCreateInfo {
	rval := &DescriptorPoolCreateInfo{
		PNext:   (unsafe.Pointer)(s.pNext),
		Flags:   (DescriptorPoolCreateFlags)(s.flags),
		MaxSets: (uint32)(s.maxSets),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPoolSizes in returned struct
	}
	return rval
}
func (s *DescriptorPoolCreateInfo) Vulkanize() *_vkDescriptorPoolCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pPoolSizes *_vkDescriptorPoolSize
	if len(s.PPoolSizes) > 0 {
		psl_pPoolSizes = &s.PPoolSizes[0]
	}
	rval := &_vkDescriptorPoolCreateInfo{
		sType:         STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                  /*cb*/
		flags:         (DescriptorPoolCreateFlags)(s.Flags),       /*cb*/
		maxSets:       (uint32)(s.MaxSets),                        /*cb*/
		poolSizeCount: uint32(len(s.PPoolSizes)),                  /*c6-a*/
		pPoolSizes:    psl_pPoolSizes,                             /*c rem*/
	}
	return rval
}

// DescriptorPoolInlineUniformBlockCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolInlineUniformBlockCreateInfoEXT.html
type DescriptorPoolInlineUniformBlockCreateInfoEXT struct {
}

type _vkDescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfoEXT

func (s *_vkDescriptorPoolInlineUniformBlockCreateInfoEXT) Goify() *DescriptorPoolInlineUniformBlockCreateInfoEXT {
	rval := (*DescriptorPoolInlineUniformBlockCreateInfoEXT)(s)
	return rval
}
func (s *DescriptorPoolInlineUniformBlockCreateInfoEXT) Vulkanize() *_vkDescriptorPoolInlineUniformBlockCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorPoolInlineUniformBlockCreateInfoEXT)(s)
	return rval
}

// DescriptorPoolSize: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolSize.html
type DescriptorPoolSize struct {
	Typ             DescriptorType
	DescriptorCount uint32
}

type _vkDescriptorPoolSize = DescriptorPoolSize

func (s *_vkDescriptorPoolSize) Goify() *DescriptorPoolSize {
	rval := (*DescriptorPoolSize)(s)
	return rval
}
func (s *DescriptorPoolSize) Vulkanize() *_vkDescriptorPoolSize {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorPoolSize)(s)
	return rval
}

// DescriptorSetAllocateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetAllocateInfo.html
type DescriptorSetAllocateInfo struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
	PNext          unsafe.Pointer
	DescriptorPool DescriptorPool
	// descriptorSetCount
	PSetLayouts []DescriptorSetLayout
}

type _vkDescriptorSetAllocateInfo struct {
	sType              StructureType
	pNext              unsafe.Pointer
	descriptorPool     DescriptorPool
	descriptorSetCount uint32
	pSetLayouts        *DescriptorSetLayout
}

func (s *_vkDescriptorSetAllocateInfo) Goify() *DescriptorSetAllocateInfo {
	rval := &DescriptorSetAllocateInfo{
		PNext:          (unsafe.Pointer)(s.pNext),
		DescriptorPool: (DescriptorPool)(s.descriptorPool),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSetLayouts in returned struct
	}
	return rval
}
func (s *DescriptorSetAllocateInfo) Vulkanize() *_vkDescriptorSetAllocateInfo {
	if s == nil {
		return nil
	}

	var psl_pSetLayouts *DescriptorSetLayout
	if len(s.PSetLayouts) > 0 {
		psl_pSetLayouts = &s.PSetLayouts[0]
	}
	rval := &_vkDescriptorSetAllocateInfo{
		sType:              STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                   /*cb*/
		descriptorPool:     (DescriptorPool)(s.DescriptorPool),          /*cb*/
		descriptorSetCount: uint32(len(s.PSetLayouts)),                  /*c6-a*/
		pSetLayouts:        psl_pSetLayouts,                             /*c rem*/
	}
	return rval
}

// DescriptorSetBindingReferenceVALVE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetBindingReferenceVALVE.html
type DescriptorSetBindingReferenceVALVE struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE
	PNext               unsafe.Pointer
	DescriptorSetLayout DescriptorSetLayout
	Binding             uint32
}

type _vkDescriptorSetBindingReferenceVALVE struct {
	sType               StructureType
	pNext               unsafe.Pointer
	descriptorSetLayout DescriptorSetLayout
	binding             uint32
}

func (s *_vkDescriptorSetBindingReferenceVALVE) Goify() *DescriptorSetBindingReferenceVALVE {
	rval := &DescriptorSetBindingReferenceVALVE{
		PNext:               (unsafe.Pointer)(s.pNext),
		DescriptorSetLayout: (DescriptorSetLayout)(s.descriptorSetLayout),
		Binding:             (uint32)(s.binding),
	}
	return rval
}
func (s *DescriptorSetBindingReferenceVALVE) Vulkanize() *_vkDescriptorSetBindingReferenceVALVE {
	if s == nil {
		return nil
	}
	rval := &_vkDescriptorSetBindingReferenceVALVE{
		sType:               STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                             /*cb*/
		descriptorSetLayout: (DescriptorSetLayout)(s.DescriptorSetLayout),          /*cb*/
		binding:             (uint32)(s.Binding),                                   /*cb*/
	}
	return rval
}

// DescriptorSetLayoutBinding: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBinding.html
type DescriptorSetLayoutBinding struct {
	//  Binding number for this entry; descriptorCount references an array field in the XML, but that field might be null and then descriptor count has a different meaning. See the man pages/spec.
	Binding uint32
	//  Type of the descriptors in this binding; descriptorCount references an array field in the XML, but that field might be null and then descriptor count has a different meaning. See the man pages/spec.
	DescriptorType DescriptorType
	//  Number of descriptors in this binding; descriptorCount references an array field in the XML, but that field might be null and then descriptor count has a different meaning. See the man pages/spec.
	DescriptorCount uint32 // Forced include via exceptions.json
	//  Shader stages this binding is visible to; descriptorCount references an array field in the XML, but that field might be null and then descriptor count has a different meaning. See the man pages/spec.
	StageFlags ShaderStageFlags
	//  Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements); descriptorCount references an array field in the XML, but that field might be null and then descriptor count has a different meaning. See the man pages/spec.
	PImmutableSamplers []Sampler
}

type _vkDescriptorSetLayoutBinding struct {
	binding            uint32
	descriptorType     DescriptorType
	descriptorCount    uint32
	stageFlags         ShaderStageFlags
	pImmutableSamplers *Sampler
}

func (s *_vkDescriptorSetLayoutBinding) Goify() *DescriptorSetLayoutBinding {
	rval := &DescriptorSetLayoutBinding{
		Binding:        (uint32)(s.binding),
		DescriptorType: (DescriptorType)(s.descriptorType),
		// Unexpected 'isLenForAnotherMember'!
		StageFlags: (ShaderStageFlags)(s.stageFlags),
		// Unexpected pointer member pImmutableSamplers in returned struct
	}
	return rval
}
func (s *DescriptorSetLayoutBinding) Vulkanize() *_vkDescriptorSetLayoutBinding {
	if s == nil {
		return nil
	}

	var psl_pImmutableSamplers *Sampler
	if len(s.PImmutableSamplers) > 0 {
		psl_pImmutableSamplers = &s.PImmutableSamplers[0]
	}
	rval := &_vkDescriptorSetLayoutBinding{
		binding:            (uint32)(s.Binding),                /*cb*/
		descriptorType:     (DescriptorType)(s.DescriptorType), /*cb*/
		descriptorCount:    s.DescriptorCount,                  /*c6-force*/
		stageFlags:         (ShaderStageFlags)(s.StageFlags),   /*cb*/
		pImmutableSamplers: psl_pImmutableSamplers,             /*c rem*/
	}
	return rval
}

// DescriptorSetLayoutBindingFlagsCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html
type DescriptorSetLayoutBindingFlagsCreateInfo struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO
	PNext unsafe.Pointer
	// bindingCount
	PBindingFlags []DescriptorBindingFlags
}

type _vkDescriptorSetLayoutBindingFlagsCreateInfo struct {
	sType         StructureType
	pNext         unsafe.Pointer
	bindingCount  uint32
	pBindingFlags *DescriptorBindingFlags
}

func (s *_vkDescriptorSetLayoutBindingFlagsCreateInfo) Goify() *DescriptorSetLayoutBindingFlagsCreateInfo {
	rval := &DescriptorSetLayoutBindingFlagsCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pBindingFlags in returned struct
	}
	return rval
}
func (s *DescriptorSetLayoutBindingFlagsCreateInfo) Vulkanize() *_vkDescriptorSetLayoutBindingFlagsCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pBindingFlags *DescriptorBindingFlags
	if len(s.PBindingFlags) > 0 {
		psl_pBindingFlags = &s.PBindingFlags[0]
	}
	rval := &_vkDescriptorSetLayoutBindingFlagsCreateInfo{
		sType:         STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                      /*cb*/
		bindingCount:  uint32(len(s.PBindingFlags)),                                   /*c6-a*/
		pBindingFlags: psl_pBindingFlags,                                              /*c rem*/
	}
	return rval
}

// DescriptorSetLayoutBindingFlagsCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfoEXT.html
type DescriptorSetLayoutBindingFlagsCreateInfoEXT struct {
}

type _vkDescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfoEXT

func (s *_vkDescriptorSetLayoutBindingFlagsCreateInfoEXT) Goify() *DescriptorSetLayoutBindingFlagsCreateInfoEXT {
	rval := (*DescriptorSetLayoutBindingFlagsCreateInfoEXT)(s)
	return rval
}
func (s *DescriptorSetLayoutBindingFlagsCreateInfoEXT) Vulkanize() *_vkDescriptorSetLayoutBindingFlagsCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorSetLayoutBindingFlagsCreateInfoEXT)(s)
	return rval
}

// DescriptorSetLayoutCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutCreateInfo.html
type DescriptorSetLayoutCreateInfo struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
	PNext unsafe.Pointer
	Flags DescriptorSetLayoutCreateFlags
	//  Number of bindings in the descriptor set layout;
	// bindingCount
	//  Array of descriptor set layout bindings;
	PBindings []DescriptorSetLayoutBinding
}

type _vkDescriptorSetLayoutCreateInfo struct {
	sType        StructureType
	pNext        unsafe.Pointer
	flags        DescriptorSetLayoutCreateFlags
	bindingCount uint32
	pBindings    *_vkDescriptorSetLayoutBinding
}

func (s *_vkDescriptorSetLayoutCreateInfo) Goify() *DescriptorSetLayoutCreateInfo {
	rval := &DescriptorSetLayoutCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (DescriptorSetLayoutCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pBindings in returned struct
	}
	return rval
}
func (s *DescriptorSetLayoutCreateInfo) Vulkanize() *_vkDescriptorSetLayoutCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pBindings *_vkDescriptorSetLayoutBinding
	if len(s.PBindings) > 0 {
		sl_pBindings := make([]_vkDescriptorSetLayoutBinding, len(s.PBindings))
		for i, v := range s.PBindings {
			sl_pBindings[i] = *(v.Vulkanize())
		}
		psl_pBindings = &sl_pBindings[0]
	}
	rval := &_vkDescriptorSetLayoutCreateInfo{
		sType:        STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                        /*cb*/
		flags:        (DescriptorSetLayoutCreateFlags)(s.Flags),        /*cb*/
		bindingCount: uint32(len(s.PBindings)),                         /*c6-a*/
		pBindings:    psl_pBindings,                                    /*c rem*/
	}
	return rval
}

// DescriptorSetLayoutHostMappingInfoVALVE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutHostMappingInfoVALVE.html
type DescriptorSetLayoutHostMappingInfoVALVE struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE
	PNext            unsafe.Pointer
	DescriptorOffset uintptr
	DescriptorSize   uint32
}

type _vkDescriptorSetLayoutHostMappingInfoVALVE struct {
	sType            StructureType
	pNext            unsafe.Pointer
	descriptorOffset uintptr
	descriptorSize   uint32
}

func (s *_vkDescriptorSetLayoutHostMappingInfoVALVE) Goify() *DescriptorSetLayoutHostMappingInfoVALVE {
	rval := &DescriptorSetLayoutHostMappingInfoVALVE{
		PNext:            (unsafe.Pointer)(s.pNext),
		DescriptorOffset: (uintptr)(s.descriptorOffset),
		DescriptorSize:   (uint32)(s.descriptorSize),
	}
	return rval
}
func (s *DescriptorSetLayoutHostMappingInfoVALVE) Vulkanize() *_vkDescriptorSetLayoutHostMappingInfoVALVE {
	if s == nil {
		return nil
	}
	rval := &_vkDescriptorSetLayoutHostMappingInfoVALVE{
		sType:            STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                    /*cb*/
		descriptorOffset: (uintptr)(s.DescriptorOffset),                                /*cb*/
		descriptorSize:   (uint32)(s.DescriptorSize),                                   /*cb*/
	}
	return rval
}

// DescriptorSetLayoutSupport: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutSupport.html
type DescriptorSetLayoutSupport struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT
	PNext     unsafe.Pointer
	Supported bool
}

// WARNING - struct DescriptorSetLayoutSupport is returned only, which is not yet handled in the binding
type _vkDescriptorSetLayoutSupport struct {
	sType     StructureType
	pNext     unsafe.Pointer
	supported Bool32
}

func (s *_vkDescriptorSetLayoutSupport) Goify() *DescriptorSetLayoutSupport {
	rval := &DescriptorSetLayoutSupport{
		PNext:     (unsafe.Pointer)(s.pNext),
		Supported: translatePublic_Bool32(s.supported), /*default*/
	}
	return rval
}
func (s *DescriptorSetLayoutSupport) Vulkanize() *_vkDescriptorSetLayoutSupport {
	if s == nil {
		return nil
	}
	rval := &_vkDescriptorSetLayoutSupport{
		sType:     STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                    /*cb*/
		supported: translateInternal_Bool32(s.Supported),        /*default*/
	}
	return rval
}

// DescriptorSetLayoutSupportKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutSupportKHR.html
type DescriptorSetLayoutSupportKHR struct {
}

type _vkDescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupportKHR

func (s *_vkDescriptorSetLayoutSupportKHR) Goify() *DescriptorSetLayoutSupportKHR {
	rval := (*DescriptorSetLayoutSupportKHR)(s)
	return rval
}
func (s *DescriptorSetLayoutSupportKHR) Vulkanize() *_vkDescriptorSetLayoutSupportKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorSetLayoutSupportKHR)(s)
	return rval
}

// DescriptorSetVariableDescriptorCountAllocateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html
type DescriptorSetVariableDescriptorCountAllocateInfo struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO
	PNext unsafe.Pointer
	// descriptorSetCount
	PDescriptorCounts []uint32
}

type _vkDescriptorSetVariableDescriptorCountAllocateInfo struct {
	sType              StructureType
	pNext              unsafe.Pointer
	descriptorSetCount uint32
	pDescriptorCounts  *uint32
}

func (s *_vkDescriptorSetVariableDescriptorCountAllocateInfo) Goify() *DescriptorSetVariableDescriptorCountAllocateInfo {
	rval := &DescriptorSetVariableDescriptorCountAllocateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDescriptorCounts in returned struct
	}
	return rval
}
func (s *DescriptorSetVariableDescriptorCountAllocateInfo) Vulkanize() *_vkDescriptorSetVariableDescriptorCountAllocateInfo {
	if s == nil {
		return nil
	}

	var psl_pDescriptorCounts *uint32
	if len(s.PDescriptorCounts) > 0 {
		psl_pDescriptorCounts = &s.PDescriptorCounts[0]
	}
	rval := &_vkDescriptorSetVariableDescriptorCountAllocateInfo{
		sType:              STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                             /*cb*/
		descriptorSetCount: uint32(len(s.PDescriptorCounts)),                                      /*c6-a*/
		pDescriptorCounts:  psl_pDescriptorCounts,                                                 /*c rem*/
	}
	return rval
}

// DescriptorSetVariableDescriptorCountAllocateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfoEXT.html
type DescriptorSetVariableDescriptorCountAllocateInfoEXT struct {
}

type _vkDescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfoEXT

func (s *_vkDescriptorSetVariableDescriptorCountAllocateInfoEXT) Goify() *DescriptorSetVariableDescriptorCountAllocateInfoEXT {
	rval := (*DescriptorSetVariableDescriptorCountAllocateInfoEXT)(s)
	return rval
}
func (s *DescriptorSetVariableDescriptorCountAllocateInfoEXT) Vulkanize() *_vkDescriptorSetVariableDescriptorCountAllocateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorSetVariableDescriptorCountAllocateInfoEXT)(s)
	return rval
}

// DescriptorSetVariableDescriptorCountLayoutSupport: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html
type DescriptorSetVariableDescriptorCountLayoutSupport struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT
	PNext                      unsafe.Pointer
	MaxVariableDescriptorCount uint32
}

// WARNING - struct DescriptorSetVariableDescriptorCountLayoutSupport is returned only, which is not yet handled in the binding
type _vkDescriptorSetVariableDescriptorCountLayoutSupport struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	maxVariableDescriptorCount uint32
}

func (s *_vkDescriptorSetVariableDescriptorCountLayoutSupport) Goify() *DescriptorSetVariableDescriptorCountLayoutSupport {
	rval := &DescriptorSetVariableDescriptorCountLayoutSupport{
		PNext:                      (unsafe.Pointer)(s.pNext),
		MaxVariableDescriptorCount: (uint32)(s.maxVariableDescriptorCount),
	}
	return rval
}
func (s *DescriptorSetVariableDescriptorCountLayoutSupport) Vulkanize() *_vkDescriptorSetVariableDescriptorCountLayoutSupport {
	if s == nil {
		return nil
	}
	rval := &_vkDescriptorSetVariableDescriptorCountLayoutSupport{
		sType:                      STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                              /*cb*/
		maxVariableDescriptorCount: (uint32)(s.MaxVariableDescriptorCount),                                 /*cb*/
	}
	return rval
}

// DescriptorSetVariableDescriptorCountLayoutSupportEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupportEXT.html
type DescriptorSetVariableDescriptorCountLayoutSupportEXT struct {
}

type _vkDescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupportEXT

func (s *_vkDescriptorSetVariableDescriptorCountLayoutSupportEXT) Goify() *DescriptorSetVariableDescriptorCountLayoutSupportEXT {
	rval := (*DescriptorSetVariableDescriptorCountLayoutSupportEXT)(s)
	return rval
}
func (s *DescriptorSetVariableDescriptorCountLayoutSupportEXT) Vulkanize() *_vkDescriptorSetVariableDescriptorCountLayoutSupportEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorSetVariableDescriptorCountLayoutSupportEXT)(s)
	return rval
}

// DescriptorUpdateTemplateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateInfo.html
type DescriptorUpdateTemplateCreateInfo struct {
	// SType = STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO
	PNext unsafe.Pointer
	Flags DescriptorUpdateTemplateCreateFlags
	//  Number of descriptor update entries to use for the update template;
	// descriptorUpdateEntryCount
	//  Descriptor update entries for the template;
	PDescriptorUpdateEntries []DescriptorUpdateTemplateEntry
	TemplateType             DescriptorUpdateTemplateType
	DescriptorSetLayout      DescriptorSetLayout
	PipelineBindPoint        PipelineBindPoint
	//  If used for push descriptors, this is the only allowed layout;
	PipelineLayout PipelineLayout
	Set            uint32
}

type _vkDescriptorUpdateTemplateCreateInfo struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	flags                      DescriptorUpdateTemplateCreateFlags
	descriptorUpdateEntryCount uint32
	pDescriptorUpdateEntries   *_vkDescriptorUpdateTemplateEntry
	templateType               DescriptorUpdateTemplateType
	descriptorSetLayout        DescriptorSetLayout
	pipelineBindPoint          PipelineBindPoint
	pipelineLayout             PipelineLayout
	set                        uint32
}

func (s *_vkDescriptorUpdateTemplateCreateInfo) Goify() *DescriptorUpdateTemplateCreateInfo {
	rval := &DescriptorUpdateTemplateCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (DescriptorUpdateTemplateCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDescriptorUpdateEntries in returned struct
		TemplateType:        (DescriptorUpdateTemplateType)(s.templateType),
		DescriptorSetLayout: (DescriptorSetLayout)(s.descriptorSetLayout),
		PipelineBindPoint:   (PipelineBindPoint)(s.pipelineBindPoint),
		PipelineLayout:      (PipelineLayout)(s.pipelineLayout),
		Set:                 (uint32)(s.set),
	}
	return rval
}
func (s *DescriptorUpdateTemplateCreateInfo) Vulkanize() *_vkDescriptorUpdateTemplateCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pDescriptorUpdateEntries *_vkDescriptorUpdateTemplateEntry
	if len(s.PDescriptorUpdateEntries) > 0 {
		psl_pDescriptorUpdateEntries = &s.PDescriptorUpdateEntries[0]
	}
	rval := &_vkDescriptorUpdateTemplateCreateInfo{
		sType:                      STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                             /*cb*/
		flags:                      (DescriptorUpdateTemplateCreateFlags)(s.Flags),        /*cb*/
		descriptorUpdateEntryCount: uint32(len(s.PDescriptorUpdateEntries)),               /*c6-a*/
		pDescriptorUpdateEntries:   psl_pDescriptorUpdateEntries,                          /*c rem*/
		templateType:               (DescriptorUpdateTemplateType)(s.TemplateType),        /*cb*/
		descriptorSetLayout:        (DescriptorSetLayout)(s.DescriptorSetLayout),          /*cb*/
		pipelineBindPoint:          (PipelineBindPoint)(s.PipelineBindPoint),              /*cb*/
		pipelineLayout:             (PipelineLayout)(s.PipelineLayout),                    /*cb*/
		set:                        (uint32)(s.Set),                                       /*cb*/
	}
	return rval
}

// DescriptorUpdateTemplateCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateInfoKHR.html
type DescriptorUpdateTemplateCreateInfoKHR struct {
}

type _vkDescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfoKHR

func (s *_vkDescriptorUpdateTemplateCreateInfoKHR) Goify() *DescriptorUpdateTemplateCreateInfoKHR {
	rval := (*DescriptorUpdateTemplateCreateInfoKHR)(s)
	return rval
}
func (s *DescriptorUpdateTemplateCreateInfoKHR) Vulkanize() *_vkDescriptorUpdateTemplateCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorUpdateTemplateCreateInfoKHR)(s)
	return rval
}

// DescriptorUpdateTemplateEntry: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateEntry.html
type DescriptorUpdateTemplateEntry struct {
	//  Binding within the destination descriptor set to write;
	DstBinding uint32
	//  Array element within the destination binding to write;
	DstArrayElement uint32
	//  Number of descriptors to write;
	DescriptorCount uint32
	//  Descriptor type to write;
	DescriptorType DescriptorType
	//  Offset into pData where the descriptors to update are stored;
	Offset uintptr
	//  Stride between two descriptors in pData when writing more than one descriptor;
	Stride uintptr
}

type _vkDescriptorUpdateTemplateEntry = DescriptorUpdateTemplateEntry

func (s *_vkDescriptorUpdateTemplateEntry) Goify() *DescriptorUpdateTemplateEntry {
	rval := (*DescriptorUpdateTemplateEntry)(s)
	return rval
}
func (s *DescriptorUpdateTemplateEntry) Vulkanize() *_vkDescriptorUpdateTemplateEntry {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorUpdateTemplateEntry)(s)
	return rval
}

// DescriptorUpdateTemplateEntryKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateEntryKHR.html
type DescriptorUpdateTemplateEntryKHR struct {
}

type _vkDescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntryKHR

func (s *_vkDescriptorUpdateTemplateEntryKHR) Goify() *DescriptorUpdateTemplateEntryKHR {
	rval := (*DescriptorUpdateTemplateEntryKHR)(s)
	return rval
}
func (s *DescriptorUpdateTemplateEntryKHR) Vulkanize() *_vkDescriptorUpdateTemplateEntryKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDescriptorUpdateTemplateEntryKHR)(s)
	return rval
}

// DeviceAddressBindingCallbackDataEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddressBindingCallbackDataEXT.html
type DeviceAddressBindingCallbackDataEXT struct {
	// SType = STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT
	PNext       unsafe.Pointer
	Flags       DeviceAddressBindingFlagsEXT
	BaseAddress DeviceAddress
	Size        DeviceSize
	BindingType DeviceAddressBindingTypeEXT
}

type _vkDeviceAddressBindingCallbackDataEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	flags       DeviceAddressBindingFlagsEXT
	baseAddress DeviceAddress
	size        DeviceSize
	bindingType DeviceAddressBindingTypeEXT
}

func (s *_vkDeviceAddressBindingCallbackDataEXT) Goify() *DeviceAddressBindingCallbackDataEXT {
	rval := &DeviceAddressBindingCallbackDataEXT{
		PNext:       (unsafe.Pointer)(s.pNext),
		Flags:       (DeviceAddressBindingFlagsEXT)(s.flags),
		BaseAddress: (DeviceAddress)(s.baseAddress),
		Size:        (DeviceSize)(s.size),
		BindingType: (DeviceAddressBindingTypeEXT)(s.bindingType),
	}
	return rval
}
func (s *DeviceAddressBindingCallbackDataEXT) Vulkanize() *_vkDeviceAddressBindingCallbackDataEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceAddressBindingCallbackDataEXT{
		sType:       STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                               /*cb*/
		flags:       (DeviceAddressBindingFlagsEXT)(s.Flags),                 /*cb*/
		baseAddress: (DeviceAddress)(s.BaseAddress),                          /*cb*/
		size:        (DeviceSize)(s.Size),                                    /*cb*/
		bindingType: (DeviceAddressBindingTypeEXT)(s.BindingType),            /*cb*/
	}
	return rval
}

// DeviceBufferMemoryRequirements: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceBufferMemoryRequirements.html
type DeviceBufferMemoryRequirements struct {
	// SType = STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS
	PNext       unsafe.Pointer
	PCreateInfo *BufferCreateInfo
}

type _vkDeviceBufferMemoryRequirements struct {
	sType       StructureType
	pNext       unsafe.Pointer
	pCreateInfo *_vkBufferCreateInfo
}

func (s *_vkDeviceBufferMemoryRequirements) Goify() *DeviceBufferMemoryRequirements {
	rval := &DeviceBufferMemoryRequirements{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected pointer member pCreateInfo in returned struct
	}
	return rval
}
func (s *DeviceBufferMemoryRequirements) Vulkanize() *_vkDeviceBufferMemoryRequirements {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceBufferMemoryRequirements{
		sType:       STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                        /*cb*/
		pCreateInfo: (s.PCreateInfo.Vulkanize()),                      /*c rem*/
	}
	return rval
}

// DeviceBufferMemoryRequirementsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceBufferMemoryRequirementsKHR.html
type DeviceBufferMemoryRequirementsKHR struct {
}

type _vkDeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirementsKHR

func (s *_vkDeviceBufferMemoryRequirementsKHR) Goify() *DeviceBufferMemoryRequirementsKHR {
	rval := (*DeviceBufferMemoryRequirementsKHR)(s)
	return rval
}
func (s *DeviceBufferMemoryRequirementsKHR) Vulkanize() *_vkDeviceBufferMemoryRequirementsKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceBufferMemoryRequirementsKHR)(s)
	return rval
}

// DeviceCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateInfo.html
type DeviceCreateInfo struct {
	// SType = STRUCTURE_TYPE_DEVICE_CREATE_INFO
	PNext unsafe.Pointer
	Flags DeviceCreateFlags
	// queueCreateInfoCount
	PQueueCreateInfos []DeviceQueueCreateInfo
	// enabledLayerCount
	//  Ordered list of layer names to be enabled;
	PpEnabledLayerNames []string
	// enabledExtensionCount
	PpEnabledExtensionNames []string
	PEnabledFeatures        *PhysicalDeviceFeatures
}

type _vkDeviceCreateInfo struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	flags                   DeviceCreateFlags
	queueCreateInfoCount    uint32
	pQueueCreateInfos       *_vkDeviceQueueCreateInfo
	enabledLayerCount       uint32
	ppEnabledLayerNames     **byte
	enabledExtensionCount   uint32
	ppEnabledExtensionNames **byte
	pEnabledFeatures        *_vkPhysicalDeviceFeatures
}

func (s *_vkDeviceCreateInfo) Goify() *DeviceCreateInfo {
	rval := &DeviceCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (DeviceCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pQueueCreateInfos in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member ppEnabledLayerNames in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member ppEnabledExtensionNames in returned struct
		// Unexpected pointer member pEnabledFeatures in returned struct
	}
	return rval
}
func (s *DeviceCreateInfo) Vulkanize() *_vkDeviceCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pQueueCreateInfos *_vkDeviceQueueCreateInfo
	if len(s.PQueueCreateInfos) > 0 {
		sl_pQueueCreateInfos := make([]_vkDeviceQueueCreateInfo, len(s.PQueueCreateInfos))
		for i, v := range s.PQueueCreateInfos {
			sl_pQueueCreateInfos[i] = *(v.Vulkanize())
		}
		psl_pQueueCreateInfos = &sl_pQueueCreateInfos[0]
	}

	var psl_ppEnabledLayerNames **byte
	if len(s.PpEnabledLayerNames) > 0 {
		sl_ppEnabledLayerNames := make([]*byte, len(s.PpEnabledLayerNames))
		for i, v := range s.PpEnabledLayerNames {
			sl_ppEnabledLayerNames[i] = sys_stringToBytePointer(v)
		}
		psl_ppEnabledLayerNames = &sl_ppEnabledLayerNames[0]
	}

	var psl_ppEnabledExtensionNames **byte
	if len(s.PpEnabledExtensionNames) > 0 {
		sl_ppEnabledExtensionNames := make([]*byte, len(s.PpEnabledExtensionNames))
		for i, v := range s.PpEnabledExtensionNames {
			sl_ppEnabledExtensionNames[i] = sys_stringToBytePointer(v)
		}
		psl_ppEnabledExtensionNames = &sl_ppEnabledExtensionNames[0]
	}
	rval := &_vkDeviceCreateInfo{
		sType:                   STRUCTURE_TYPE_DEVICE_CREATE_INFO,      /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),              /*cb*/
		flags:                   (DeviceCreateFlags)(s.Flags),           /*cb*/
		queueCreateInfoCount:    uint32(len(s.PQueueCreateInfos)),       /*c6-a*/
		pQueueCreateInfos:       psl_pQueueCreateInfos,                  /*c rem*/
		enabledLayerCount:       uint32(len(s.PpEnabledLayerNames)),     /*c6-a*/
		ppEnabledLayerNames:     psl_ppEnabledLayerNames,                /*c rem*/
		enabledExtensionCount:   uint32(len(s.PpEnabledExtensionNames)), /*c6-a*/
		ppEnabledExtensionNames: psl_ppEnabledExtensionNames,            /*c rem*/
		pEnabledFeatures:        (s.PEnabledFeatures.Vulkanize()),       /*c rem*/
	}
	return rval
}

// DeviceDeviceMemoryReportCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html
type DeviceDeviceMemoryReportCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT
	PNext           unsafe.Pointer
	Flags           DeviceMemoryReportFlagsEXT
	PfnUserCallback PFN_vkDeviceMemoryReportCallbackEXT
	PUserData       unsafe.Pointer
}

type _vkDeviceDeviceMemoryReportCreateInfoEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           DeviceMemoryReportFlagsEXT
	pfnUserCallback PFN_vkDeviceMemoryReportCallbackEXT
	pUserData       unsafe.Pointer
}

func (s *_vkDeviceDeviceMemoryReportCreateInfoEXT) Goify() *DeviceDeviceMemoryReportCreateInfoEXT {
	rval := &DeviceDeviceMemoryReportCreateInfoEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		Flags:           (DeviceMemoryReportFlagsEXT)(s.flags),
		PfnUserCallback: (PFN_vkDeviceMemoryReportCallbackEXT)(s.pfnUserCallback),
		PUserData:       (unsafe.Pointer)(s.pUserData),
	}
	return rval
}
func (s *DeviceDeviceMemoryReportCreateInfoEXT) Vulkanize() *_vkDeviceDeviceMemoryReportCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceDeviceMemoryReportCreateInfoEXT{
		sType:           STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                  /*cb*/
		flags:           (DeviceMemoryReportFlagsEXT)(s.Flags),                      /*cb*/
		pfnUserCallback: (PFN_vkDeviceMemoryReportCallbackEXT)(s.PfnUserCallback),   /*cb*/
		pUserData:       (unsafe.Pointer)(s.PUserData),                              /*cb*/
	}
	return rval
}

// DeviceDiagnosticsConfigCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html
type DeviceDiagnosticsConfigCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV
	PNext unsafe.Pointer
	Flags DeviceDiagnosticsConfigFlagsNV
}

type _vkDeviceDiagnosticsConfigCreateInfoNV struct {
	sType StructureType
	pNext unsafe.Pointer
	flags DeviceDiagnosticsConfigFlagsNV
}

func (s *_vkDeviceDiagnosticsConfigCreateInfoNV) Goify() *DeviceDiagnosticsConfigCreateInfoNV {
	rval := &DeviceDiagnosticsConfigCreateInfoNV{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (DeviceDiagnosticsConfigFlagsNV)(s.flags),
	}
	return rval
}
func (s *DeviceDiagnosticsConfigCreateInfoNV) Vulkanize() *_vkDeviceDiagnosticsConfigCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceDiagnosticsConfigCreateInfoNV{
		sType: STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                               /*cb*/
		flags: (DeviceDiagnosticsConfigFlagsNV)(s.Flags),               /*cb*/
	}
	return rval
}

// DeviceEventInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceEventInfoEXT.html
type DeviceEventInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT
	PNext       unsafe.Pointer
	DeviceEvent DeviceEventTypeEXT
}

type _vkDeviceEventInfoEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	deviceEvent DeviceEventTypeEXT
}

func (s *_vkDeviceEventInfoEXT) Goify() *DeviceEventInfoEXT {
	rval := &DeviceEventInfoEXT{
		PNext:       (unsafe.Pointer)(s.pNext),
		DeviceEvent: (DeviceEventTypeEXT)(s.deviceEvent),
	}
	return rval
}
func (s *DeviceEventInfoEXT) Vulkanize() *_vkDeviceEventInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceEventInfoEXT{
		sType:       STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),            /*cb*/
		deviceEvent: (DeviceEventTypeEXT)(s.DeviceEvent),  /*cb*/
	}
	return rval
}

// DeviceFaultAddressInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultAddressInfoEXT.html
type DeviceFaultAddressInfoEXT struct {
	AddressType      DeviceFaultAddressTypeEXT
	ReportedAddress  DeviceAddress
	AddressPrecision DeviceSize
}

type _vkDeviceFaultAddressInfoEXT = DeviceFaultAddressInfoEXT

func (s *_vkDeviceFaultAddressInfoEXT) Goify() *DeviceFaultAddressInfoEXT {
	rval := (*DeviceFaultAddressInfoEXT)(s)
	return rval
}
func (s *DeviceFaultAddressInfoEXT) Vulkanize() *_vkDeviceFaultAddressInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceFaultAddressInfoEXT)(s)
	return rval
}

// DeviceFaultCountsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultCountsEXT.html
type DeviceFaultCountsEXT struct {
	// SType = STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT
	PNext            unsafe.Pointer
	AddressInfoCount uint32
	VendorInfoCount  uint32
	//  Specified in bytes;
	VendorBinarySize DeviceSize
}

type _vkDeviceFaultCountsEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	addressInfoCount uint32
	vendorInfoCount  uint32
	vendorBinarySize DeviceSize
}

func (s *_vkDeviceFaultCountsEXT) Goify() *DeviceFaultCountsEXT {
	rval := &DeviceFaultCountsEXT{
		PNext:            (unsafe.Pointer)(s.pNext),
		AddressInfoCount: (uint32)(s.addressInfoCount),
		VendorInfoCount:  (uint32)(s.vendorInfoCount),
		VendorBinarySize: (DeviceSize)(s.vendorBinarySize),
	}
	return rval
}
func (s *DeviceFaultCountsEXT) Vulkanize() *_vkDeviceFaultCountsEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceFaultCountsEXT{
		sType:            STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),              /*cb*/
		addressInfoCount: (uint32)(s.AddressInfoCount),           /*cb*/
		vendorInfoCount:  (uint32)(s.VendorInfoCount),            /*cb*/
		vendorBinarySize: (DeviceSize)(s.VendorBinarySize),       /*cb*/
	}
	return rval
}

// DeviceFaultInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultInfoEXT.html
type DeviceFaultInfoEXT struct {
	// SType = STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT
	PNext unsafe.Pointer
	//  Free-form description of the fault;
	Description       string
	PAddressInfos     *DeviceFaultAddressInfoEXT
	PVendorInfos      *DeviceFaultVendorInfoEXT
	PVendorBinaryData unsafe.Pointer
}

type _vkDeviceFaultInfoEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	description       [MAX_DESCRIPTION_SIZE]byte
	pAddressInfos     *_vkDeviceFaultAddressInfoEXT
	pVendorInfos      *_vkDeviceFaultVendorInfoEXT
	pVendorBinaryData unsafe.Pointer
}

func (s *_vkDeviceFaultInfoEXT) Goify() *DeviceFaultInfoEXT {
	rval := &DeviceFaultInfoEXT{
		PNext:         (unsafe.Pointer)(s.pNext),
		Description:   nullTermBytesToString(s.description[:]), /*c arr*/
		PAddressInfos: (*DeviceFaultAddressInfoEXT)(s.pAddressInfos),
		// Unexpected pointer member pVendorInfos in returned struct
		PVendorBinaryData: (unsafe.Pointer)(s.pVendorBinaryData),
	}
	return rval
}
func (s *DeviceFaultInfoEXT) Vulkanize() *_vkDeviceFaultInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceFaultInfoEXT{
		sType: STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),            /*cb*/
		// description : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		pAddressInfos:     (*_vkDeviceFaultAddressInfoEXT)(s.PAddressInfos), /*cb*/
		pVendorInfos:      (s.PVendorInfos.Vulkanize()),                     /*c rem*/
		pVendorBinaryData: (unsafe.Pointer)(s.PVendorBinaryData),            /*cb*/
	}
	return rval
}

// DeviceFaultVendorBinaryHeaderVersionOneEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultVendorBinaryHeaderVersionOneEXT.html
type DeviceFaultVendorBinaryHeaderVersionOneEXT struct {
	HeaderSize            uint32
	HeaderVersion         DeviceFaultVendorBinaryHeaderVersionEXT
	VendorID              uint32
	DeviceID              uint32
	DriverVersion         uint32
	PipelineCacheUUID     [UUID_SIZE]uint8
	ApplicationNameOffset uint32
	ApplicationVersion    uint32
	EngineNameOffset      uint32
	EngineVersion         uint32
	ApiVersion            uint32
}

type _vkDeviceFaultVendorBinaryHeaderVersionOneEXT = DeviceFaultVendorBinaryHeaderVersionOneEXT

func (s *_vkDeviceFaultVendorBinaryHeaderVersionOneEXT) Goify() *DeviceFaultVendorBinaryHeaderVersionOneEXT {
	rval := (*DeviceFaultVendorBinaryHeaderVersionOneEXT)(s)
	return rval
}
func (s *DeviceFaultVendorBinaryHeaderVersionOneEXT) Vulkanize() *_vkDeviceFaultVendorBinaryHeaderVersionOneEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceFaultVendorBinaryHeaderVersionOneEXT)(s)
	return rval
}

// DeviceFaultVendorInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultVendorInfoEXT.html
type DeviceFaultVendorInfoEXT struct {
	//  Free-form description of the fault;
	Description     string
	VendorFaultCode uint64
	VendorFaultData uint64
}

type _vkDeviceFaultVendorInfoEXT struct {
	description     [MAX_DESCRIPTION_SIZE]byte
	vendorFaultCode uint64
	vendorFaultData uint64
}

func (s *_vkDeviceFaultVendorInfoEXT) Goify() *DeviceFaultVendorInfoEXT {
	rval := &DeviceFaultVendorInfoEXT{
		Description:     nullTermBytesToString(s.description[:]), /*c arr*/
		VendorFaultCode: (uint64)(s.vendorFaultCode),
		VendorFaultData: (uint64)(s.vendorFaultData),
	}
	return rval
}
func (s *DeviceFaultVendorInfoEXT) Vulkanize() *_vkDeviceFaultVendorInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceFaultVendorInfoEXT{
		// description : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		vendorFaultCode: (uint64)(s.VendorFaultCode), /*cb*/
		vendorFaultData: (uint64)(s.VendorFaultData), /*cb*/
	}
	return rval
}

// DeviceGroupBindSparseInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupBindSparseInfo.html
type DeviceGroupBindSparseInfo struct {
	// SType = STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO
	PNext               unsafe.Pointer
	ResourceDeviceIndex uint32
	MemoryDeviceIndex   uint32
}

type _vkDeviceGroupBindSparseInfo struct {
	sType               StructureType
	pNext               unsafe.Pointer
	resourceDeviceIndex uint32
	memoryDeviceIndex   uint32
}

func (s *_vkDeviceGroupBindSparseInfo) Goify() *DeviceGroupBindSparseInfo {
	rval := &DeviceGroupBindSparseInfo{
		PNext:               (unsafe.Pointer)(s.pNext),
		ResourceDeviceIndex: (uint32)(s.resourceDeviceIndex),
		MemoryDeviceIndex:   (uint32)(s.memoryDeviceIndex),
	}
	return rval
}
func (s *DeviceGroupBindSparseInfo) Vulkanize() *_vkDeviceGroupBindSparseInfo {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceGroupBindSparseInfo{
		sType:               STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                    /*cb*/
		resourceDeviceIndex: (uint32)(s.ResourceDeviceIndex),              /*cb*/
		memoryDeviceIndex:   (uint32)(s.MemoryDeviceIndex),                /*cb*/
	}
	return rval
}

// DeviceGroupBindSparseInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupBindSparseInfoKHR.html
type DeviceGroupBindSparseInfoKHR struct {
}

type _vkDeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfoKHR

func (s *_vkDeviceGroupBindSparseInfoKHR) Goify() *DeviceGroupBindSparseInfoKHR {
	rval := (*DeviceGroupBindSparseInfoKHR)(s)
	return rval
}
func (s *DeviceGroupBindSparseInfoKHR) Vulkanize() *_vkDeviceGroupBindSparseInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceGroupBindSparseInfoKHR)(s)
	return rval
}

// DeviceGroupCommandBufferBeginInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupCommandBufferBeginInfo.html
type DeviceGroupCommandBufferBeginInfo struct {
	// SType = STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO
	PNext      unsafe.Pointer
	DeviceMask uint32
}

type _vkDeviceGroupCommandBufferBeginInfo struct {
	sType      StructureType
	pNext      unsafe.Pointer
	deviceMask uint32
}

func (s *_vkDeviceGroupCommandBufferBeginInfo) Goify() *DeviceGroupCommandBufferBeginInfo {
	rval := &DeviceGroupCommandBufferBeginInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		DeviceMask: (uint32)(s.deviceMask),
	}
	return rval
}
func (s *DeviceGroupCommandBufferBeginInfo) Vulkanize() *_vkDeviceGroupCommandBufferBeginInfo {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceGroupCommandBufferBeginInfo{
		sType:      STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                             /*cb*/
		deviceMask: (uint32)(s.DeviceMask),                                /*cb*/
	}
	return rval
}

// DeviceGroupCommandBufferBeginInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupCommandBufferBeginInfoKHR.html
type DeviceGroupCommandBufferBeginInfoKHR struct {
}

type _vkDeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfoKHR

func (s *_vkDeviceGroupCommandBufferBeginInfoKHR) Goify() *DeviceGroupCommandBufferBeginInfoKHR {
	rval := (*DeviceGroupCommandBufferBeginInfoKHR)(s)
	return rval
}
func (s *DeviceGroupCommandBufferBeginInfoKHR) Vulkanize() *_vkDeviceGroupCommandBufferBeginInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceGroupCommandBufferBeginInfoKHR)(s)
	return rval
}

// DeviceGroupDeviceCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupDeviceCreateInfo.html
type DeviceGroupDeviceCreateInfo struct {
	// SType = STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO
	PNext unsafe.Pointer
	// physicalDeviceCount
	PPhysicalDevices []PhysicalDevice
}

type _vkDeviceGroupDeviceCreateInfo struct {
	sType               StructureType
	pNext               unsafe.Pointer
	physicalDeviceCount uint32
	pPhysicalDevices    *PhysicalDevice
}

func (s *_vkDeviceGroupDeviceCreateInfo) Goify() *DeviceGroupDeviceCreateInfo {
	rval := &DeviceGroupDeviceCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPhysicalDevices in returned struct
	}
	return rval
}
func (s *DeviceGroupDeviceCreateInfo) Vulkanize() *_vkDeviceGroupDeviceCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pPhysicalDevices *PhysicalDevice
	if len(s.PPhysicalDevices) > 0 {
		psl_pPhysicalDevices = &s.PPhysicalDevices[0]
	}
	rval := &_vkDeviceGroupDeviceCreateInfo{
		sType:               STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                      /*cb*/
		physicalDeviceCount: uint32(len(s.PPhysicalDevices)),                /*c6-a*/
		pPhysicalDevices:    psl_pPhysicalDevices,                           /*c rem*/
	}
	return rval
}

// DeviceGroupDeviceCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupDeviceCreateInfoKHR.html
type DeviceGroupDeviceCreateInfoKHR struct {
}

type _vkDeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfoKHR

func (s *_vkDeviceGroupDeviceCreateInfoKHR) Goify() *DeviceGroupDeviceCreateInfoKHR {
	rval := (*DeviceGroupDeviceCreateInfoKHR)(s)
	return rval
}
func (s *DeviceGroupDeviceCreateInfoKHR) Vulkanize() *_vkDeviceGroupDeviceCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceGroupDeviceCreateInfoKHR)(s)
	return rval
}

// DeviceGroupPresentCapabilitiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentCapabilitiesKHR.html
type DeviceGroupPresentCapabilitiesKHR struct {
	// SType = STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR
	PNext       unsafe.Pointer
	PresentMask [MAX_DEVICE_GROUP_SIZE]uint32
	Modes       DeviceGroupPresentModeFlagsKHR
}

// WARNING - struct DeviceGroupPresentCapabilitiesKHR is returned only, which is not yet handled in the binding
type _vkDeviceGroupPresentCapabilitiesKHR struct {
	sType       StructureType
	pNext       unsafe.Pointer
	presentMask [MAX_DEVICE_GROUP_SIZE]uint32
	modes       DeviceGroupPresentModeFlagsKHR
}

func (s *_vkDeviceGroupPresentCapabilitiesKHR) Goify() *DeviceGroupPresentCapabilitiesKHR {
	rval := &DeviceGroupPresentCapabilitiesKHR{
		PNext:       (unsafe.Pointer)(s.pNext),
		PresentMask: ([MAX_DEVICE_GROUP_SIZE]uint32)(s.presentMask),
		Modes:       (DeviceGroupPresentModeFlagsKHR)(s.modes),
	}
	return rval
}
func (s *DeviceGroupPresentCapabilitiesKHR) Vulkanize() *_vkDeviceGroupPresentCapabilitiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceGroupPresentCapabilitiesKHR{
		sType:       STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                            /*cb*/
		presentMask: ([MAX_DEVICE_GROUP_SIZE]uint32)(s.PresentMask),       /*cb*/
		modes:       (DeviceGroupPresentModeFlagsKHR)(s.Modes),            /*cb*/
	}
	return rval
}

// DeviceGroupPresentInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentInfoKHR.html
type DeviceGroupPresentInfoKHR struct {
	// SType = STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR
	PNext unsafe.Pointer
	// swapchainCount
	PDeviceMasks []uint32
	Mode         DeviceGroupPresentModeFlagBitsKHR
}

type _vkDeviceGroupPresentInfoKHR struct {
	sType          StructureType
	pNext          unsafe.Pointer
	swapchainCount uint32
	pDeviceMasks   *uint32
	mode           DeviceGroupPresentModeFlagBitsKHR
}

func (s *_vkDeviceGroupPresentInfoKHR) Goify() *DeviceGroupPresentInfoKHR {
	rval := &DeviceGroupPresentInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDeviceMasks in returned struct
		Mode: (DeviceGroupPresentModeFlagBitsKHR)(s.mode),
	}
	return rval
}
func (s *DeviceGroupPresentInfoKHR) Vulkanize() *_vkDeviceGroupPresentInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pDeviceMasks *uint32
	if len(s.PDeviceMasks) > 0 {
		psl_pDeviceMasks = &s.PDeviceMasks[0]
	}
	rval := &_vkDeviceGroupPresentInfoKHR{
		sType:          STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                    /*cb*/
		swapchainCount: uint32(len(s.PDeviceMasks)),                  /*c6-a*/
		pDeviceMasks:   psl_pDeviceMasks,                             /*c rem*/
		mode:           (DeviceGroupPresentModeFlagBitsKHR)(s.Mode),  /*cb*/
	}
	return rval
}

// DeviceGroupRenderPassBeginInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupRenderPassBeginInfo.html
type DeviceGroupRenderPassBeginInfo struct {
	// SType = STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO
	PNext      unsafe.Pointer
	DeviceMask uint32
	// deviceRenderAreaCount
	PDeviceRenderAreas []Rect2D
}

type _vkDeviceGroupRenderPassBeginInfo struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	deviceMask            uint32
	deviceRenderAreaCount uint32
	pDeviceRenderAreas    *_vkRect2D
}

func (s *_vkDeviceGroupRenderPassBeginInfo) Goify() *DeviceGroupRenderPassBeginInfo {
	rval := &DeviceGroupRenderPassBeginInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		DeviceMask: (uint32)(s.deviceMask),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDeviceRenderAreas in returned struct
	}
	return rval
}
func (s *DeviceGroupRenderPassBeginInfo) Vulkanize() *_vkDeviceGroupRenderPassBeginInfo {
	if s == nil {
		return nil
	}

	var psl_pDeviceRenderAreas *_vkRect2D
	if len(s.PDeviceRenderAreas) > 0 {
		sl_pDeviceRenderAreas := make([]_vkRect2D, len(s.PDeviceRenderAreas))
		for i, v := range s.PDeviceRenderAreas {
			sl_pDeviceRenderAreas[i] = *(v.Vulkanize())
		}
		psl_pDeviceRenderAreas = &sl_pDeviceRenderAreas[0]
	}
	rval := &_vkDeviceGroupRenderPassBeginInfo{
		sType:                 STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                          /*cb*/
		deviceMask:            (uint32)(s.DeviceMask),                             /*cb*/
		deviceRenderAreaCount: uint32(len(s.PDeviceRenderAreas)),                  /*c6-a*/
		pDeviceRenderAreas:    psl_pDeviceRenderAreas,                             /*c rem*/
	}
	return rval
}

// DeviceGroupRenderPassBeginInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupRenderPassBeginInfoKHR.html
type DeviceGroupRenderPassBeginInfoKHR struct {
}

type _vkDeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfoKHR

func (s *_vkDeviceGroupRenderPassBeginInfoKHR) Goify() *DeviceGroupRenderPassBeginInfoKHR {
	rval := (*DeviceGroupRenderPassBeginInfoKHR)(s)
	return rval
}
func (s *DeviceGroupRenderPassBeginInfoKHR) Vulkanize() *_vkDeviceGroupRenderPassBeginInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceGroupRenderPassBeginInfoKHR)(s)
	return rval
}

// DeviceGroupSubmitInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSubmitInfo.html
type DeviceGroupSubmitInfo struct {
	// SType = STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO
	PNext unsafe.Pointer
	// waitSemaphoreCount
	PWaitSemaphoreDeviceIndices []uint32
	// commandBufferCount
	PCommandBufferDeviceMasks []uint32
	// signalSemaphoreCount
	PSignalSemaphoreDeviceIndices []uint32
}

type _vkDeviceGroupSubmitInfo struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	waitSemaphoreCount            uint32
	pWaitSemaphoreDeviceIndices   *uint32
	commandBufferCount            uint32
	pCommandBufferDeviceMasks     *uint32
	signalSemaphoreCount          uint32
	pSignalSemaphoreDeviceIndices *uint32
}

func (s *_vkDeviceGroupSubmitInfo) Goify() *DeviceGroupSubmitInfo {
	rval := &DeviceGroupSubmitInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pWaitSemaphoreDeviceIndices in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCommandBufferDeviceMasks in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSignalSemaphoreDeviceIndices in returned struct
	}
	return rval
}
func (s *DeviceGroupSubmitInfo) Vulkanize() *_vkDeviceGroupSubmitInfo {
	if s == nil {
		return nil
	}

	var psl_pWaitSemaphoreDeviceIndices *uint32
	if len(s.PWaitSemaphoreDeviceIndices) > 0 {
		psl_pWaitSemaphoreDeviceIndices = &s.PWaitSemaphoreDeviceIndices[0]
	}

	var psl_pCommandBufferDeviceMasks *uint32
	if len(s.PCommandBufferDeviceMasks) > 0 {
		psl_pCommandBufferDeviceMasks = &s.PCommandBufferDeviceMasks[0]
	}

	var psl_pSignalSemaphoreDeviceIndices *uint32
	if len(s.PSignalSemaphoreDeviceIndices) > 0 {
		psl_pSignalSemaphoreDeviceIndices = &s.PSignalSemaphoreDeviceIndices[0]
	}
	rval := &_vkDeviceGroupSubmitInfo{
		sType:                         STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,      /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                    /*cb*/
		waitSemaphoreCount:            uint32(len(s.PWaitSemaphoreDeviceIndices)),   /*c6-a*/
		pWaitSemaphoreDeviceIndices:   psl_pWaitSemaphoreDeviceIndices,              /*c rem*/
		commandBufferCount:            uint32(len(s.PCommandBufferDeviceMasks)),     /*c6-a*/
		pCommandBufferDeviceMasks:     psl_pCommandBufferDeviceMasks,                /*c rem*/
		signalSemaphoreCount:          uint32(len(s.PSignalSemaphoreDeviceIndices)), /*c6-a*/
		pSignalSemaphoreDeviceIndices: psl_pSignalSemaphoreDeviceIndices,            /*c rem*/
	}
	return rval
}

// DeviceGroupSubmitInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSubmitInfoKHR.html
type DeviceGroupSubmitInfoKHR struct {
}

type _vkDeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfoKHR

func (s *_vkDeviceGroupSubmitInfoKHR) Goify() *DeviceGroupSubmitInfoKHR {
	rval := (*DeviceGroupSubmitInfoKHR)(s)
	return rval
}
func (s *DeviceGroupSubmitInfoKHR) Vulkanize() *_vkDeviceGroupSubmitInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceGroupSubmitInfoKHR)(s)
	return rval
}

// DeviceGroupSwapchainCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html
type DeviceGroupSwapchainCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR
	PNext unsafe.Pointer
	Modes DeviceGroupPresentModeFlagsKHR
}

type _vkDeviceGroupSwapchainCreateInfoKHR struct {
	sType StructureType
	pNext unsafe.Pointer
	modes DeviceGroupPresentModeFlagsKHR
}

func (s *_vkDeviceGroupSwapchainCreateInfoKHR) Goify() *DeviceGroupSwapchainCreateInfoKHR {
	rval := &DeviceGroupSwapchainCreateInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		Modes: (DeviceGroupPresentModeFlagsKHR)(s.modes),
	}
	return rval
}
func (s *DeviceGroupSwapchainCreateInfoKHR) Vulkanize() *_vkDeviceGroupSwapchainCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceGroupSwapchainCreateInfoKHR{
		sType: STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                             /*cb*/
		modes: (DeviceGroupPresentModeFlagsKHR)(s.Modes),             /*cb*/
	}
	return rval
}

// DeviceImageMemoryRequirements: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceImageMemoryRequirements.html
type DeviceImageMemoryRequirements struct {
	// SType = STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS
	PNext       unsafe.Pointer
	PCreateInfo *ImageCreateInfo
	PlaneAspect ImageAspectFlagBits
}

type _vkDeviceImageMemoryRequirements struct {
	sType       StructureType
	pNext       unsafe.Pointer
	pCreateInfo *_vkImageCreateInfo
	planeAspect ImageAspectFlagBits
}

func (s *_vkDeviceImageMemoryRequirements) Goify() *DeviceImageMemoryRequirements {
	rval := &DeviceImageMemoryRequirements{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected pointer member pCreateInfo in returned struct
		PlaneAspect: (ImageAspectFlagBits)(s.planeAspect),
	}
	return rval
}
func (s *DeviceImageMemoryRequirements) Vulkanize() *_vkDeviceImageMemoryRequirements {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceImageMemoryRequirements{
		sType:       STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                       /*cb*/
		pCreateInfo: (s.PCreateInfo.Vulkanize()),                     /*c rem*/
		planeAspect: (ImageAspectFlagBits)(s.PlaneAspect),            /*cb*/
	}
	return rval
}

// DeviceImageMemoryRequirementsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceImageMemoryRequirementsKHR.html
type DeviceImageMemoryRequirementsKHR struct {
}

type _vkDeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirementsKHR

func (s *_vkDeviceImageMemoryRequirementsKHR) Goify() *DeviceImageMemoryRequirementsKHR {
	rval := (*DeviceImageMemoryRequirementsKHR)(s)
	return rval
}
func (s *DeviceImageMemoryRequirementsKHR) Vulkanize() *_vkDeviceImageMemoryRequirementsKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceImageMemoryRequirementsKHR)(s)
	return rval
}

// DeviceImageSubresourceInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceImageSubresourceInfoKHR.html
type DeviceImageSubresourceInfoKHR struct {
	// SType = STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR
	PNext        unsafe.Pointer
	PCreateInfo  *ImageCreateInfo
	PSubresource *ImageSubresource2KHR
}

type _vkDeviceImageSubresourceInfoKHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	pCreateInfo  *_vkImageCreateInfo
	pSubresource *_vkImageSubresource2KHR
}

func (s *_vkDeviceImageSubresourceInfoKHR) Goify() *DeviceImageSubresourceInfoKHR {
	rval := &DeviceImageSubresourceInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected pointer member pCreateInfo in returned struct
		// Unexpected pointer member pSubresource in returned struct
	}
	return rval
}
func (s *DeviceImageSubresourceInfoKHR) Vulkanize() *_vkDeviceImageSubresourceInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceImageSubresourceInfoKHR{
		sType:        STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                        /*cb*/
		pCreateInfo:  (s.PCreateInfo.Vulkanize()),                      /*c rem*/
		pSubresource: (s.PSubresource.Vulkanize()),                     /*c rem*/
	}
	return rval
}

// DeviceMemoryOpaqueCaptureAddressInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html
type DeviceMemoryOpaqueCaptureAddressInfo struct {
	// SType = STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO
	PNext  unsafe.Pointer
	Memory DeviceMemory
}

type _vkDeviceMemoryOpaqueCaptureAddressInfo struct {
	sType  StructureType
	pNext  unsafe.Pointer
	memory DeviceMemory
}

func (s *_vkDeviceMemoryOpaqueCaptureAddressInfo) Goify() *DeviceMemoryOpaqueCaptureAddressInfo {
	rval := &DeviceMemoryOpaqueCaptureAddressInfo{
		PNext:  (unsafe.Pointer)(s.pNext),
		Memory: (DeviceMemory)(s.memory),
	}
	return rval
}
func (s *DeviceMemoryOpaqueCaptureAddressInfo) Vulkanize() *_vkDeviceMemoryOpaqueCaptureAddressInfo {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceMemoryOpaqueCaptureAddressInfo{
		sType:  STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                                /*cb*/
		memory: (DeviceMemory)(s.Memory),                                 /*cb*/
	}
	return rval
}

// DeviceMemoryOpaqueCaptureAddressInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOpaqueCaptureAddressInfoKHR.html
type DeviceMemoryOpaqueCaptureAddressInfoKHR struct {
}

type _vkDeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfoKHR

func (s *_vkDeviceMemoryOpaqueCaptureAddressInfoKHR) Goify() *DeviceMemoryOpaqueCaptureAddressInfoKHR {
	rval := (*DeviceMemoryOpaqueCaptureAddressInfoKHR)(s)
	return rval
}
func (s *DeviceMemoryOpaqueCaptureAddressInfoKHR) Vulkanize() *_vkDeviceMemoryOpaqueCaptureAddressInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceMemoryOpaqueCaptureAddressInfoKHR)(s)
	return rval
}

// DeviceMemoryOverallocationCreateInfoAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html
type DeviceMemoryOverallocationCreateInfoAMD struct {
	// SType = STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD
	PNext                  unsafe.Pointer
	OverallocationBehavior MemoryOverallocationBehaviorAMD
}

type _vkDeviceMemoryOverallocationCreateInfoAMD struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	overallocationBehavior MemoryOverallocationBehaviorAMD
}

func (s *_vkDeviceMemoryOverallocationCreateInfoAMD) Goify() *DeviceMemoryOverallocationCreateInfoAMD {
	rval := &DeviceMemoryOverallocationCreateInfoAMD{
		PNext:                  (unsafe.Pointer)(s.pNext),
		OverallocationBehavior: (MemoryOverallocationBehaviorAMD)(s.overallocationBehavior),
	}
	return rval
}
func (s *DeviceMemoryOverallocationCreateInfoAMD) Vulkanize() *_vkDeviceMemoryOverallocationCreateInfoAMD {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceMemoryOverallocationCreateInfoAMD{
		sType:                  STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                   /*cb*/
		overallocationBehavior: (MemoryOverallocationBehaviorAMD)(s.OverallocationBehavior), /*cb*/
	}
	return rval
}

// DeviceMemoryReportCallbackDataEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportCallbackDataEXT.html
type DeviceMemoryReportCallbackDataEXT struct {
	// SType = STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT
	PNext          unsafe.Pointer
	Flags          DeviceMemoryReportFlagsEXT
	Typ            DeviceMemoryReportEventTypeEXT
	MemoryObjectId uint64
	Size           DeviceSize
	ObjectType     ObjectType
	ObjectHandle   uint64
	HeapIndex      uint32
}

// WARNING - struct DeviceMemoryReportCallbackDataEXT is returned only, which is not yet handled in the binding
type _vkDeviceMemoryReportCallbackDataEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	flags          DeviceMemoryReportFlagsEXT
	typ            DeviceMemoryReportEventTypeEXT
	memoryObjectId uint64
	size           DeviceSize
	objectType     ObjectType
	objectHandle   uint64
	heapIndex      uint32
}

func (s *_vkDeviceMemoryReportCallbackDataEXT) Goify() *DeviceMemoryReportCallbackDataEXT {
	rval := &DeviceMemoryReportCallbackDataEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		Flags:          (DeviceMemoryReportFlagsEXT)(s.flags),
		Typ:            (DeviceMemoryReportEventTypeEXT)(s.typ),
		MemoryObjectId: (uint64)(s.memoryObjectId),
		Size:           (DeviceSize)(s.size),
		ObjectType:     (ObjectType)(s.objectType),
		ObjectHandle:   (uint64)(s.objectHandle),
		HeapIndex:      (uint32)(s.heapIndex),
	}
	return rval
}
func (s *DeviceMemoryReportCallbackDataEXT) Vulkanize() *_vkDeviceMemoryReportCallbackDataEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceMemoryReportCallbackDataEXT{
		sType:          STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                             /*cb*/
		flags:          (DeviceMemoryReportFlagsEXT)(s.Flags),                 /*cb*/
		typ:            (DeviceMemoryReportEventTypeEXT)(s.Typ),               /*cb*/
		memoryObjectId: (uint64)(s.MemoryObjectId),                            /*cb*/
		size:           (DeviceSize)(s.Size),                                  /*cb*/
		objectType:     (ObjectType)(s.ObjectType),                            /*cb*/
		objectHandle:   (uint64)(s.ObjectHandle),                              /*cb*/
		heapIndex:      (uint32)(s.HeapIndex),                                 /*cb*/
	}
	return rval
}

// DevicePrivateDataCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevicePrivateDataCreateInfoEXT.html
type DevicePrivateDataCreateInfoEXT struct {
}

type _vkDevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfoEXT

func (s *_vkDevicePrivateDataCreateInfoEXT) Goify() *DevicePrivateDataCreateInfoEXT {
	rval := (*DevicePrivateDataCreateInfoEXT)(s)
	return rval
}
func (s *DevicePrivateDataCreateInfoEXT) Vulkanize() *_vkDevicePrivateDataCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDevicePrivateDataCreateInfoEXT)(s)
	return rval
}

// DeviceQueueCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueCreateInfo.html
type DeviceQueueCreateInfo struct {
	// SType = STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
	PNext            unsafe.Pointer
	Flags            DeviceQueueCreateFlags
	QueueFamilyIndex uint32
	// queueCount
	PQueuePriorities []float32
}

type _vkDeviceQueueCreateInfo struct {
	sType            StructureType
	pNext            unsafe.Pointer
	flags            DeviceQueueCreateFlags
	queueFamilyIndex uint32
	queueCount       uint32
	pQueuePriorities *float32
}

func (s *_vkDeviceQueueCreateInfo) Goify() *DeviceQueueCreateInfo {
	rval := &DeviceQueueCreateInfo{
		PNext:            (unsafe.Pointer)(s.pNext),
		Flags:            (DeviceQueueCreateFlags)(s.flags),
		QueueFamilyIndex: (uint32)(s.queueFamilyIndex),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pQueuePriorities in returned struct
	}
	return rval
}
func (s *DeviceQueueCreateInfo) Vulkanize() *_vkDeviceQueueCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pQueuePriorities *float32
	if len(s.PQueuePriorities) > 0 {
		psl_pQueuePriorities = &s.PQueuePriorities[0]
	}
	rval := &_vkDeviceQueueCreateInfo{
		sType:            STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),               /*cb*/
		flags:            (DeviceQueueCreateFlags)(s.Flags),       /*cb*/
		queueFamilyIndex: (uint32)(s.QueueFamilyIndex),            /*cb*/
		queueCount:       uint32(len(s.PQueuePriorities)),         /*c6-a*/
		pQueuePriorities: psl_pQueuePriorities,                    /*c rem*/
	}
	return rval
}

// DeviceQueueGlobalPriorityCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueGlobalPriorityCreateInfoEXT.html
type DeviceQueueGlobalPriorityCreateInfoEXT struct {
}

type _vkDeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoEXT

func (s *_vkDeviceQueueGlobalPriorityCreateInfoEXT) Goify() *DeviceQueueGlobalPriorityCreateInfoEXT {
	rval := (*DeviceQueueGlobalPriorityCreateInfoEXT)(s)
	return rval
}
func (s *DeviceQueueGlobalPriorityCreateInfoEXT) Vulkanize() *_vkDeviceQueueGlobalPriorityCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDeviceQueueGlobalPriorityCreateInfoEXT)(s)
	return rval
}

// DeviceQueueGlobalPriorityCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueGlobalPriorityCreateInfoKHR.html
type DeviceQueueGlobalPriorityCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR
	PNext          unsafe.Pointer
	GlobalPriority QueueGlobalPriorityKHR
}

type _vkDeviceQueueGlobalPriorityCreateInfoKHR struct {
	sType          StructureType
	pNext          unsafe.Pointer
	globalPriority QueueGlobalPriorityKHR
}

func (s *_vkDeviceQueueGlobalPriorityCreateInfoKHR) Goify() *DeviceQueueGlobalPriorityCreateInfoKHR {
	rval := &DeviceQueueGlobalPriorityCreateInfoKHR{
		PNext:          (unsafe.Pointer)(s.pNext),
		GlobalPriority: (QueueGlobalPriorityKHR)(s.globalPriority),
	}
	return rval
}
func (s *DeviceQueueGlobalPriorityCreateInfoKHR) Vulkanize() *_vkDeviceQueueGlobalPriorityCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceQueueGlobalPriorityCreateInfoKHR{
		sType:          STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                   /*cb*/
		globalPriority: (QueueGlobalPriorityKHR)(s.GlobalPriority),                  /*cb*/
	}
	return rval
}

// DeviceQueueInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueInfo2.html
type DeviceQueueInfo2 struct {
	// SType = STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2
	PNext            unsafe.Pointer
	Flags            DeviceQueueCreateFlags
	QueueFamilyIndex uint32
	QueueIndex       uint32
}

type _vkDeviceQueueInfo2 struct {
	sType            StructureType
	pNext            unsafe.Pointer
	flags            DeviceQueueCreateFlags
	queueFamilyIndex uint32
	queueIndex       uint32
}

func (s *_vkDeviceQueueInfo2) Goify() *DeviceQueueInfo2 {
	rval := &DeviceQueueInfo2{
		PNext:            (unsafe.Pointer)(s.pNext),
		Flags:            (DeviceQueueCreateFlags)(s.flags),
		QueueFamilyIndex: (uint32)(s.queueFamilyIndex),
		QueueIndex:       (uint32)(s.queueIndex),
	}
	return rval
}
func (s *DeviceQueueInfo2) Vulkanize() *_vkDeviceQueueInfo2 {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceQueueInfo2{
		sType:            STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),          /*cb*/
		flags:            (DeviceQueueCreateFlags)(s.Flags),  /*cb*/
		queueFamilyIndex: (uint32)(s.QueueFamilyIndex),       /*cb*/
		queueIndex:       (uint32)(s.QueueIndex),             /*cb*/
	}
	return rval
}

// DeviceQueueShaderCoreControlCreateInfoARM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueShaderCoreControlCreateInfoARM.html
type DeviceQueueShaderCoreControlCreateInfoARM struct {
	// SType = STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM
	PNext           unsafe.Pointer
	ShaderCoreCount uint32
}

type _vkDeviceQueueShaderCoreControlCreateInfoARM struct {
	sType           StructureType
	pNext           unsafe.Pointer
	shaderCoreCount uint32
}

func (s *_vkDeviceQueueShaderCoreControlCreateInfoARM) Goify() *DeviceQueueShaderCoreControlCreateInfoARM {
	rval := &DeviceQueueShaderCoreControlCreateInfoARM{
		PNext:           (unsafe.Pointer)(s.pNext),
		ShaderCoreCount: (uint32)(s.shaderCoreCount),
	}
	return rval
}
func (s *DeviceQueueShaderCoreControlCreateInfoARM) Vulkanize() *_vkDeviceQueueShaderCoreControlCreateInfoARM {
	if s == nil {
		return nil
	}
	rval := &_vkDeviceQueueShaderCoreControlCreateInfoARM{
		sType:           STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                       /*cb*/
		shaderCoreCount: (uint32)(s.ShaderCoreCount),                                     /*cb*/
	}
	return rval
}

// DirectDriverLoadingInfoLUNARG: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingInfoLUNARG.html
type DirectDriverLoadingInfoLUNARG struct {
	// SType = STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG
	PNext                  unsafe.Pointer
	Flags                  DirectDriverLoadingFlagsLUNARG
	PfnGetInstanceProcAddr PFN_vkGetInstanceProcAddrLUNARG
}

type _vkDirectDriverLoadingInfoLUNARG struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	flags                  DirectDriverLoadingFlagsLUNARG
	pfnGetInstanceProcAddr PFN_vkGetInstanceProcAddrLUNARG
}

func (s *_vkDirectDriverLoadingInfoLUNARG) Goify() *DirectDriverLoadingInfoLUNARG {
	rval := &DirectDriverLoadingInfoLUNARG{
		PNext:                  (unsafe.Pointer)(s.pNext),
		Flags:                  (DirectDriverLoadingFlagsLUNARG)(s.flags),
		PfnGetInstanceProcAddr: (PFN_vkGetInstanceProcAddrLUNARG)(s.pfnGetInstanceProcAddr),
	}
	return rval
}
func (s *DirectDriverLoadingInfoLUNARG) Vulkanize() *_vkDirectDriverLoadingInfoLUNARG {
	if s == nil {
		return nil
	}
	rval := &_vkDirectDriverLoadingInfoLUNARG{
		sType:                  STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG,            /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                   /*cb*/
		flags:                  (DirectDriverLoadingFlagsLUNARG)(s.Flags),                   /*cb*/
		pfnGetInstanceProcAddr: (PFN_vkGetInstanceProcAddrLUNARG)(s.PfnGetInstanceProcAddr), /*cb*/
	}
	return rval
}

// DirectDriverLoadingListLUNARG: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingListLUNARG.html
type DirectDriverLoadingListLUNARG struct {
	// SType = STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG
	PNext unsafe.Pointer
	Mode  DirectDriverLoadingModeLUNARG
	// driverCount
	PDrivers []DirectDriverLoadingInfoLUNARG
}

type _vkDirectDriverLoadingListLUNARG struct {
	sType       StructureType
	pNext       unsafe.Pointer
	mode        DirectDriverLoadingModeLUNARG
	driverCount uint32
	pDrivers    *_vkDirectDriverLoadingInfoLUNARG
}

func (s *_vkDirectDriverLoadingListLUNARG) Goify() *DirectDriverLoadingListLUNARG {
	rval := &DirectDriverLoadingListLUNARG{
		PNext: (unsafe.Pointer)(s.pNext),
		Mode:  (DirectDriverLoadingModeLUNARG)(s.mode),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDrivers in returned struct
	}
	return rval
}
func (s *DirectDriverLoadingListLUNARG) Vulkanize() *_vkDirectDriverLoadingListLUNARG {
	if s == nil {
		return nil
	}

	var psl_pDrivers *_vkDirectDriverLoadingInfoLUNARG
	if len(s.PDrivers) > 0 {
		sl_pDrivers := make([]_vkDirectDriverLoadingInfoLUNARG, len(s.PDrivers))
		for i, v := range s.PDrivers {
			sl_pDrivers[i] = *(v.Vulkanize())
		}
		psl_pDrivers = &sl_pDrivers[0]
	}
	rval := &_vkDirectDriverLoadingListLUNARG{
		sType:       STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                        /*cb*/
		mode:        (DirectDriverLoadingModeLUNARG)(s.Mode),          /*cb*/
		driverCount: uint32(len(s.PDrivers)),                          /*c6-a*/
		pDrivers:    psl_pDrivers,                                     /*c rem*/
	}
	return rval
}

// DispatchIndirectCommand: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDispatchIndirectCommand.html
type DispatchIndirectCommand struct {
	X uint32
	Y uint32
	Z uint32
}

type _vkDispatchIndirectCommand = DispatchIndirectCommand

func (s *_vkDispatchIndirectCommand) Goify() *DispatchIndirectCommand {
	rval := (*DispatchIndirectCommand)(s)
	return rval
}
func (s *DispatchIndirectCommand) Vulkanize() *_vkDispatchIndirectCommand {
	if s == nil {
		return nil
	}
	rval := (*_vkDispatchIndirectCommand)(s)
	return rval
}

// DisplayEventInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayEventInfoEXT.html
type DisplayEventInfoEXT struct {
	// SType = STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT
	PNext        unsafe.Pointer
	DisplayEvent DisplayEventTypeEXT
}

type _vkDisplayEventInfoEXT struct {
	sType        StructureType
	pNext        unsafe.Pointer
	displayEvent DisplayEventTypeEXT
}

func (s *_vkDisplayEventInfoEXT) Goify() *DisplayEventInfoEXT {
	rval := &DisplayEventInfoEXT{
		PNext:        (unsafe.Pointer)(s.pNext),
		DisplayEvent: (DisplayEventTypeEXT)(s.displayEvent),
	}
	return rval
}
func (s *DisplayEventInfoEXT) Vulkanize() *_vkDisplayEventInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayEventInfoEXT{
		sType:        STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),             /*cb*/
		displayEvent: (DisplayEventTypeEXT)(s.DisplayEvent), /*cb*/
	}
	return rval
}

// DisplayModeCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateInfoKHR.html
type DisplayModeCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR
	PNext unsafe.Pointer
	Flags DisplayModeCreateFlagsKHR
	//  The parameters this mode uses.;
	Parameters DisplayModeParametersKHR
}

type _vkDisplayModeCreateInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	flags      DisplayModeCreateFlagsKHR
	parameters _vkDisplayModeParametersKHR
}

func (s *_vkDisplayModeCreateInfoKHR) Goify() *DisplayModeCreateInfoKHR {
	rval := &DisplayModeCreateInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		Flags:      (DisplayModeCreateFlagsKHR)(s.flags),
		Parameters: *(s.parameters.Goify()),
	}
	return rval
}
func (s *DisplayModeCreateInfoKHR) Vulkanize() *_vkDisplayModeCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayModeCreateInfoKHR{
		sType:      STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                   /*cb*/
		flags:      (DisplayModeCreateFlagsKHR)(s.Flags),        /*cb*/
		parameters: *(s.Parameters.Vulkanize()),                 /*c3*/
	}
	return rval
}

// DisplayModeParametersKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeParametersKHR.html
type DisplayModeParametersKHR struct {
	//  Visible scanout region.;
	VisibleRegion Extent2D
	//  Number of times per second the display is updated.;
	RefreshRate uint32
}

type _vkDisplayModeParametersKHR struct {
	visibleRegion _vkExtent2D
	refreshRate   uint32
}

func (s *_vkDisplayModeParametersKHR) Goify() *DisplayModeParametersKHR {
	rval := &DisplayModeParametersKHR{
		VisibleRegion: (Extent2D)(s.visibleRegion),
		RefreshRate:   (uint32)(s.refreshRate),
	}
	return rval
}
func (s *DisplayModeParametersKHR) Vulkanize() *_vkDisplayModeParametersKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayModeParametersKHR{
		visibleRegion: (_vkExtent2D)(s.VisibleRegion), /*cb*/
		refreshRate:   (uint32)(s.RefreshRate),        /*cb*/
	}
	return rval
}

// DisplayModeProperties2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeProperties2KHR.html
type DisplayModeProperties2KHR struct {
	// SType = STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR
	PNext                 unsafe.Pointer
	DisplayModeProperties DisplayModePropertiesKHR
}

// WARNING - struct DisplayModeProperties2KHR is returned only, which is not yet handled in the binding
type _vkDisplayModeProperties2KHR struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	displayModeProperties _vkDisplayModePropertiesKHR
}

func (s *_vkDisplayModeProperties2KHR) Goify() *DisplayModeProperties2KHR {
	rval := &DisplayModeProperties2KHR{
		PNext:                 (unsafe.Pointer)(s.pNext),
		DisplayModeProperties: *(s.displayModeProperties.Goify()),
	}
	return rval
}
func (s *DisplayModeProperties2KHR) Vulkanize() *_vkDisplayModeProperties2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayModeProperties2KHR{
		sType:                 STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                    /*cb*/
		displayModeProperties: *(s.DisplayModeProperties.Vulkanize()),       /*c3*/
	}
	return rval
}

// DisplayModePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModePropertiesKHR.html
type DisplayModePropertiesKHR struct {
	//  Handle of this display mode.;
	DisplayMode DisplayModeKHR
	//  The parameters this mode uses.;
	Parameters DisplayModeParametersKHR
}

// WARNING - struct DisplayModePropertiesKHR is returned only, which is not yet handled in the binding
type _vkDisplayModePropertiesKHR struct {
	displayMode DisplayModeKHR
	parameters  _vkDisplayModeParametersKHR
}

func (s *_vkDisplayModePropertiesKHR) Goify() *DisplayModePropertiesKHR {
	rval := &DisplayModePropertiesKHR{
		DisplayMode: (DisplayModeKHR)(s.displayMode),
		Parameters:  *(s.parameters.Goify()),
	}
	return rval
}
func (s *DisplayModePropertiesKHR) Vulkanize() *_vkDisplayModePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayModePropertiesKHR{
		displayMode: (DisplayModeKHR)(s.DisplayMode), /*cb*/
		parameters:  *(s.Parameters.Vulkanize()),     /*c3*/
	}
	return rval
}

// DisplayNativeHdrSurfaceCapabilitiesAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html
type DisplayNativeHdrSurfaceCapabilitiesAMD struct {
	// SType = STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD
	PNext               unsafe.Pointer
	LocalDimmingSupport bool
}

// WARNING - struct DisplayNativeHdrSurfaceCapabilitiesAMD is returned only, which is not yet handled in the binding
type _vkDisplayNativeHdrSurfaceCapabilitiesAMD struct {
	sType               StructureType
	pNext               unsafe.Pointer
	localDimmingSupport Bool32
}

func (s *_vkDisplayNativeHdrSurfaceCapabilitiesAMD) Goify() *DisplayNativeHdrSurfaceCapabilitiesAMD {
	rval := &DisplayNativeHdrSurfaceCapabilitiesAMD{
		PNext:               (unsafe.Pointer)(s.pNext),
		LocalDimmingSupport: translatePublic_Bool32(s.localDimmingSupport), /*default*/
	}
	return rval
}
func (s *DisplayNativeHdrSurfaceCapabilitiesAMD) Vulkanize() *_vkDisplayNativeHdrSurfaceCapabilitiesAMD {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayNativeHdrSurfaceCapabilitiesAMD{
		sType:               STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                  /*cb*/
		localDimmingSupport: translateInternal_Bool32(s.LocalDimmingSupport),            /*default*/
	}
	return rval
}

// DisplayPlaneCapabilities2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilities2KHR.html
type DisplayPlaneCapabilities2KHR struct {
	// SType = STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR
	PNext        unsafe.Pointer
	Capabilities DisplayPlaneCapabilitiesKHR
}

// WARNING - struct DisplayPlaneCapabilities2KHR is returned only, which is not yet handled in the binding
type _vkDisplayPlaneCapabilities2KHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	capabilities _vkDisplayPlaneCapabilitiesKHR
}

func (s *_vkDisplayPlaneCapabilities2KHR) Goify() *DisplayPlaneCapabilities2KHR {
	rval := &DisplayPlaneCapabilities2KHR{
		PNext:        (unsafe.Pointer)(s.pNext),
		Capabilities: *(s.capabilities.Goify()),
	}
	return rval
}
func (s *DisplayPlaneCapabilities2KHR) Vulkanize() *_vkDisplayPlaneCapabilities2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayPlaneCapabilities2KHR{
		sType:        STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                       /*cb*/
		capabilities: *(s.Capabilities.Vulkanize()),                   /*c3*/
	}
	return rval
}

// DisplayPlaneCapabilitiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilitiesKHR.html
type DisplayPlaneCapabilitiesKHR struct {
	//  Types of alpha blending supported, if any.;
	SupportedAlpha DisplayPlaneAlphaFlagsKHR
	//  Does the plane have any position and extent restrictions?;
	MinSrcPosition Offset2D
	MaxSrcPosition Offset2D
	MinSrcExtent   Extent2D
	MaxSrcExtent   Extent2D
	MinDstPosition Offset2D
	MaxDstPosition Offset2D
	MinDstExtent   Extent2D
	MaxDstExtent   Extent2D
}

// WARNING - struct DisplayPlaneCapabilitiesKHR is returned only, which is not yet handled in the binding
type _vkDisplayPlaneCapabilitiesKHR struct {
	supportedAlpha DisplayPlaneAlphaFlagsKHR
	minSrcPosition _vkOffset2D
	maxSrcPosition _vkOffset2D
	minSrcExtent   _vkExtent2D
	maxSrcExtent   _vkExtent2D
	minDstPosition _vkOffset2D
	maxDstPosition _vkOffset2D
	minDstExtent   _vkExtent2D
	maxDstExtent   _vkExtent2D
}

func (s *_vkDisplayPlaneCapabilitiesKHR) Goify() *DisplayPlaneCapabilitiesKHR {
	rval := &DisplayPlaneCapabilitiesKHR{
		SupportedAlpha: (DisplayPlaneAlphaFlagsKHR)(s.supportedAlpha),
		MinSrcPosition: (Offset2D)(s.minSrcPosition),
		MaxSrcPosition: (Offset2D)(s.maxSrcPosition),
		MinSrcExtent:   (Extent2D)(s.minSrcExtent),
		MaxSrcExtent:   (Extent2D)(s.maxSrcExtent),
		MinDstPosition: (Offset2D)(s.minDstPosition),
		MaxDstPosition: (Offset2D)(s.maxDstPosition),
		MinDstExtent:   (Extent2D)(s.minDstExtent),
		MaxDstExtent:   (Extent2D)(s.maxDstExtent),
	}
	return rval
}
func (s *DisplayPlaneCapabilitiesKHR) Vulkanize() *_vkDisplayPlaneCapabilitiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayPlaneCapabilitiesKHR{
		supportedAlpha: (DisplayPlaneAlphaFlagsKHR)(s.SupportedAlpha), /*cb*/
		minSrcPosition: (_vkOffset2D)(s.MinSrcPosition),               /*cb*/
		maxSrcPosition: (_vkOffset2D)(s.MaxSrcPosition),               /*cb*/
		minSrcExtent:   (_vkExtent2D)(s.MinSrcExtent),                 /*cb*/
		maxSrcExtent:   (_vkExtent2D)(s.MaxSrcExtent),                 /*cb*/
		minDstPosition: (_vkOffset2D)(s.MinDstPosition),               /*cb*/
		maxDstPosition: (_vkOffset2D)(s.MaxDstPosition),               /*cb*/
		minDstExtent:   (_vkExtent2D)(s.MinDstExtent),                 /*cb*/
		maxDstExtent:   (_vkExtent2D)(s.MaxDstExtent),                 /*cb*/
	}
	return rval
}

// DisplayPlaneInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneInfo2KHR.html
type DisplayPlaneInfo2KHR struct {
	// SType = STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR
	PNext      unsafe.Pointer
	Mode       DisplayModeKHR
	PlaneIndex uint32
}

type _vkDisplayPlaneInfo2KHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	mode       DisplayModeKHR
	planeIndex uint32
}

func (s *_vkDisplayPlaneInfo2KHR) Goify() *DisplayPlaneInfo2KHR {
	rval := &DisplayPlaneInfo2KHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		Mode:       (DisplayModeKHR)(s.mode),
		PlaneIndex: (uint32)(s.planeIndex),
	}
	return rval
}
func (s *DisplayPlaneInfo2KHR) Vulkanize() *_vkDisplayPlaneInfo2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayPlaneInfo2KHR{
		sType:      STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),               /*cb*/
		mode:       (DisplayModeKHR)(s.Mode),                /*cb*/
		planeIndex: (uint32)(s.PlaneIndex),                  /*cb*/
	}
	return rval
}

// DisplayPlaneProperties2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneProperties2KHR.html
type DisplayPlaneProperties2KHR struct {
	// SType = STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR
	PNext                  unsafe.Pointer
	DisplayPlaneProperties DisplayPlanePropertiesKHR
}

// WARNING - struct DisplayPlaneProperties2KHR is returned only, which is not yet handled in the binding
type _vkDisplayPlaneProperties2KHR struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	displayPlaneProperties _vkDisplayPlanePropertiesKHR
}

func (s *_vkDisplayPlaneProperties2KHR) Goify() *DisplayPlaneProperties2KHR {
	rval := &DisplayPlaneProperties2KHR{
		PNext:                  (unsafe.Pointer)(s.pNext),
		DisplayPlaneProperties: (DisplayPlanePropertiesKHR)(s.displayPlaneProperties),
	}
	return rval
}
func (s *DisplayPlaneProperties2KHR) Vulkanize() *_vkDisplayPlaneProperties2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayPlaneProperties2KHR{
		sType:                  STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR,            /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                /*cb*/
		displayPlaneProperties: (_vkDisplayPlanePropertiesKHR)(s.DisplayPlaneProperties), /*cb*/
	}
	return rval
}

// DisplayPlanePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlanePropertiesKHR.html
type DisplayPlanePropertiesKHR struct {
	//  Display the plane is currently associated with.  Will be VK_NULL_HANDLE if the plane is not in use.;
	CurrentDisplay DisplayKHR
	//  Current z-order of the plane.;
	CurrentStackIndex uint32
}

type _vkDisplayPlanePropertiesKHR = DisplayPlanePropertiesKHR

func (s *_vkDisplayPlanePropertiesKHR) Goify() *DisplayPlanePropertiesKHR {
	rval := (*DisplayPlanePropertiesKHR)(s)
	return rval
}
func (s *DisplayPlanePropertiesKHR) Vulkanize() *_vkDisplayPlanePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkDisplayPlanePropertiesKHR)(s)
	return rval
}

// DisplayPowerInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPowerInfoEXT.html
type DisplayPowerInfoEXT struct {
	// SType = STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT
	PNext      unsafe.Pointer
	PowerState DisplayPowerStateEXT
}

type _vkDisplayPowerInfoEXT struct {
	sType      StructureType
	pNext      unsafe.Pointer
	powerState DisplayPowerStateEXT
}

func (s *_vkDisplayPowerInfoEXT) Goify() *DisplayPowerInfoEXT {
	rval := &DisplayPowerInfoEXT{
		PNext:      (unsafe.Pointer)(s.pNext),
		PowerState: (DisplayPowerStateEXT)(s.powerState),
	}
	return rval
}
func (s *DisplayPowerInfoEXT) Vulkanize() *_vkDisplayPowerInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayPowerInfoEXT{
		sType:      STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),             /*cb*/
		powerState: (DisplayPowerStateEXT)(s.PowerState),  /*cb*/
	}
	return rval
}

// DisplayPresentInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPresentInfoKHR.html
type DisplayPresentInfoKHR struct {
	// SType = STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR
	PNext unsafe.Pointer
	//  Rectangle within the presentable image to read pixel data from when presenting to the display.;
	SrcRect Rect2D
	//  Rectangle within the current display mode's visible region to display srcRectangle in.;
	DstRect Rect2D
	//  For smart displays, use buffered mode.  If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE.;
	Persistent bool
}

type _vkDisplayPresentInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	srcRect    _vkRect2D
	dstRect    _vkRect2D
	persistent Bool32
}

func (s *_vkDisplayPresentInfoKHR) Goify() *DisplayPresentInfoKHR {
	rval := &DisplayPresentInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		SrcRect:    *(s.srcRect.Goify()),
		DstRect:    *(s.dstRect.Goify()),
		Persistent: translatePublic_Bool32(s.persistent), /*default*/
	}
	return rval
}
func (s *DisplayPresentInfoKHR) Vulkanize() *_vkDisplayPresentInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayPresentInfoKHR{
		sType:      STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),               /*cb*/
		srcRect:    *(s.SrcRect.Vulkanize()),                /*c3*/
		dstRect:    *(s.DstRect.Vulkanize()),                /*c3*/
		persistent: translateInternal_Bool32(s.Persistent),  /*default*/
	}
	return rval
}

// DisplayProperties2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayProperties2KHR.html
type DisplayProperties2KHR struct {
	// SType = STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR
	PNext             unsafe.Pointer
	DisplayProperties DisplayPropertiesKHR
}

// WARNING - struct DisplayProperties2KHR is returned only, which is not yet handled in the binding
type _vkDisplayProperties2KHR struct {
	sType             StructureType
	pNext             unsafe.Pointer
	displayProperties _vkDisplayPropertiesKHR
}

func (s *_vkDisplayProperties2KHR) Goify() *DisplayProperties2KHR {
	rval := &DisplayProperties2KHR{
		PNext:             (unsafe.Pointer)(s.pNext),
		DisplayProperties: *(s.displayProperties.Goify()),
	}
	return rval
}
func (s *DisplayProperties2KHR) Vulkanize() *_vkDisplayProperties2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayProperties2KHR{
		sType:             STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),               /*cb*/
		displayProperties: *(s.DisplayProperties.Vulkanize()),      /*c3*/
	}
	return rval
}

// DisplayPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPropertiesKHR.html
type DisplayPropertiesKHR struct {
	//  Handle of the display object;
	Display DisplayKHR
	//  Name of the display;
	DisplayName string
	//  In millimeters?;
	PhysicalDimensions Extent2D
	//  Max resolution for CRT?;
	PhysicalResolution Extent2D
	//  one or more bits from VkSurfaceTransformFlagsKHR;
	SupportedTransforms SurfaceTransformFlagsKHR
	//  VK_TRUE if the overlay plane's z-order can be changed on this display.;
	PlaneReorderPossible bool
	//  VK_TRUE if this is a "smart" display that supports self-refresh/internal buffering.;
	PersistentContent bool
}

// WARNING - struct DisplayPropertiesKHR is returned only, which is not yet handled in the binding
type _vkDisplayPropertiesKHR struct {
	display              DisplayKHR
	displayName          *byte
	physicalDimensions   _vkExtent2D
	physicalResolution   _vkExtent2D
	supportedTransforms  SurfaceTransformFlagsKHR
	planeReorderPossible Bool32
	persistentContent    Bool32
}

func (s *_vkDisplayPropertiesKHR) Goify() *DisplayPropertiesKHR {
	rval := &DisplayPropertiesKHR{
		Display: (DisplayKHR)(s.display),
		// Unexpected pointer member displayName in returned struct
		PhysicalDimensions:   (Extent2D)(s.physicalDimensions),
		PhysicalResolution:   (Extent2D)(s.physicalResolution),
		SupportedTransforms:  (SurfaceTransformFlagsKHR)(s.supportedTransforms),
		PlaneReorderPossible: translatePublic_Bool32(s.planeReorderPossible), /*default*/
		PersistentContent:    translatePublic_Bool32(s.persistentContent),    /*default*/
	}
	return rval
}
func (s *DisplayPropertiesKHR) Vulkanize() *_vkDisplayPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplayPropertiesKHR{
		display:              (DisplayKHR)(s.Display),                           /*cb*/
		displayName:          sys_stringToBytePointer(s.DisplayName),            /*c rem*/
		physicalDimensions:   (_vkExtent2D)(s.PhysicalDimensions),               /*cb*/
		physicalResolution:   (_vkExtent2D)(s.PhysicalResolution),               /*cb*/
		supportedTransforms:  (SurfaceTransformFlagsKHR)(s.SupportedTransforms), /*cb*/
		planeReorderPossible: translateInternal_Bool32(s.PlaneReorderPossible),  /*default*/
		persistentContent:    translateInternal_Bool32(s.PersistentContent),     /*default*/
	}
	return rval
}

// DisplaySurfaceCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateInfoKHR.html
type DisplaySurfaceCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR
	PNext unsafe.Pointer
	Flags DisplaySurfaceCreateFlagsKHR
	//  The mode to use when displaying this surface;
	DisplayMode DisplayModeKHR
	//  The plane on which this surface appears.  Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount.;
	PlaneIndex uint32
	//  The z-order of the plane.;
	PlaneStackIndex uint32
	//  Transform to apply to the images as part of the scanout operation;
	Transform SurfaceTransformFlagBitsKHR
	//  Global alpha value.  Must be between 0 and 1, inclusive.  Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR;
	GlobalAlpha float32
	//  What type of alpha blending to use.  Must be a bit from vkGetDisplayPlanePropertiesKHR::supportedAlpha.;
	AlphaMode DisplayPlaneAlphaFlagBitsKHR
	//  size of the images to use with this surface;
	ImageExtent Extent2D
}

type _vkDisplaySurfaceCreateInfoKHR struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           DisplaySurfaceCreateFlagsKHR
	displayMode     DisplayModeKHR
	planeIndex      uint32
	planeStackIndex uint32
	transform       SurfaceTransformFlagBitsKHR
	globalAlpha     float32
	alphaMode       DisplayPlaneAlphaFlagBitsKHR
	imageExtent     _vkExtent2D
}

func (s *_vkDisplaySurfaceCreateInfoKHR) Goify() *DisplaySurfaceCreateInfoKHR {
	rval := &DisplaySurfaceCreateInfoKHR{
		PNext:           (unsafe.Pointer)(s.pNext),
		Flags:           (DisplaySurfaceCreateFlagsKHR)(s.flags),
		DisplayMode:     (DisplayModeKHR)(s.displayMode),
		PlaneIndex:      (uint32)(s.planeIndex),
		PlaneStackIndex: (uint32)(s.planeStackIndex),
		Transform:       (SurfaceTransformFlagBitsKHR)(s.transform),
		GlobalAlpha:     (float32)(s.globalAlpha),
		AlphaMode:       (DisplayPlaneAlphaFlagBitsKHR)(s.alphaMode),
		ImageExtent:     (Extent2D)(s.imageExtent),
	}
	return rval
}
func (s *DisplaySurfaceCreateInfoKHR) Vulkanize() *_vkDisplaySurfaceCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkDisplaySurfaceCreateInfoKHR{
		sType:           STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                      /*cb*/
		flags:           (DisplaySurfaceCreateFlagsKHR)(s.Flags),        /*cb*/
		displayMode:     (DisplayModeKHR)(s.DisplayMode),                /*cb*/
		planeIndex:      (uint32)(s.PlaneIndex),                         /*cb*/
		planeStackIndex: (uint32)(s.PlaneStackIndex),                    /*cb*/
		transform:       (SurfaceTransformFlagBitsKHR)(s.Transform),     /*cb*/
		globalAlpha:     (float32)(s.GlobalAlpha),                       /*cb*/
		alphaMode:       (DisplayPlaneAlphaFlagBitsKHR)(s.AlphaMode),    /*cb*/
		imageExtent:     (_vkExtent2D)(s.ImageExtent),                   /*cb*/
	}
	return rval
}

// DrawIndexedIndirectCommand: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndexedIndirectCommand.html
type DrawIndexedIndirectCommand struct {
	IndexCount    uint32
	InstanceCount uint32
	FirstIndex    uint32
	VertexOffset  int32
	FirstInstance uint32
}

type _vkDrawIndexedIndirectCommand = DrawIndexedIndirectCommand

func (s *_vkDrawIndexedIndirectCommand) Goify() *DrawIndexedIndirectCommand {
	rval := (*DrawIndexedIndirectCommand)(s)
	return rval
}
func (s *DrawIndexedIndirectCommand) Vulkanize() *_vkDrawIndexedIndirectCommand {
	if s == nil {
		return nil
	}
	rval := (*_vkDrawIndexedIndirectCommand)(s)
	return rval
}

// DrawIndirectCommand: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndirectCommand.html
type DrawIndirectCommand struct {
	VertexCount   uint32
	InstanceCount uint32
	FirstVertex   uint32
	FirstInstance uint32
}

type _vkDrawIndirectCommand = DrawIndirectCommand

func (s *_vkDrawIndirectCommand) Goify() *DrawIndirectCommand {
	rval := (*DrawIndirectCommand)(s)
	return rval
}
func (s *DrawIndirectCommand) Vulkanize() *_vkDrawIndirectCommand {
	if s == nil {
		return nil
	}
	rval := (*_vkDrawIndirectCommand)(s)
	return rval
}

// DrawMeshTasksIndirectCommandEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawMeshTasksIndirectCommandEXT.html
type DrawMeshTasksIndirectCommandEXT struct {
	GroupCountX uint32
	GroupCountY uint32
	GroupCountZ uint32
}

type _vkDrawMeshTasksIndirectCommandEXT = DrawMeshTasksIndirectCommandEXT

func (s *_vkDrawMeshTasksIndirectCommandEXT) Goify() *DrawMeshTasksIndirectCommandEXT {
	rval := (*DrawMeshTasksIndirectCommandEXT)(s)
	return rval
}
func (s *DrawMeshTasksIndirectCommandEXT) Vulkanize() *_vkDrawMeshTasksIndirectCommandEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDrawMeshTasksIndirectCommandEXT)(s)
	return rval
}

// DrawMeshTasksIndirectCommandNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawMeshTasksIndirectCommandNV.html
type DrawMeshTasksIndirectCommandNV struct {
	TaskCount uint32
	FirstTask uint32
}

type _vkDrawMeshTasksIndirectCommandNV = DrawMeshTasksIndirectCommandNV

func (s *_vkDrawMeshTasksIndirectCommandNV) Goify() *DrawMeshTasksIndirectCommandNV {
	rval := (*DrawMeshTasksIndirectCommandNV)(s)
	return rval
}
func (s *DrawMeshTasksIndirectCommandNV) Vulkanize() *_vkDrawMeshTasksIndirectCommandNV {
	if s == nil {
		return nil
	}
	rval := (*_vkDrawMeshTasksIndirectCommandNV)(s)
	return rval
}

// DrmFormatModifierProperties2EXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierProperties2EXT.html
type DrmFormatModifierProperties2EXT struct {
	DrmFormatModifier               uint64
	DrmFormatModifierPlaneCount     uint32
	DrmFormatModifierTilingFeatures FormatFeatureFlags2
}

type _vkDrmFormatModifierProperties2EXT = DrmFormatModifierProperties2EXT

func (s *_vkDrmFormatModifierProperties2EXT) Goify() *DrmFormatModifierProperties2EXT {
	rval := (*DrmFormatModifierProperties2EXT)(s)
	return rval
}
func (s *DrmFormatModifierProperties2EXT) Vulkanize() *_vkDrmFormatModifierProperties2EXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDrmFormatModifierProperties2EXT)(s)
	return rval
}

// DrmFormatModifierPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesEXT.html
type DrmFormatModifierPropertiesEXT struct {
	DrmFormatModifier               uint64
	DrmFormatModifierPlaneCount     uint32
	DrmFormatModifierTilingFeatures FormatFeatureFlags
}

type _vkDrmFormatModifierPropertiesEXT = DrmFormatModifierPropertiesEXT

func (s *_vkDrmFormatModifierPropertiesEXT) Goify() *DrmFormatModifierPropertiesEXT {
	rval := (*DrmFormatModifierPropertiesEXT)(s)
	return rval
}
func (s *DrmFormatModifierPropertiesEXT) Vulkanize() *_vkDrmFormatModifierPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkDrmFormatModifierPropertiesEXT)(s)
	return rval
}

// DrmFormatModifierPropertiesList2EXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesList2EXT.html
type DrmFormatModifierPropertiesList2EXT struct {
	// SType = STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT
	PNext unsafe.Pointer
	// drmFormatModifierCount
	PDrmFormatModifierProperties []DrmFormatModifierProperties2EXT
}

// WARNING - struct DrmFormatModifierPropertiesList2EXT is returned only, which is not yet handled in the binding
type _vkDrmFormatModifierPropertiesList2EXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	drmFormatModifierCount       uint32
	pDrmFormatModifierProperties *_vkDrmFormatModifierProperties2EXT
}

func (s *_vkDrmFormatModifierPropertiesList2EXT) Goify() *DrmFormatModifierPropertiesList2EXT {
	rval := &DrmFormatModifierPropertiesList2EXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDrmFormatModifierProperties in returned struct
	}
	return rval
}
func (s *DrmFormatModifierPropertiesList2EXT) Vulkanize() *_vkDrmFormatModifierPropertiesList2EXT {
	if s == nil {
		return nil
	}

	var psl_pDrmFormatModifierProperties *_vkDrmFormatModifierProperties2EXT
	if len(s.PDrmFormatModifierProperties) > 0 {
		psl_pDrmFormatModifierProperties = &s.PDrmFormatModifierProperties[0]
	}
	rval := &_vkDrmFormatModifierPropertiesList2EXT{
		sType:                        STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                /*cb*/
		drmFormatModifierCount:       uint32(len(s.PDrmFormatModifierProperties)),              /*c6-a*/
		pDrmFormatModifierProperties: psl_pDrmFormatModifierProperties,                         /*c rem*/
	}
	return rval
}

// DrmFormatModifierPropertiesListEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesListEXT.html
type DrmFormatModifierPropertiesListEXT struct {
	// SType = STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT
	PNext unsafe.Pointer
	// drmFormatModifierCount
	PDrmFormatModifierProperties []DrmFormatModifierPropertiesEXT
}

// WARNING - struct DrmFormatModifierPropertiesListEXT is returned only, which is not yet handled in the binding
type _vkDrmFormatModifierPropertiesListEXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	drmFormatModifierCount       uint32
	pDrmFormatModifierProperties *_vkDrmFormatModifierPropertiesEXT
}

func (s *_vkDrmFormatModifierPropertiesListEXT) Goify() *DrmFormatModifierPropertiesListEXT {
	rval := &DrmFormatModifierPropertiesListEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDrmFormatModifierProperties in returned struct
	}
	return rval
}
func (s *DrmFormatModifierPropertiesListEXT) Vulkanize() *_vkDrmFormatModifierPropertiesListEXT {
	if s == nil {
		return nil
	}

	var psl_pDrmFormatModifierProperties *_vkDrmFormatModifierPropertiesEXT
	if len(s.PDrmFormatModifierProperties) > 0 {
		psl_pDrmFormatModifierProperties = &s.PDrmFormatModifierProperties[0]
	}
	rval := &_vkDrmFormatModifierPropertiesListEXT{
		sType:                        STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                              /*cb*/
		drmFormatModifierCount:       uint32(len(s.PDrmFormatModifierProperties)),            /*c6-a*/
		pDrmFormatModifierProperties: psl_pDrmFormatModifierProperties,                       /*c rem*/
	}
	return rval
}

// EventCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEventCreateInfo.html
type EventCreateInfo struct {
	// SType = STRUCTURE_TYPE_EVENT_CREATE_INFO
	PNext unsafe.Pointer
	//  Event creation flags;
	Flags EventCreateFlags
}

type _vkEventCreateInfo struct {
	sType StructureType
	pNext unsafe.Pointer
	flags EventCreateFlags
}

func (s *_vkEventCreateInfo) Goify() *EventCreateInfo {
	rval := &EventCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (EventCreateFlags)(s.flags),
	}
	return rval
}
func (s *EventCreateInfo) Vulkanize() *_vkEventCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkEventCreateInfo{
		sType: STRUCTURE_TYPE_EVENT_CREATE_INFO, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),        /*cb*/
		flags: (EventCreateFlags)(s.Flags),      /*cb*/
	}
	return rval
}

// ExportFenceCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceCreateInfo.html
type ExportFenceCreateInfo struct {
	// SType = STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO
	PNext       unsafe.Pointer
	HandleTypes ExternalFenceHandleTypeFlags
}

type _vkExportFenceCreateInfo struct {
	sType       StructureType
	pNext       unsafe.Pointer
	handleTypes ExternalFenceHandleTypeFlags
}

func (s *_vkExportFenceCreateInfo) Goify() *ExportFenceCreateInfo {
	rval := &ExportFenceCreateInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		HandleTypes: (ExternalFenceHandleTypeFlags)(s.handleTypes),
	}
	return rval
}
func (s *ExportFenceCreateInfo) Vulkanize() *_vkExportFenceCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkExportFenceCreateInfo{
		sType:       STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,       /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                     /*cb*/
		handleTypes: (ExternalFenceHandleTypeFlags)(s.HandleTypes), /*cb*/
	}
	return rval
}

// ExportFenceCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceCreateInfoKHR.html
type ExportFenceCreateInfoKHR struct {
}

type _vkExportFenceCreateInfoKHR = ExportFenceCreateInfoKHR

func (s *_vkExportFenceCreateInfoKHR) Goify() *ExportFenceCreateInfoKHR {
	rval := (*ExportFenceCreateInfoKHR)(s)
	return rval
}
func (s *ExportFenceCreateInfoKHR) Vulkanize() *_vkExportFenceCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExportFenceCreateInfoKHR)(s)
	return rval
}

// ExportMemoryAllocateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfo.html
type ExportMemoryAllocateInfo struct {
	// SType = STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO
	PNext       unsafe.Pointer
	HandleTypes ExternalMemoryHandleTypeFlags
}

type _vkExportMemoryAllocateInfo struct {
	sType       StructureType
	pNext       unsafe.Pointer
	handleTypes ExternalMemoryHandleTypeFlags
}

func (s *_vkExportMemoryAllocateInfo) Goify() *ExportMemoryAllocateInfo {
	rval := &ExportMemoryAllocateInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		HandleTypes: (ExternalMemoryHandleTypeFlags)(s.handleTypes),
	}
	return rval
}
func (s *ExportMemoryAllocateInfo) Vulkanize() *_vkExportMemoryAllocateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkExportMemoryAllocateInfo{
		sType:       STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,     /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                      /*cb*/
		handleTypes: (ExternalMemoryHandleTypeFlags)(s.HandleTypes), /*cb*/
	}
	return rval
}

// ExportMemoryAllocateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfoKHR.html
type ExportMemoryAllocateInfoKHR struct {
}

type _vkExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfoKHR

func (s *_vkExportMemoryAllocateInfoKHR) Goify() *ExportMemoryAllocateInfoKHR {
	rval := (*ExportMemoryAllocateInfoKHR)(s)
	return rval
}
func (s *ExportMemoryAllocateInfoKHR) Vulkanize() *_vkExportMemoryAllocateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExportMemoryAllocateInfoKHR)(s)
	return rval
}

// ExportMemoryAllocateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfoNV.html
type ExportMemoryAllocateInfoNV struct {
	// SType = STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV
	PNext       unsafe.Pointer
	HandleTypes ExternalMemoryHandleTypeFlagsNV
}

type _vkExportMemoryAllocateInfoNV struct {
	sType       StructureType
	pNext       unsafe.Pointer
	handleTypes ExternalMemoryHandleTypeFlagsNV
}

func (s *_vkExportMemoryAllocateInfoNV) Goify() *ExportMemoryAllocateInfoNV {
	rval := &ExportMemoryAllocateInfoNV{
		PNext:       (unsafe.Pointer)(s.pNext),
		HandleTypes: (ExternalMemoryHandleTypeFlagsNV)(s.handleTypes),
	}
	return rval
}
func (s *ExportMemoryAllocateInfoNV) Vulkanize() *_vkExportMemoryAllocateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkExportMemoryAllocateInfoNV{
		sType:       STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV,    /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                        /*cb*/
		handleTypes: (ExternalMemoryHandleTypeFlagsNV)(s.HandleTypes), /*cb*/
	}
	return rval
}

// ExportSemaphoreCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreCreateInfo.html
type ExportSemaphoreCreateInfo struct {
	// SType = STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO
	PNext       unsafe.Pointer
	HandleTypes ExternalSemaphoreHandleTypeFlags
}

type _vkExportSemaphoreCreateInfo struct {
	sType       StructureType
	pNext       unsafe.Pointer
	handleTypes ExternalSemaphoreHandleTypeFlags
}

func (s *_vkExportSemaphoreCreateInfo) Goify() *ExportSemaphoreCreateInfo {
	rval := &ExportSemaphoreCreateInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		HandleTypes: (ExternalSemaphoreHandleTypeFlags)(s.handleTypes),
	}
	return rval
}
func (s *ExportSemaphoreCreateInfo) Vulkanize() *_vkExportSemaphoreCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkExportSemaphoreCreateInfo{
		sType:       STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,       /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                         /*cb*/
		handleTypes: (ExternalSemaphoreHandleTypeFlags)(s.HandleTypes), /*cb*/
	}
	return rval
}

// ExportSemaphoreCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreCreateInfoKHR.html
type ExportSemaphoreCreateInfoKHR struct {
}

type _vkExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfoKHR

func (s *_vkExportSemaphoreCreateInfoKHR) Goify() *ExportSemaphoreCreateInfoKHR {
	rval := (*ExportSemaphoreCreateInfoKHR)(s)
	return rval
}
func (s *ExportSemaphoreCreateInfoKHR) Vulkanize() *_vkExportSemaphoreCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExportSemaphoreCreateInfoKHR)(s)
	return rval
}

// ExtensionProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtensionProperties.html
type ExtensionProperties struct {
	//  extension name;
	ExtensionName string
	//  version of the extension specification implemented;
	SpecVersion uint32
}

// WARNING - struct ExtensionProperties is returned only, which is not yet handled in the binding
type _vkExtensionProperties struct {
	extensionName [MAX_EXTENSION_NAME_SIZE]byte
	specVersion   uint32
}

func (s *_vkExtensionProperties) Goify() *ExtensionProperties {
	rval := &ExtensionProperties{
		ExtensionName: nullTermBytesToString(s.extensionName[:]), /*c arr*/
		SpecVersion:   (uint32)(s.specVersion),
	}
	return rval
}
func (s *ExtensionProperties) Vulkanize() *_vkExtensionProperties {
	if s == nil {
		return nil
	}
	rval := &_vkExtensionProperties{
		// extensionName : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		specVersion: (uint32)(s.SpecVersion), /*cb*/
	}
	return rval
}

// Extent2D: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent2D.html
type Extent2D struct {
	Width  uint32
	Height uint32
}

type _vkExtent2D = Extent2D

func (s *_vkExtent2D) Goify() *Extent2D {
	rval := (*Extent2D)(s)
	return rval
}
func (s *Extent2D) Vulkanize() *_vkExtent2D {
	if s == nil {
		return nil
	}
	rval := (*_vkExtent2D)(s)
	return rval
}

// Extent3D: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent3D.html
type Extent3D struct {
	Width  uint32
	Height uint32
	Depth  uint32
}

type _vkExtent3D = Extent3D

func (s *_vkExtent3D) Goify() *Extent3D {
	rval := (*Extent3D)(s)
	return rval
}
func (s *Extent3D) Vulkanize() *_vkExtent3D {
	if s == nil {
		return nil
	}
	rval := (*_vkExtent3D)(s)
	return rval
}

// ExternalBufferProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalBufferProperties.html
type ExternalBufferProperties struct {
	// SType = STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES
	PNext                    unsafe.Pointer
	ExternalMemoryProperties ExternalMemoryProperties
}

// WARNING - struct ExternalBufferProperties is returned only, which is not yet handled in the binding
type _vkExternalBufferProperties struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	externalMemoryProperties _vkExternalMemoryProperties
}

func (s *_vkExternalBufferProperties) Goify() *ExternalBufferProperties {
	rval := &ExternalBufferProperties{
		PNext:                    (unsafe.Pointer)(s.pNext),
		ExternalMemoryProperties: (ExternalMemoryProperties)(s.externalMemoryProperties),
	}
	return rval
}
func (s *ExternalBufferProperties) Vulkanize() *_vkExternalBufferProperties {
	if s == nil {
		return nil
	}
	rval := &_vkExternalBufferProperties{
		sType:                    STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,                 /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                 /*cb*/
		externalMemoryProperties: (_vkExternalMemoryProperties)(s.ExternalMemoryProperties), /*cb*/
	}
	return rval
}

// ExternalBufferPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalBufferPropertiesKHR.html
type ExternalBufferPropertiesKHR struct {
}

type _vkExternalBufferPropertiesKHR = ExternalBufferPropertiesKHR

func (s *_vkExternalBufferPropertiesKHR) Goify() *ExternalBufferPropertiesKHR {
	rval := (*ExternalBufferPropertiesKHR)(s)
	return rval
}
func (s *ExternalBufferPropertiesKHR) Vulkanize() *_vkExternalBufferPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExternalBufferPropertiesKHR)(s)
	return rval
}

// ExternalFenceProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceProperties.html
type ExternalFenceProperties struct {
	// SType = STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES
	PNext                         unsafe.Pointer
	ExportFromImportedHandleTypes ExternalFenceHandleTypeFlags
	CompatibleHandleTypes         ExternalFenceHandleTypeFlags
	ExternalFenceFeatures         ExternalFenceFeatureFlags
}

// WARNING - struct ExternalFenceProperties is returned only, which is not yet handled in the binding
type _vkExternalFenceProperties struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	exportFromImportedHandleTypes ExternalFenceHandleTypeFlags
	compatibleHandleTypes         ExternalFenceHandleTypeFlags
	externalFenceFeatures         ExternalFenceFeatureFlags
}

func (s *_vkExternalFenceProperties) Goify() *ExternalFenceProperties {
	rval := &ExternalFenceProperties{
		PNext:                         (unsafe.Pointer)(s.pNext),
		ExportFromImportedHandleTypes: (ExternalFenceHandleTypeFlags)(s.exportFromImportedHandleTypes),
		CompatibleHandleTypes:         (ExternalFenceHandleTypeFlags)(s.compatibleHandleTypes),
		ExternalFenceFeatures:         (ExternalFenceFeatureFlags)(s.externalFenceFeatures),
	}
	return rval
}
func (s *ExternalFenceProperties) Vulkanize() *_vkExternalFenceProperties {
	if s == nil {
		return nil
	}
	rval := &_vkExternalFenceProperties{
		sType:                         STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,                        /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                       /*cb*/
		exportFromImportedHandleTypes: (ExternalFenceHandleTypeFlags)(s.ExportFromImportedHandleTypes), /*cb*/
		compatibleHandleTypes:         (ExternalFenceHandleTypeFlags)(s.CompatibleHandleTypes),         /*cb*/
		externalFenceFeatures:         (ExternalFenceFeatureFlags)(s.ExternalFenceFeatures),            /*cb*/
	}
	return rval
}

// ExternalFencePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFencePropertiesKHR.html
type ExternalFencePropertiesKHR struct {
}

type _vkExternalFencePropertiesKHR = ExternalFencePropertiesKHR

func (s *_vkExternalFencePropertiesKHR) Goify() *ExternalFencePropertiesKHR {
	rval := (*ExternalFencePropertiesKHR)(s)
	return rval
}
func (s *ExternalFencePropertiesKHR) Vulkanize() *_vkExternalFencePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExternalFencePropertiesKHR)(s)
	return rval
}

// ExternalImageFormatProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatProperties.html
type ExternalImageFormatProperties struct {
	// SType = STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES
	PNext                    unsafe.Pointer
	ExternalMemoryProperties ExternalMemoryProperties
}

// WARNING - struct ExternalImageFormatProperties is returned only, which is not yet handled in the binding
type _vkExternalImageFormatProperties struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	externalMemoryProperties _vkExternalMemoryProperties
}

func (s *_vkExternalImageFormatProperties) Goify() *ExternalImageFormatProperties {
	rval := &ExternalImageFormatProperties{
		PNext:                    (unsafe.Pointer)(s.pNext),
		ExternalMemoryProperties: (ExternalMemoryProperties)(s.externalMemoryProperties),
	}
	return rval
}
func (s *ExternalImageFormatProperties) Vulkanize() *_vkExternalImageFormatProperties {
	if s == nil {
		return nil
	}
	rval := &_vkExternalImageFormatProperties{
		sType:                    STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,           /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                 /*cb*/
		externalMemoryProperties: (_vkExternalMemoryProperties)(s.ExternalMemoryProperties), /*cb*/
	}
	return rval
}

// ExternalImageFormatPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatPropertiesKHR.html
type ExternalImageFormatPropertiesKHR struct {
}

type _vkExternalImageFormatPropertiesKHR = ExternalImageFormatPropertiesKHR

func (s *_vkExternalImageFormatPropertiesKHR) Goify() *ExternalImageFormatPropertiesKHR {
	rval := (*ExternalImageFormatPropertiesKHR)(s)
	return rval
}
func (s *ExternalImageFormatPropertiesKHR) Vulkanize() *_vkExternalImageFormatPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExternalImageFormatPropertiesKHR)(s)
	return rval
}

// ExternalImageFormatPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatPropertiesNV.html
type ExternalImageFormatPropertiesNV struct {
	ImageFormatProperties         ImageFormatProperties
	ExternalMemoryFeatures        ExternalMemoryFeatureFlagsNV
	ExportFromImportedHandleTypes ExternalMemoryHandleTypeFlagsNV
	CompatibleHandleTypes         ExternalMemoryHandleTypeFlagsNV
}

// WARNING - struct ExternalImageFormatPropertiesNV is returned only, which is not yet handled in the binding
type _vkExternalImageFormatPropertiesNV struct {
	imageFormatProperties         _vkImageFormatProperties
	externalMemoryFeatures        ExternalMemoryFeatureFlagsNV
	exportFromImportedHandleTypes ExternalMemoryHandleTypeFlagsNV
	compatibleHandleTypes         ExternalMemoryHandleTypeFlagsNV
}

func (s *_vkExternalImageFormatPropertiesNV) Goify() *ExternalImageFormatPropertiesNV {
	rval := &ExternalImageFormatPropertiesNV{
		ImageFormatProperties:         *(s.imageFormatProperties.Goify()),
		ExternalMemoryFeatures:        (ExternalMemoryFeatureFlagsNV)(s.externalMemoryFeatures),
		ExportFromImportedHandleTypes: (ExternalMemoryHandleTypeFlagsNV)(s.exportFromImportedHandleTypes),
		CompatibleHandleTypes:         (ExternalMemoryHandleTypeFlagsNV)(s.compatibleHandleTypes),
	}
	return rval
}
func (s *ExternalImageFormatPropertiesNV) Vulkanize() *_vkExternalImageFormatPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkExternalImageFormatPropertiesNV{
		imageFormatProperties:         *(s.ImageFormatProperties.Vulkanize()),                             /*c3*/
		externalMemoryFeatures:        (ExternalMemoryFeatureFlagsNV)(s.ExternalMemoryFeatures),           /*cb*/
		exportFromImportedHandleTypes: (ExternalMemoryHandleTypeFlagsNV)(s.ExportFromImportedHandleTypes), /*cb*/
		compatibleHandleTypes:         (ExternalMemoryHandleTypeFlagsNV)(s.CompatibleHandleTypes),         /*cb*/
	}
	return rval
}

// ExternalMemoryAcquireUnmodifiedEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryAcquireUnmodifiedEXT.html
type ExternalMemoryAcquireUnmodifiedEXT struct {
	// SType = STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT
	PNext                   unsafe.Pointer
	AcquireUnmodifiedMemory bool
}

type _vkExternalMemoryAcquireUnmodifiedEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	acquireUnmodifiedMemory Bool32
}

func (s *_vkExternalMemoryAcquireUnmodifiedEXT) Goify() *ExternalMemoryAcquireUnmodifiedEXT {
	rval := &ExternalMemoryAcquireUnmodifiedEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		AcquireUnmodifiedMemory: translatePublic_Bool32(s.acquireUnmodifiedMemory), /*default*/
	}
	return rval
}
func (s *ExternalMemoryAcquireUnmodifiedEXT) Vulkanize() *_vkExternalMemoryAcquireUnmodifiedEXT {
	if s == nil {
		return nil
	}
	rval := &_vkExternalMemoryAcquireUnmodifiedEXT{
		sType:                   STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                             /*cb*/
		acquireUnmodifiedMemory: translateInternal_Bool32(s.AcquireUnmodifiedMemory),   /*default*/
	}
	return rval
}

// ExternalMemoryBufferCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryBufferCreateInfo.html
type ExternalMemoryBufferCreateInfo struct {
	// SType = STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO
	PNext       unsafe.Pointer
	HandleTypes ExternalMemoryHandleTypeFlags
}

type _vkExternalMemoryBufferCreateInfo struct {
	sType       StructureType
	pNext       unsafe.Pointer
	handleTypes ExternalMemoryHandleTypeFlags
}

func (s *_vkExternalMemoryBufferCreateInfo) Goify() *ExternalMemoryBufferCreateInfo {
	rval := &ExternalMemoryBufferCreateInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		HandleTypes: (ExternalMemoryHandleTypeFlags)(s.handleTypes),
	}
	return rval
}
func (s *ExternalMemoryBufferCreateInfo) Vulkanize() *_vkExternalMemoryBufferCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkExternalMemoryBufferCreateInfo{
		sType:       STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                         /*cb*/
		handleTypes: (ExternalMemoryHandleTypeFlags)(s.HandleTypes),    /*cb*/
	}
	return rval
}

// ExternalMemoryBufferCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryBufferCreateInfoKHR.html
type ExternalMemoryBufferCreateInfoKHR struct {
}

type _vkExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfoKHR

func (s *_vkExternalMemoryBufferCreateInfoKHR) Goify() *ExternalMemoryBufferCreateInfoKHR {
	rval := (*ExternalMemoryBufferCreateInfoKHR)(s)
	return rval
}
func (s *ExternalMemoryBufferCreateInfoKHR) Vulkanize() *_vkExternalMemoryBufferCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExternalMemoryBufferCreateInfoKHR)(s)
	return rval
}

// ExternalMemoryImageCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfo.html
type ExternalMemoryImageCreateInfo struct {
	// SType = STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO
	PNext       unsafe.Pointer
	HandleTypes ExternalMemoryHandleTypeFlags
}

type _vkExternalMemoryImageCreateInfo struct {
	sType       StructureType
	pNext       unsafe.Pointer
	handleTypes ExternalMemoryHandleTypeFlags
}

func (s *_vkExternalMemoryImageCreateInfo) Goify() *ExternalMemoryImageCreateInfo {
	rval := &ExternalMemoryImageCreateInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		HandleTypes: (ExternalMemoryHandleTypeFlags)(s.handleTypes),
	}
	return rval
}
func (s *ExternalMemoryImageCreateInfo) Vulkanize() *_vkExternalMemoryImageCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkExternalMemoryImageCreateInfo{
		sType:       STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                        /*cb*/
		handleTypes: (ExternalMemoryHandleTypeFlags)(s.HandleTypes),   /*cb*/
	}
	return rval
}

// ExternalMemoryImageCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfoKHR.html
type ExternalMemoryImageCreateInfoKHR struct {
}

type _vkExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfoKHR

func (s *_vkExternalMemoryImageCreateInfoKHR) Goify() *ExternalMemoryImageCreateInfoKHR {
	rval := (*ExternalMemoryImageCreateInfoKHR)(s)
	return rval
}
func (s *ExternalMemoryImageCreateInfoKHR) Vulkanize() *_vkExternalMemoryImageCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExternalMemoryImageCreateInfoKHR)(s)
	return rval
}

// ExternalMemoryImageCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfoNV.html
type ExternalMemoryImageCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV
	PNext       unsafe.Pointer
	HandleTypes ExternalMemoryHandleTypeFlagsNV
}

type _vkExternalMemoryImageCreateInfoNV struct {
	sType       StructureType
	pNext       unsafe.Pointer
	handleTypes ExternalMemoryHandleTypeFlagsNV
}

func (s *_vkExternalMemoryImageCreateInfoNV) Goify() *ExternalMemoryImageCreateInfoNV {
	rval := &ExternalMemoryImageCreateInfoNV{
		PNext:       (unsafe.Pointer)(s.pNext),
		HandleTypes: (ExternalMemoryHandleTypeFlagsNV)(s.handleTypes),
	}
	return rval
}
func (s *ExternalMemoryImageCreateInfoNV) Vulkanize() *_vkExternalMemoryImageCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkExternalMemoryImageCreateInfoNV{
		sType:       STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                           /*cb*/
		handleTypes: (ExternalMemoryHandleTypeFlagsNV)(s.HandleTypes),    /*cb*/
	}
	return rval
}

// ExternalMemoryProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryProperties.html
type ExternalMemoryProperties struct {
	ExternalMemoryFeatures        ExternalMemoryFeatureFlags
	ExportFromImportedHandleTypes ExternalMemoryHandleTypeFlags
	CompatibleHandleTypes         ExternalMemoryHandleTypeFlags
}

type _vkExternalMemoryProperties = ExternalMemoryProperties

func (s *_vkExternalMemoryProperties) Goify() *ExternalMemoryProperties {
	rval := (*ExternalMemoryProperties)(s)
	return rval
}
func (s *ExternalMemoryProperties) Vulkanize() *_vkExternalMemoryProperties {
	if s == nil {
		return nil
	}
	rval := (*_vkExternalMemoryProperties)(s)
	return rval
}

// ExternalMemoryPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryPropertiesKHR.html
type ExternalMemoryPropertiesKHR struct {
}

type _vkExternalMemoryPropertiesKHR = ExternalMemoryPropertiesKHR

func (s *_vkExternalMemoryPropertiesKHR) Goify() *ExternalMemoryPropertiesKHR {
	rval := (*ExternalMemoryPropertiesKHR)(s)
	return rval
}
func (s *ExternalMemoryPropertiesKHR) Vulkanize() *_vkExternalMemoryPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExternalMemoryPropertiesKHR)(s)
	return rval
}

// ExternalSemaphoreProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreProperties.html
type ExternalSemaphoreProperties struct {
	// SType = STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES
	PNext                         unsafe.Pointer
	ExportFromImportedHandleTypes ExternalSemaphoreHandleTypeFlags
	CompatibleHandleTypes         ExternalSemaphoreHandleTypeFlags
	ExternalSemaphoreFeatures     ExternalSemaphoreFeatureFlags
}

// WARNING - struct ExternalSemaphoreProperties is returned only, which is not yet handled in the binding
type _vkExternalSemaphoreProperties struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	exportFromImportedHandleTypes ExternalSemaphoreHandleTypeFlags
	compatibleHandleTypes         ExternalSemaphoreHandleTypeFlags
	externalSemaphoreFeatures     ExternalSemaphoreFeatureFlags
}

func (s *_vkExternalSemaphoreProperties) Goify() *ExternalSemaphoreProperties {
	rval := &ExternalSemaphoreProperties{
		PNext:                         (unsafe.Pointer)(s.pNext),
		ExportFromImportedHandleTypes: (ExternalSemaphoreHandleTypeFlags)(s.exportFromImportedHandleTypes),
		CompatibleHandleTypes:         (ExternalSemaphoreHandleTypeFlags)(s.compatibleHandleTypes),
		ExternalSemaphoreFeatures:     (ExternalSemaphoreFeatureFlags)(s.externalSemaphoreFeatures),
	}
	return rval
}
func (s *ExternalSemaphoreProperties) Vulkanize() *_vkExternalSemaphoreProperties {
	if s == nil {
		return nil
	}
	rval := &_vkExternalSemaphoreProperties{
		sType:                         STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,                        /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                           /*cb*/
		exportFromImportedHandleTypes: (ExternalSemaphoreHandleTypeFlags)(s.ExportFromImportedHandleTypes), /*cb*/
		compatibleHandleTypes:         (ExternalSemaphoreHandleTypeFlags)(s.CompatibleHandleTypes),         /*cb*/
		externalSemaphoreFeatures:     (ExternalSemaphoreFeatureFlags)(s.ExternalSemaphoreFeatures),        /*cb*/
	}
	return rval
}

// ExternalSemaphorePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphorePropertiesKHR.html
type ExternalSemaphorePropertiesKHR struct {
}

type _vkExternalSemaphorePropertiesKHR = ExternalSemaphorePropertiesKHR

func (s *_vkExternalSemaphorePropertiesKHR) Goify() *ExternalSemaphorePropertiesKHR {
	rval := (*ExternalSemaphorePropertiesKHR)(s)
	return rval
}
func (s *ExternalSemaphorePropertiesKHR) Vulkanize() *_vkExternalSemaphorePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkExternalSemaphorePropertiesKHR)(s)
	return rval
}

// FenceCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceCreateInfo.html
type FenceCreateInfo struct {
	// SType = STRUCTURE_TYPE_FENCE_CREATE_INFO
	PNext unsafe.Pointer
	//  Fence creation flags;
	Flags FenceCreateFlags
}

type _vkFenceCreateInfo struct {
	sType StructureType
	pNext unsafe.Pointer
	flags FenceCreateFlags
}

func (s *_vkFenceCreateInfo) Goify() *FenceCreateInfo {
	rval := &FenceCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (FenceCreateFlags)(s.flags),
	}
	return rval
}
func (s *FenceCreateInfo) Vulkanize() *_vkFenceCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkFenceCreateInfo{
		sType: STRUCTURE_TYPE_FENCE_CREATE_INFO, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),        /*cb*/
		flags: (FenceCreateFlags)(s.Flags),      /*cb*/
	}
	return rval
}

// FenceGetFdInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetFdInfoKHR.html
type FenceGetFdInfoKHR struct {
	// SType = STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR
	PNext      unsafe.Pointer
	Fence      Fence
	HandleType ExternalFenceHandleTypeFlagBits
}

type _vkFenceGetFdInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	fence      Fence
	handleType ExternalFenceHandleTypeFlagBits
}

func (s *_vkFenceGetFdInfoKHR) Goify() *FenceGetFdInfoKHR {
	rval := &FenceGetFdInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		Fence:      (Fence)(s.fence),
		HandleType: (ExternalFenceHandleTypeFlagBits)(s.handleType),
	}
	return rval
}
func (s *FenceGetFdInfoKHR) Vulkanize() *_vkFenceGetFdInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkFenceGetFdInfoKHR{
		sType:      STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR,            /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                       /*cb*/
		fence:      (Fence)(s.Fence),                                /*cb*/
		handleType: (ExternalFenceHandleTypeFlagBits)(s.HandleType), /*cb*/
	}
	return rval
}

// FilterCubicImageViewImageFormatPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html
type FilterCubicImageViewImageFormatPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT
	PNext unsafe.Pointer
	//  The combinations of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT;
	FilterCubic bool
	//  The combination of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT and ReductionMode of Min or Max;
	FilterCubicMinmax bool
}

// WARNING - struct FilterCubicImageViewImageFormatPropertiesEXT is returned only, which is not yet handled in the binding
type _vkFilterCubicImageViewImageFormatPropertiesEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	filterCubic       Bool32
	filterCubicMinmax Bool32
}

func (s *_vkFilterCubicImageViewImageFormatPropertiesEXT) Goify() *FilterCubicImageViewImageFormatPropertiesEXT {
	rval := &FilterCubicImageViewImageFormatPropertiesEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		FilterCubic:       translatePublic_Bool32(s.filterCubic),       /*default*/
		FilterCubicMinmax: translatePublic_Bool32(s.filterCubicMinmax), /*default*/
	}
	return rval
}
func (s *FilterCubicImageViewImageFormatPropertiesEXT) Vulkanize() *_vkFilterCubicImageViewImageFormatPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkFilterCubicImageViewImageFormatPropertiesEXT{
		sType:             STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                          /*cb*/
		filterCubic:       translateInternal_Bool32(s.FilterCubic),                            /*default*/
		filterCubicMinmax: translateInternal_Bool32(s.FilterCubicMinmax),                      /*default*/
	}
	return rval
}

// FormatProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties.html
type FormatProperties struct {
	//  Format features in case of linear tiling;
	LinearTilingFeatures FormatFeatureFlags
	//  Format features in case of optimal tiling;
	OptimalTilingFeatures FormatFeatureFlags
	//  Format features supported by buffers;
	BufferFeatures FormatFeatureFlags
}

type _vkFormatProperties = FormatProperties

func (s *_vkFormatProperties) Goify() *FormatProperties {
	rval := (*FormatProperties)(s)
	return rval
}
func (s *FormatProperties) Vulkanize() *_vkFormatProperties {
	if s == nil {
		return nil
	}
	rval := (*_vkFormatProperties)(s)
	return rval
}

// FormatProperties2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties2.html
type FormatProperties2 struct {
	// SType = STRUCTURE_TYPE_FORMAT_PROPERTIES_2
	PNext            unsafe.Pointer
	FormatProperties FormatProperties
}

// WARNING - struct FormatProperties2 is returned only, which is not yet handled in the binding
type _vkFormatProperties2 struct {
	sType            StructureType
	pNext            unsafe.Pointer
	formatProperties _vkFormatProperties
}

func (s *_vkFormatProperties2) Goify() *FormatProperties2 {
	rval := &FormatProperties2{
		PNext:            (unsafe.Pointer)(s.pNext),
		FormatProperties: (FormatProperties)(s.formatProperties),
	}
	return rval
}
func (s *FormatProperties2) Vulkanize() *_vkFormatProperties2 {
	if s == nil {
		return nil
	}
	rval := &_vkFormatProperties2{
		sType:            STRUCTURE_TYPE_FORMAT_PROPERTIES_2,        /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                 /*cb*/
		formatProperties: (_vkFormatProperties)(s.FormatProperties), /*cb*/
	}
	return rval
}

// FormatProperties2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties2KHR.html
type FormatProperties2KHR struct {
}

type _vkFormatProperties2KHR = FormatProperties2KHR

func (s *_vkFormatProperties2KHR) Goify() *FormatProperties2KHR {
	rval := (*FormatProperties2KHR)(s)
	return rval
}
func (s *FormatProperties2KHR) Vulkanize() *_vkFormatProperties2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkFormatProperties2KHR)(s)
	return rval
}

// FormatProperties3KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties3KHR.html
type FormatProperties3KHR struct {
}

type _vkFormatProperties3KHR = FormatProperties3KHR

func (s *_vkFormatProperties3KHR) Goify() *FormatProperties3KHR {
	rval := (*FormatProperties3KHR)(s)
	return rval
}
func (s *FormatProperties3KHR) Vulkanize() *_vkFormatProperties3KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkFormatProperties3KHR)(s)
	return rval
}

// FragmentShadingRateAttachmentInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFragmentShadingRateAttachmentInfoKHR.html
type FragmentShadingRateAttachmentInfoKHR struct {
	// SType = STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR
	PNext                          unsafe.Pointer
	PFragmentShadingRateAttachment *AttachmentReference2
	ShadingRateAttachmentTexelSize Extent2D
}

type _vkFragmentShadingRateAttachmentInfoKHR struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	pFragmentShadingRateAttachment *_vkAttachmentReference2
	shadingRateAttachmentTexelSize _vkExtent2D
}

func (s *_vkFragmentShadingRateAttachmentInfoKHR) Goify() *FragmentShadingRateAttachmentInfoKHR {
	rval := &FragmentShadingRateAttachmentInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected pointer member pFragmentShadingRateAttachment in returned struct
		ShadingRateAttachmentTexelSize: (Extent2D)(s.shadingRateAttachmentTexelSize),
	}
	return rval
}
func (s *FragmentShadingRateAttachmentInfoKHR) Vulkanize() *_vkFragmentShadingRateAttachmentInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkFragmentShadingRateAttachmentInfoKHR{
		sType:                          STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                /*cb*/
		pFragmentShadingRateAttachment: (s.PFragmentShadingRateAttachment.Vulkanize()),           /*c rem*/
		shadingRateAttachmentTexelSize: (_vkExtent2D)(s.ShadingRateAttachmentTexelSize),          /*cb*/
	}
	return rval
}

// FrameBoundaryEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFrameBoundaryEXT.html
type FrameBoundaryEXT struct {
	// SType = STRUCTURE_TYPE_FRAME_BOUNDARY_EXT
	PNext   unsafe.Pointer
	Flags   FrameBoundaryFlagsEXT
	FrameID uint64
	// imageCount
	PImages []Image
	// bufferCount
	PBuffers []Buffer
	TagName  uint64
	TagSize  uintptr
	PTag     unsafe.Pointer
}

type _vkFrameBoundaryEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	flags       FrameBoundaryFlagsEXT
	frameID     uint64
	imageCount  uint32
	pImages     *Image
	bufferCount uint32
	pBuffers    *Buffer
	tagName     uint64
	tagSize     uintptr
	pTag        unsafe.Pointer
}

func (s *_vkFrameBoundaryEXT) Goify() *FrameBoundaryEXT {
	rval := &FrameBoundaryEXT{
		PNext:   (unsafe.Pointer)(s.pNext),
		Flags:   (FrameBoundaryFlagsEXT)(s.flags),
		FrameID: (uint64)(s.frameID),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pImages in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pBuffers in returned struct
		TagName: (uint64)(s.tagName),
		TagSize: (uintptr)(s.tagSize),
		PTag:    (unsafe.Pointer)(s.pTag),
	}
	return rval
}
func (s *FrameBoundaryEXT) Vulkanize() *_vkFrameBoundaryEXT {
	if s == nil {
		return nil
	}

	var psl_pImages *Image
	if len(s.PImages) > 0 {
		psl_pImages = &s.PImages[0]
	}

	var psl_pBuffers *Buffer
	if len(s.PBuffers) > 0 {
		psl_pBuffers = &s.PBuffers[0]
	}
	rval := &_vkFrameBoundaryEXT{
		sType:       STRUCTURE_TYPE_FRAME_BOUNDARY_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),         /*cb*/
		flags:       (FrameBoundaryFlagsEXT)(s.Flags),  /*cb*/
		frameID:     (uint64)(s.FrameID),               /*cb*/
		imageCount:  uint32(len(s.PImages)),            /*c6-a*/
		pImages:     psl_pImages,                       /*c rem*/
		bufferCount: uint32(len(s.PBuffers)),           /*c6-a*/
		pBuffers:    psl_pBuffers,                      /*c rem*/
		tagName:     (uint64)(s.TagName),               /*cb*/
		tagSize:     (uintptr)(s.TagSize),              /*cb*/
		pTag:        (unsafe.Pointer)(s.PTag),          /*cb*/
	}
	return rval
}

// FramebufferAttachmentImageInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentImageInfo.html
type FramebufferAttachmentImageInfo struct {
	// SType = STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO
	PNext unsafe.Pointer
	//  Image creation flags;
	Flags ImageCreateFlags
	//  Image usage flags;
	Usage      ImageUsageFlags
	Width      uint32
	Height     uint32
	LayerCount uint32
	// viewFormatCount
	PViewFormats []Format
}

type _vkFramebufferAttachmentImageInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           ImageCreateFlags
	usage           ImageUsageFlags
	width           uint32
	height          uint32
	layerCount      uint32
	viewFormatCount uint32
	pViewFormats    *Format
}

func (s *_vkFramebufferAttachmentImageInfo) Goify() *FramebufferAttachmentImageInfo {
	rval := &FramebufferAttachmentImageInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		Flags:      (ImageCreateFlags)(s.flags),
		Usage:      (ImageUsageFlags)(s.usage),
		Width:      (uint32)(s.width),
		Height:     (uint32)(s.height),
		LayerCount: (uint32)(s.layerCount),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pViewFormats in returned struct
	}
	return rval
}
func (s *FramebufferAttachmentImageInfo) Vulkanize() *_vkFramebufferAttachmentImageInfo {
	if s == nil {
		return nil
	}

	var psl_pViewFormats *Format
	if len(s.PViewFormats) > 0 {
		psl_pViewFormats = &s.PViewFormats[0]
	}
	rval := &_vkFramebufferAttachmentImageInfo{
		sType:           STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                        /*cb*/
		flags:           (ImageCreateFlags)(s.Flags),                      /*cb*/
		usage:           (ImageUsageFlags)(s.Usage),                       /*cb*/
		width:           (uint32)(s.Width),                                /*cb*/
		height:          (uint32)(s.Height),                               /*cb*/
		layerCount:      (uint32)(s.LayerCount),                           /*cb*/
		viewFormatCount: uint32(len(s.PViewFormats)),                      /*c6-a*/
		pViewFormats:    psl_pViewFormats,                                 /*c rem*/
	}
	return rval
}

// FramebufferAttachmentImageInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentImageInfoKHR.html
type FramebufferAttachmentImageInfoKHR struct {
}

type _vkFramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfoKHR

func (s *_vkFramebufferAttachmentImageInfoKHR) Goify() *FramebufferAttachmentImageInfoKHR {
	rval := (*FramebufferAttachmentImageInfoKHR)(s)
	return rval
}
func (s *FramebufferAttachmentImageInfoKHR) Vulkanize() *_vkFramebufferAttachmentImageInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkFramebufferAttachmentImageInfoKHR)(s)
	return rval
}

// FramebufferAttachmentsCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentsCreateInfo.html
type FramebufferAttachmentsCreateInfo struct {
	// SType = STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO
	PNext unsafe.Pointer
	// attachmentImageInfoCount
	PAttachmentImageInfos []FramebufferAttachmentImageInfo
}

type _vkFramebufferAttachmentsCreateInfo struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	attachmentImageInfoCount uint32
	pAttachmentImageInfos    *_vkFramebufferAttachmentImageInfo
}

func (s *_vkFramebufferAttachmentsCreateInfo) Goify() *FramebufferAttachmentsCreateInfo {
	rval := &FramebufferAttachmentsCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAttachmentImageInfos in returned struct
	}
	return rval
}
func (s *FramebufferAttachmentsCreateInfo) Vulkanize() *_vkFramebufferAttachmentsCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pAttachmentImageInfos *_vkFramebufferAttachmentImageInfo
	if len(s.PAttachmentImageInfos) > 0 {
		sl_pAttachmentImageInfos := make([]_vkFramebufferAttachmentImageInfo, len(s.PAttachmentImageInfos))
		for i, v := range s.PAttachmentImageInfos {
			sl_pAttachmentImageInfos[i] = *(v.Vulkanize())
		}
		psl_pAttachmentImageInfos = &sl_pAttachmentImageInfos[0]
	}
	rval := &_vkFramebufferAttachmentsCreateInfo{
		sType:                    STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                          /*cb*/
		attachmentImageInfoCount: uint32(len(s.PAttachmentImageInfos)),               /*c6-a*/
		pAttachmentImageInfos:    psl_pAttachmentImageInfos,                          /*c rem*/
	}
	return rval
}

// FramebufferAttachmentsCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentsCreateInfoKHR.html
type FramebufferAttachmentsCreateInfoKHR struct {
}

type _vkFramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfoKHR

func (s *_vkFramebufferAttachmentsCreateInfoKHR) Goify() *FramebufferAttachmentsCreateInfoKHR {
	rval := (*FramebufferAttachmentsCreateInfoKHR)(s)
	return rval
}
func (s *FramebufferAttachmentsCreateInfoKHR) Vulkanize() *_vkFramebufferAttachmentsCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkFramebufferAttachmentsCreateInfoKHR)(s)
	return rval
}

// FramebufferCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferCreateInfo.html
type FramebufferCreateInfo struct {
	// SType = STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
	PNext      unsafe.Pointer
	Flags      FramebufferCreateFlags
	RenderPass RenderPass
	// attachmentCount
	PAttachments []ImageView
	Width        uint32
	Height       uint32
	Layers       uint32
}

type _vkFramebufferCreateInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           FramebufferCreateFlags
	renderPass      RenderPass
	attachmentCount uint32
	pAttachments    *ImageView
	width           uint32
	height          uint32
	layers          uint32
}

func (s *_vkFramebufferCreateInfo) Goify() *FramebufferCreateInfo {
	rval := &FramebufferCreateInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		Flags:      (FramebufferCreateFlags)(s.flags),
		RenderPass: (RenderPass)(s.renderPass),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAttachments in returned struct
		Width:  (uint32)(s.width),
		Height: (uint32)(s.height),
		Layers: (uint32)(s.layers),
	}
	return rval
}
func (s *FramebufferCreateInfo) Vulkanize() *_vkFramebufferCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pAttachments *ImageView
	if len(s.PAttachments) > 0 {
		psl_pAttachments = &s.PAttachments[0]
	}
	rval := &_vkFramebufferCreateInfo{
		sType:           STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),              /*cb*/
		flags:           (FramebufferCreateFlags)(s.Flags),      /*cb*/
		renderPass:      (RenderPass)(s.RenderPass),             /*cb*/
		attachmentCount: uint32(len(s.PAttachments)),            /*c6-a*/
		pAttachments:    psl_pAttachments,                       /*c rem*/
		width:           (uint32)(s.Width),                      /*cb*/
		height:          (uint32)(s.Height),                     /*cb*/
		layers:          (uint32)(s.Layers),                     /*cb*/
	}
	return rval
}

// FramebufferMixedSamplesCombinationNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferMixedSamplesCombinationNV.html
type FramebufferMixedSamplesCombinationNV struct {
	// SType = STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV
	PNext                 unsafe.Pointer
	CoverageReductionMode CoverageReductionModeNV
	RasterizationSamples  SampleCountFlagBits
	DepthStencilSamples   SampleCountFlags
	ColorSamples          SampleCountFlags
}

// WARNING - struct FramebufferMixedSamplesCombinationNV is returned only, which is not yet handled in the binding
type _vkFramebufferMixedSamplesCombinationNV struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	coverageReductionMode CoverageReductionModeNV
	rasterizationSamples  SampleCountFlagBits
	depthStencilSamples   SampleCountFlags
	colorSamples          SampleCountFlags
}

func (s *_vkFramebufferMixedSamplesCombinationNV) Goify() *FramebufferMixedSamplesCombinationNV {
	rval := &FramebufferMixedSamplesCombinationNV{
		PNext:                 (unsafe.Pointer)(s.pNext),
		CoverageReductionMode: (CoverageReductionModeNV)(s.coverageReductionMode),
		RasterizationSamples:  (SampleCountFlagBits)(s.rasterizationSamples),
		DepthStencilSamples:   (SampleCountFlags)(s.depthStencilSamples),
		ColorSamples:          (SampleCountFlags)(s.colorSamples),
	}
	return rval
}
func (s *FramebufferMixedSamplesCombinationNV) Vulkanize() *_vkFramebufferMixedSamplesCombinationNV {
	if s == nil {
		return nil
	}
	rval := &_vkFramebufferMixedSamplesCombinationNV{
		sType:                 STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                               /*cb*/
		coverageReductionMode: (CoverageReductionModeNV)(s.CoverageReductionMode),      /*cb*/
		rasterizationSamples:  (SampleCountFlagBits)(s.RasterizationSamples),           /*cb*/
		depthStencilSamples:   (SampleCountFlags)(s.DepthStencilSamples),               /*cb*/
		colorSamples:          (SampleCountFlags)(s.ColorSamples),                      /*cb*/
	}
	return rval
}

// GeneratedCommandsInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsInfoNV.html
type GeneratedCommandsInfoNV struct {
	// SType = STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV
	PNext                  unsafe.Pointer
	PipelineBindPoint      PipelineBindPoint
	Pipeline               Pipeline
	IndirectCommandsLayout IndirectCommandsLayoutNV
	// streamCount
	PStreams             []IndirectCommandsStreamNV
	SequencesCount       uint32
	PreprocessBuffer     Buffer
	PreprocessOffset     DeviceSize
	PreprocessSize       DeviceSize
	SequencesCountBuffer Buffer
	SequencesCountOffset DeviceSize
	SequencesIndexBuffer Buffer
	SequencesIndexOffset DeviceSize
}

type _vkGeneratedCommandsInfoNV struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	pipelineBindPoint      PipelineBindPoint
	pipeline               Pipeline
	indirectCommandsLayout IndirectCommandsLayoutNV
	streamCount            uint32
	pStreams               *_vkIndirectCommandsStreamNV
	sequencesCount         uint32
	preprocessBuffer       Buffer
	preprocessOffset       DeviceSize
	preprocessSize         DeviceSize
	sequencesCountBuffer   Buffer
	sequencesCountOffset   DeviceSize
	sequencesIndexBuffer   Buffer
	sequencesIndexOffset   DeviceSize
}

func (s *_vkGeneratedCommandsInfoNV) Goify() *GeneratedCommandsInfoNV {
	rval := &GeneratedCommandsInfoNV{
		PNext:                  (unsafe.Pointer)(s.pNext),
		PipelineBindPoint:      (PipelineBindPoint)(s.pipelineBindPoint),
		Pipeline:               (Pipeline)(s.pipeline),
		IndirectCommandsLayout: (IndirectCommandsLayoutNV)(s.indirectCommandsLayout),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStreams in returned struct
		SequencesCount:       (uint32)(s.sequencesCount),
		PreprocessBuffer:     (Buffer)(s.preprocessBuffer),
		PreprocessOffset:     (DeviceSize)(s.preprocessOffset),
		PreprocessSize:       (DeviceSize)(s.preprocessSize),
		SequencesCountBuffer: (Buffer)(s.sequencesCountBuffer),
		SequencesCountOffset: (DeviceSize)(s.sequencesCountOffset),
		SequencesIndexBuffer: (Buffer)(s.sequencesIndexBuffer),
		SequencesIndexOffset: (DeviceSize)(s.sequencesIndexOffset),
	}
	return rval
}
func (s *GeneratedCommandsInfoNV) Vulkanize() *_vkGeneratedCommandsInfoNV {
	if s == nil {
		return nil
	}

	var psl_pStreams *_vkIndirectCommandsStreamNV
	if len(s.PStreams) > 0 {
		psl_pStreams = &s.PStreams[0]
	}
	rval := &_vkGeneratedCommandsInfoNV{
		sType:                  STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV,            /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                            /*cb*/
		pipelineBindPoint:      (PipelineBindPoint)(s.PipelineBindPoint),             /*cb*/
		pipeline:               (Pipeline)(s.Pipeline),                               /*cb*/
		indirectCommandsLayout: (IndirectCommandsLayoutNV)(s.IndirectCommandsLayout), /*cb*/
		streamCount:            uint32(len(s.PStreams)),                              /*c6-a*/
		pStreams:               psl_pStreams,                                         /*c rem*/
		sequencesCount:         (uint32)(s.SequencesCount),                           /*cb*/
		preprocessBuffer:       (Buffer)(s.PreprocessBuffer),                         /*cb*/
		preprocessOffset:       (DeviceSize)(s.PreprocessOffset),                     /*cb*/
		preprocessSize:         (DeviceSize)(s.PreprocessSize),                       /*cb*/
		sequencesCountBuffer:   (Buffer)(s.SequencesCountBuffer),                     /*cb*/
		sequencesCountOffset:   (DeviceSize)(s.SequencesCountOffset),                 /*cb*/
		sequencesIndexBuffer:   (Buffer)(s.SequencesIndexBuffer),                     /*cb*/
		sequencesIndexOffset:   (DeviceSize)(s.SequencesIndexOffset),                 /*cb*/
	}
	return rval
}

// GeneratedCommandsMemoryRequirementsInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html
type GeneratedCommandsMemoryRequirementsInfoNV struct {
	// SType = STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV
	PNext                  unsafe.Pointer
	PipelineBindPoint      PipelineBindPoint
	Pipeline               Pipeline
	IndirectCommandsLayout IndirectCommandsLayoutNV
	MaxSequencesCount      uint32
}

type _vkGeneratedCommandsMemoryRequirementsInfoNV struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	pipelineBindPoint      PipelineBindPoint
	pipeline               Pipeline
	indirectCommandsLayout IndirectCommandsLayoutNV
	maxSequencesCount      uint32
}

func (s *_vkGeneratedCommandsMemoryRequirementsInfoNV) Goify() *GeneratedCommandsMemoryRequirementsInfoNV {
	rval := &GeneratedCommandsMemoryRequirementsInfoNV{
		PNext:                  (unsafe.Pointer)(s.pNext),
		PipelineBindPoint:      (PipelineBindPoint)(s.pipelineBindPoint),
		Pipeline:               (Pipeline)(s.pipeline),
		IndirectCommandsLayout: (IndirectCommandsLayoutNV)(s.indirectCommandsLayout),
		MaxSequencesCount:      (uint32)(s.maxSequencesCount),
	}
	return rval
}
func (s *GeneratedCommandsMemoryRequirementsInfoNV) Vulkanize() *_vkGeneratedCommandsMemoryRequirementsInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkGeneratedCommandsMemoryRequirementsInfoNV{
		sType:                  STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                     /*cb*/
		pipelineBindPoint:      (PipelineBindPoint)(s.PipelineBindPoint),                      /*cb*/
		pipeline:               (Pipeline)(s.Pipeline),                                        /*cb*/
		indirectCommandsLayout: (IndirectCommandsLayoutNV)(s.IndirectCommandsLayout),          /*cb*/
		maxSequencesCount:      (uint32)(s.MaxSequencesCount),                                 /*cb*/
	}
	return rval
}

// GeometryAABBNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryAABBNV.html
type GeometryAABBNV struct {
	// SType = STRUCTURE_TYPE_GEOMETRY_AABB_NV
	PNext    unsafe.Pointer
	AabbData Buffer
	NumAABBs uint32
	//  Stride in bytes between AABBs;
	Stride uint32
	//  Offset in bytes of the first AABB in aabbData;
	Offset DeviceSize
}

type _vkGeometryAABBNV struct {
	sType    StructureType
	pNext    unsafe.Pointer
	aabbData Buffer
	numAABBs uint32
	stride   uint32
	offset   DeviceSize
}

func (s *_vkGeometryAABBNV) Goify() *GeometryAABBNV {
	rval := &GeometryAABBNV{
		PNext:    (unsafe.Pointer)(s.pNext),
		AabbData: (Buffer)(s.aabbData),
		NumAABBs: (uint32)(s.numAABBs),
		Stride:   (uint32)(s.stride),
		Offset:   (DeviceSize)(s.offset),
	}
	return rval
}
func (s *GeometryAABBNV) Vulkanize() *_vkGeometryAABBNV {
	if s == nil {
		return nil
	}
	rval := &_vkGeometryAABBNV{
		sType:    STRUCTURE_TYPE_GEOMETRY_AABB_NV, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),       /*cb*/
		aabbData: (Buffer)(s.AabbData),            /*cb*/
		numAABBs: (uint32)(s.NumAABBs),            /*cb*/
		stride:   (uint32)(s.Stride),              /*cb*/
		offset:   (DeviceSize)(s.Offset),          /*cb*/
	}
	return rval
}

// GeometryDataNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryDataNV.html
type GeometryDataNV struct {
	Triangles GeometryTrianglesNV
	Aabbs     GeometryAABBNV
}

type _vkGeometryDataNV struct {
	triangles _vkGeometryTrianglesNV
	aabbs     _vkGeometryAABBNV
}

func (s *_vkGeometryDataNV) Goify() *GeometryDataNV {
	rval := &GeometryDataNV{
		Triangles: *(s.triangles.Goify()),
		Aabbs:     *(s.aabbs.Goify()),
	}
	return rval
}
func (s *GeometryDataNV) Vulkanize() *_vkGeometryDataNV {
	if s == nil {
		return nil
	}
	rval := &_vkGeometryDataNV{
		triangles: *(s.Triangles.Vulkanize()), /*c3*/
		aabbs:     *(s.Aabbs.Vulkanize()),     /*c3*/
	}
	return rval
}

// GeometryNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryNV.html
type GeometryNV struct {
	// SType = STRUCTURE_TYPE_GEOMETRY_NV
	PNext        unsafe.Pointer
	GeometryType GeometryTypeKHR
	Geometry     GeometryDataNV
	Flags        GeometryFlagsKHR
}

type _vkGeometryNV struct {
	sType        StructureType
	pNext        unsafe.Pointer
	geometryType GeometryTypeKHR
	geometry     _vkGeometryDataNV
	flags        GeometryFlagsKHR
}

func (s *_vkGeometryNV) Goify() *GeometryNV {
	rval := &GeometryNV{
		PNext:        (unsafe.Pointer)(s.pNext),
		GeometryType: (GeometryTypeKHR)(s.geometryType),
		Geometry:     *(s.geometry.Goify()),
		Flags:        (GeometryFlagsKHR)(s.flags),
	}
	return rval
}
func (s *GeometryNV) Vulkanize() *_vkGeometryNV {
	if s == nil {
		return nil
	}
	rval := &_vkGeometryNV{
		sType:        STRUCTURE_TYPE_GEOMETRY_NV,        /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),         /*cb*/
		geometryType: (GeometryTypeKHR)(s.GeometryType), /*cb*/
		geometry:     *(s.Geometry.Vulkanize()),         /*c3*/
		flags:        (GeometryFlagsKHR)(s.Flags),       /*cb*/
	}
	return rval
}

// GeometryTrianglesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryTrianglesNV.html
type GeometryTrianglesNV struct {
	// SType = STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV
	PNext        unsafe.Pointer
	VertexData   Buffer
	VertexOffset DeviceSize
	VertexCount  uint32
	VertexStride DeviceSize
	VertexFormat Format
	IndexData    Buffer
	IndexOffset  DeviceSize
	IndexCount   uint32
	IndexType    IndexType
	//  Optional reference to array of floats representing a 3x4 row major affine transformation matrix.;
	TransformData   Buffer
	TransformOffset DeviceSize
}

type _vkGeometryTrianglesNV struct {
	sType           StructureType
	pNext           unsafe.Pointer
	vertexData      Buffer
	vertexOffset    DeviceSize
	vertexCount     uint32
	vertexStride    DeviceSize
	vertexFormat    Format
	indexData       Buffer
	indexOffset     DeviceSize
	indexCount      uint32
	indexType       IndexType
	transformData   Buffer
	transformOffset DeviceSize
}

func (s *_vkGeometryTrianglesNV) Goify() *GeometryTrianglesNV {
	rval := &GeometryTrianglesNV{
		PNext:           (unsafe.Pointer)(s.pNext),
		VertexData:      (Buffer)(s.vertexData),
		VertexOffset:    (DeviceSize)(s.vertexOffset),
		VertexCount:     (uint32)(s.vertexCount),
		VertexStride:    (DeviceSize)(s.vertexStride),
		VertexFormat:    (Format)(s.vertexFormat),
		IndexData:       (Buffer)(s.indexData),
		IndexOffset:     (DeviceSize)(s.indexOffset),
		IndexCount:      (uint32)(s.indexCount),
		IndexType:       (IndexType)(s.indexType),
		TransformData:   (Buffer)(s.transformData),
		TransformOffset: (DeviceSize)(s.transformOffset),
	}
	return rval
}
func (s *GeometryTrianglesNV) Vulkanize() *_vkGeometryTrianglesNV {
	if s == nil {
		return nil
	}
	rval := &_vkGeometryTrianglesNV{
		sType:           STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),            /*cb*/
		vertexData:      (Buffer)(s.VertexData),               /*cb*/
		vertexOffset:    (DeviceSize)(s.VertexOffset),         /*cb*/
		vertexCount:     (uint32)(s.VertexCount),              /*cb*/
		vertexStride:    (DeviceSize)(s.VertexStride),         /*cb*/
		vertexFormat:    (Format)(s.VertexFormat),             /*cb*/
		indexData:       (Buffer)(s.IndexData),                /*cb*/
		indexOffset:     (DeviceSize)(s.IndexOffset),          /*cb*/
		indexCount:      (uint32)(s.IndexCount),               /*cb*/
		indexType:       (IndexType)(s.IndexType),             /*cb*/
		transformData:   (Buffer)(s.TransformData),            /*cb*/
		transformOffset: (DeviceSize)(s.TransformOffset),      /*cb*/
	}
	return rval
}

// GetLatencyMarkerInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGetLatencyMarkerInfoNV.html
type GetLatencyMarkerInfoNV struct {
	// SType = STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV
	PNext    unsafe.Pointer
	PTimings *LatencyTimingsFrameReportNV
}

type _vkGetLatencyMarkerInfoNV struct {
	sType    StructureType
	pNext    unsafe.Pointer
	pTimings *_vkLatencyTimingsFrameReportNV
}

func (s *_vkGetLatencyMarkerInfoNV) Goify() *GetLatencyMarkerInfoNV {
	rval := &GetLatencyMarkerInfoNV{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected pointer member pTimings in returned struct
	}
	return rval
}
func (s *GetLatencyMarkerInfoNV) Vulkanize() *_vkGetLatencyMarkerInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkGetLatencyMarkerInfoNV{
		sType:    STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                 /*cb*/
		pTimings: (s.PTimings.Vulkanize()),                  /*c rem*/
	}
	return rval
}

// GraphicsPipelineCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineCreateInfo.html
type GraphicsPipelineCreateInfo struct {
	// SType = STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
	PNext unsafe.Pointer
	//  Pipeline creation flags;
	Flags PipelineCreateFlags
	// stageCount
	//  One entry for each active shader stage;
	PStages             []PipelineShaderStageCreateInfo
	PVertexInputState   *PipelineVertexInputStateCreateInfo
	PInputAssemblyState *PipelineInputAssemblyStateCreateInfo
	PTessellationState  *PipelineTessellationStateCreateInfo
	PViewportState      *PipelineViewportStateCreateInfo
	PRasterizationState *PipelineRasterizationStateCreateInfo
	PMultisampleState   *PipelineMultisampleStateCreateInfo
	PDepthStencilState  *PipelineDepthStencilStateCreateInfo
	PColorBlendState    *PipelineColorBlendStateCreateInfo
	PDynamicState       *PipelineDynamicStateCreateInfo
	//  Interface layout of the pipeline;
	Layout     PipelineLayout
	RenderPass RenderPass
	Subpass    uint32
	//  If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of;
	BasePipelineHandle Pipeline
	//  If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of;
	BasePipelineIndex int32
}

type _vkGraphicsPipelineCreateInfo struct {
	sType               StructureType
	pNext               unsafe.Pointer
	flags               PipelineCreateFlags
	stageCount          uint32
	pStages             *_vkPipelineShaderStageCreateInfo
	pVertexInputState   *_vkPipelineVertexInputStateCreateInfo
	pInputAssemblyState *_vkPipelineInputAssemblyStateCreateInfo
	pTessellationState  *_vkPipelineTessellationStateCreateInfo
	pViewportState      *_vkPipelineViewportStateCreateInfo
	pRasterizationState *_vkPipelineRasterizationStateCreateInfo
	pMultisampleState   *_vkPipelineMultisampleStateCreateInfo
	pDepthStencilState  *_vkPipelineDepthStencilStateCreateInfo
	pColorBlendState    *_vkPipelineColorBlendStateCreateInfo
	pDynamicState       *_vkPipelineDynamicStateCreateInfo
	layout              PipelineLayout
	renderPass          RenderPass
	subpass             uint32
	basePipelineHandle  Pipeline
	basePipelineIndex   int32
}

func (s *_vkGraphicsPipelineCreateInfo) Goify() *GraphicsPipelineCreateInfo {
	rval := &GraphicsPipelineCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PipelineCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStages in returned struct
		// Unexpected pointer member pVertexInputState in returned struct
		// Unexpected pointer member pInputAssemblyState in returned struct
		// Unexpected pointer member pTessellationState in returned struct
		// Unexpected pointer member pViewportState in returned struct
		// Unexpected pointer member pRasterizationState in returned struct
		// Unexpected pointer member pMultisampleState in returned struct
		// Unexpected pointer member pDepthStencilState in returned struct
		// Unexpected pointer member pColorBlendState in returned struct
		// Unexpected pointer member pDynamicState in returned struct
		Layout:             (PipelineLayout)(s.layout),
		RenderPass:         (RenderPass)(s.renderPass),
		Subpass:            (uint32)(s.subpass),
		BasePipelineHandle: (Pipeline)(s.basePipelineHandle),
		BasePipelineIndex:  (int32)(s.basePipelineIndex),
	}
	return rval
}
func (s *GraphicsPipelineCreateInfo) Vulkanize() *_vkGraphicsPipelineCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pStages *_vkPipelineShaderStageCreateInfo
	if len(s.PStages) > 0 {
		sl_pStages := make([]_vkPipelineShaderStageCreateInfo, len(s.PStages))
		for i, v := range s.PStages {
			sl_pStages[i] = *(v.Vulkanize())
		}
		psl_pStages = &sl_pStages[0]
	}
	rval := &_vkGraphicsPipelineCreateInfo{
		sType:               STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                    /*cb*/
		flags:               (PipelineCreateFlags)(s.Flags),               /*cb*/
		stageCount:          uint32(len(s.PStages)),                       /*c6-a*/
		pStages:             psl_pStages,                                  /*c rem*/
		pVertexInputState:   (s.PVertexInputState.Vulkanize()),            /*c rem*/
		pInputAssemblyState: (s.PInputAssemblyState.Vulkanize()),          /*c rem*/
		pTessellationState:  (s.PTessellationState.Vulkanize()),           /*c rem*/
		pViewportState:      (s.PViewportState.Vulkanize()),               /*c rem*/
		pRasterizationState: (s.PRasterizationState.Vulkanize()),          /*c rem*/
		pMultisampleState:   (s.PMultisampleState.Vulkanize()),            /*c rem*/
		pDepthStencilState:  (s.PDepthStencilState.Vulkanize()),           /*c rem*/
		pColorBlendState:    (s.PColorBlendState.Vulkanize()),             /*c rem*/
		pDynamicState:       (s.PDynamicState.Vulkanize()),                /*c rem*/
		layout:              (PipelineLayout)(s.Layout),                   /*cb*/
		renderPass:          (RenderPass)(s.RenderPass),                   /*cb*/
		subpass:             (uint32)(s.Subpass),                          /*cb*/
		basePipelineHandle:  (Pipeline)(s.BasePipelineHandle),             /*cb*/
		basePipelineIndex:   (int32)(s.BasePipelineIndex),                 /*cb*/
	}
	return rval
}

// GraphicsPipelineLibraryCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineLibraryCreateInfoEXT.html
type GraphicsPipelineLibraryCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT
	PNext unsafe.Pointer
	Flags GraphicsPipelineLibraryFlagsEXT
}

type _vkGraphicsPipelineLibraryCreateInfoEXT struct {
	sType StructureType
	pNext unsafe.Pointer
	flags GraphicsPipelineLibraryFlagsEXT
}

func (s *_vkGraphicsPipelineLibraryCreateInfoEXT) Goify() *GraphicsPipelineLibraryCreateInfoEXT {
	rval := &GraphicsPipelineLibraryCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (GraphicsPipelineLibraryFlagsEXT)(s.flags),
	}
	return rval
}
func (s *GraphicsPipelineLibraryCreateInfoEXT) Vulkanize() *_vkGraphicsPipelineLibraryCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkGraphicsPipelineLibraryCreateInfoEXT{
		sType: STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                /*cb*/
		flags: (GraphicsPipelineLibraryFlagsEXT)(s.Flags),               /*cb*/
	}
	return rval
}

// GraphicsPipelineShaderGroupsCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html
type GraphicsPipelineShaderGroupsCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV
	PNext unsafe.Pointer
	// groupCount
	PGroups []GraphicsShaderGroupCreateInfoNV
	// pipelineCount
	PPipelines []Pipeline
}

type _vkGraphicsPipelineShaderGroupsCreateInfoNV struct {
	sType         StructureType
	pNext         unsafe.Pointer
	groupCount    uint32
	pGroups       *_vkGraphicsShaderGroupCreateInfoNV
	pipelineCount uint32
	pPipelines    *Pipeline
}

func (s *_vkGraphicsPipelineShaderGroupsCreateInfoNV) Goify() *GraphicsPipelineShaderGroupsCreateInfoNV {
	rval := &GraphicsPipelineShaderGroupsCreateInfoNV{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pGroups in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPipelines in returned struct
	}
	return rval
}
func (s *GraphicsPipelineShaderGroupsCreateInfoNV) Vulkanize() *_vkGraphicsPipelineShaderGroupsCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pGroups *_vkGraphicsShaderGroupCreateInfoNV
	if len(s.PGroups) > 0 {
		sl_pGroups := make([]_vkGraphicsShaderGroupCreateInfoNV, len(s.PGroups))
		for i, v := range s.PGroups {
			sl_pGroups[i] = *(v.Vulkanize())
		}
		psl_pGroups = &sl_pGroups[0]
	}

	var psl_pPipelines *Pipeline
	if len(s.PPipelines) > 0 {
		psl_pPipelines = &s.PPipelines[0]
	}
	rval := &_vkGraphicsPipelineShaderGroupsCreateInfoNV{
		sType:         STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                     /*cb*/
		groupCount:    uint32(len(s.PGroups)),                                        /*c6-a*/
		pGroups:       psl_pGroups,                                                   /*c rem*/
		pipelineCount: uint32(len(s.PPipelines)),                                     /*c6-a*/
		pPipelines:    psl_pPipelines,                                                /*c rem*/
	}
	return rval
}

// GraphicsShaderGroupCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html
type GraphicsShaderGroupCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV
	PNext unsafe.Pointer
	// stageCount
	PStages            []PipelineShaderStageCreateInfo
	PVertexInputState  *PipelineVertexInputStateCreateInfo
	PTessellationState *PipelineTessellationStateCreateInfo
}

type _vkGraphicsShaderGroupCreateInfoNV struct {
	sType              StructureType
	pNext              unsafe.Pointer
	stageCount         uint32
	pStages            *_vkPipelineShaderStageCreateInfo
	pVertexInputState  *_vkPipelineVertexInputStateCreateInfo
	pTessellationState *_vkPipelineTessellationStateCreateInfo
}

func (s *_vkGraphicsShaderGroupCreateInfoNV) Goify() *GraphicsShaderGroupCreateInfoNV {
	rval := &GraphicsShaderGroupCreateInfoNV{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStages in returned struct
		// Unexpected pointer member pVertexInputState in returned struct
		// Unexpected pointer member pTessellationState in returned struct
	}
	return rval
}
func (s *GraphicsShaderGroupCreateInfoNV) Vulkanize() *_vkGraphicsShaderGroupCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pStages *_vkPipelineShaderStageCreateInfo
	if len(s.PStages) > 0 {
		sl_pStages := make([]_vkPipelineShaderStageCreateInfo, len(s.PStages))
		for i, v := range s.PStages {
			sl_pStages[i] = *(v.Vulkanize())
		}
		psl_pStages = &sl_pStages[0]
	}
	rval := &_vkGraphicsShaderGroupCreateInfoNV{
		sType:              STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                           /*cb*/
		stageCount:         uint32(len(s.PStages)),                              /*c6-a*/
		pStages:            psl_pStages,                                         /*c rem*/
		pVertexInputState:  (s.PVertexInputState.Vulkanize()),                   /*c rem*/
		pTessellationState: (s.PTessellationState.Vulkanize()),                  /*c rem*/
	}
	return rval
}

// HdrMetadataEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHdrMetadataEXT.html
type HdrMetadataEXT struct {
	// SType = STRUCTURE_TYPE_HDR_METADATA_EXT
	PNext unsafe.Pointer
	//  Display primary's Red;
	DisplayPrimaryRed XYColorEXT
	//  Display primary's Green;
	DisplayPrimaryGreen XYColorEXT
	//  Display primary's Blue;
	DisplayPrimaryBlue XYColorEXT
	//  Display primary's Blue;
	WhitePoint XYColorEXT
	//  Display maximum luminance;
	MaxLuminance float32
	//  Display minimum luminance;
	MinLuminance float32
	//  Content maximum luminance;
	MaxContentLightLevel      float32
	MaxFrameAverageLightLevel float32
}

type _vkHdrMetadataEXT struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	displayPrimaryRed         _vkXYColorEXT
	displayPrimaryGreen       _vkXYColorEXT
	displayPrimaryBlue        _vkXYColorEXT
	whitePoint                _vkXYColorEXT
	maxLuminance              float32
	minLuminance              float32
	maxContentLightLevel      float32
	maxFrameAverageLightLevel float32
}

func (s *_vkHdrMetadataEXT) Goify() *HdrMetadataEXT {
	rval := &HdrMetadataEXT{
		PNext:                     (unsafe.Pointer)(s.pNext),
		DisplayPrimaryRed:         (XYColorEXT)(s.displayPrimaryRed),
		DisplayPrimaryGreen:       (XYColorEXT)(s.displayPrimaryGreen),
		DisplayPrimaryBlue:        (XYColorEXT)(s.displayPrimaryBlue),
		WhitePoint:                (XYColorEXT)(s.whitePoint),
		MaxLuminance:              (float32)(s.maxLuminance),
		MinLuminance:              (float32)(s.minLuminance),
		MaxContentLightLevel:      (float32)(s.maxContentLightLevel),
		MaxFrameAverageLightLevel: (float32)(s.maxFrameAverageLightLevel),
	}
	return rval
}
func (s *HdrMetadataEXT) Vulkanize() *_vkHdrMetadataEXT {
	if s == nil {
		return nil
	}
	rval := &_vkHdrMetadataEXT{
		sType:                     STRUCTURE_TYPE_HDR_METADATA_EXT,        /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),              /*cb*/
		displayPrimaryRed:         (_vkXYColorEXT)(s.DisplayPrimaryRed),   /*cb*/
		displayPrimaryGreen:       (_vkXYColorEXT)(s.DisplayPrimaryGreen), /*cb*/
		displayPrimaryBlue:        (_vkXYColorEXT)(s.DisplayPrimaryBlue),  /*cb*/
		whitePoint:                (_vkXYColorEXT)(s.WhitePoint),          /*cb*/
		maxLuminance:              (float32)(s.MaxLuminance),              /*cb*/
		minLuminance:              (float32)(s.MinLuminance),              /*cb*/
		maxContentLightLevel:      (float32)(s.MaxContentLightLevel),      /*cb*/
		maxFrameAverageLightLevel: (float32)(s.MaxFrameAverageLightLevel), /*cb*/
	}
	return rval
}

// HeadlessSurfaceCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateInfoEXT.html
type HeadlessSurfaceCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT
	PNext unsafe.Pointer
	Flags HeadlessSurfaceCreateFlagsEXT
}

type _vkHeadlessSurfaceCreateInfoEXT struct {
	sType StructureType
	pNext unsafe.Pointer
	flags HeadlessSurfaceCreateFlagsEXT
}

func (s *_vkHeadlessSurfaceCreateInfoEXT) Goify() *HeadlessSurfaceCreateInfoEXT {
	rval := &HeadlessSurfaceCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (HeadlessSurfaceCreateFlagsEXT)(s.flags),
	}
	return rval
}
func (s *HeadlessSurfaceCreateInfoEXT) Vulkanize() *_vkHeadlessSurfaceCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkHeadlessSurfaceCreateInfoEXT{
		sType: STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                       /*cb*/
		flags: (HeadlessSurfaceCreateFlagsEXT)(s.Flags),        /*cb*/
	}
	return rval
}

// HostImageCopyDevicePerformanceQueryEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHostImageCopyDevicePerformanceQueryEXT.html
type HostImageCopyDevicePerformanceQueryEXT struct {
	// SType = STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT
	PNext unsafe.Pointer
	//  Specifies if device access is optimal;
	OptimalDeviceAccess bool
	//  Specifies if memory layout is identical;
	IdenticalMemoryLayout bool
}

// WARNING - struct HostImageCopyDevicePerformanceQueryEXT is returned only, which is not yet handled in the binding
type _vkHostImageCopyDevicePerformanceQueryEXT struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	optimalDeviceAccess   Bool32
	identicalMemoryLayout Bool32
}

func (s *_vkHostImageCopyDevicePerformanceQueryEXT) Goify() *HostImageCopyDevicePerformanceQueryEXT {
	rval := &HostImageCopyDevicePerformanceQueryEXT{
		PNext:                 (unsafe.Pointer)(s.pNext),
		OptimalDeviceAccess:   translatePublic_Bool32(s.optimalDeviceAccess),   /*default*/
		IdenticalMemoryLayout: translatePublic_Bool32(s.identicalMemoryLayout), /*default*/
	}
	return rval
}
func (s *HostImageCopyDevicePerformanceQueryEXT) Vulkanize() *_vkHostImageCopyDevicePerformanceQueryEXT {
	if s == nil {
		return nil
	}
	rval := &_vkHostImageCopyDevicePerformanceQueryEXT{
		sType:                 STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                   /*cb*/
		optimalDeviceAccess:   translateInternal_Bool32(s.OptimalDeviceAccess),             /*default*/
		identicalMemoryLayout: translateInternal_Bool32(s.IdenticalMemoryLayout),           /*default*/
	}
	return rval
}

// HostImageLayoutTransitionInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHostImageLayoutTransitionInfoEXT.html
type HostImageLayoutTransitionInfoEXT struct {
	// SType = STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT
	PNext            unsafe.Pointer
	Image            Image
	OldLayout        ImageLayout
	NewLayout        ImageLayout
	SubresourceRange ImageSubresourceRange
}

type _vkHostImageLayoutTransitionInfoEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	image            Image
	oldLayout        ImageLayout
	newLayout        ImageLayout
	subresourceRange _vkImageSubresourceRange
}

func (s *_vkHostImageLayoutTransitionInfoEXT) Goify() *HostImageLayoutTransitionInfoEXT {
	rval := &HostImageLayoutTransitionInfoEXT{
		PNext:            (unsafe.Pointer)(s.pNext),
		Image:            (Image)(s.image),
		OldLayout:        (ImageLayout)(s.oldLayout),
		NewLayout:        (ImageLayout)(s.newLayout),
		SubresourceRange: (ImageSubresourceRange)(s.subresourceRange),
	}
	return rval
}
func (s *HostImageLayoutTransitionInfoEXT) Vulkanize() *_vkHostImageLayoutTransitionInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkHostImageLayoutTransitionInfoEXT{
		sType:            STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                            /*cb*/
		image:            (Image)(s.Image),                                     /*cb*/
		oldLayout:        (ImageLayout)(s.OldLayout),                           /*cb*/
		newLayout:        (ImageLayout)(s.NewLayout),                           /*cb*/
		subresourceRange: (_vkImageSubresourceRange)(s.SubresourceRange),       /*cb*/
	}
	return rval
}

// ImageBlit: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit.html
type ImageBlit struct {
	SrcSubresource ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	SrcOffsets     [2]Offset3D
	DstSubresource ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	DstOffsets [2]Offset3D
}

type _vkImageBlit struct {
	srcSubresource _vkImageSubresourceLayers
	srcOffsets     [2]_vkOffset3D
	dstSubresource _vkImageSubresourceLayers
	dstOffsets     [2]_vkOffset3D
}

func (s *_vkImageBlit) Goify() *ImageBlit {
	rval := &ImageBlit{
		SrcSubresource: (ImageSubresourceLayers)(s.srcSubresource),
		SrcOffsets:     ([2]Offset3D)(s.srcOffsets),
		DstSubresource: (ImageSubresourceLayers)(s.dstSubresource),
		DstOffsets:     ([2]Offset3D)(s.dstOffsets),
	}
	return rval
}
func (s *ImageBlit) Vulkanize() *_vkImageBlit {
	if s == nil {
		return nil
	}
	rval := &_vkImageBlit{
		srcSubresource: (_vkImageSubresourceLayers)(s.SrcSubresource), /*cb*/
		srcOffsets:     ([2]_vkOffset3D)(s.SrcOffsets),                /*cb*/
		dstSubresource: (_vkImageSubresourceLayers)(s.DstSubresource), /*cb*/
		dstOffsets:     ([2]_vkOffset3D)(s.DstOffsets),                /*cb*/
	}
	return rval
}

// ImageBlit2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit2.html
type ImageBlit2 struct {
	// SType = STRUCTURE_TYPE_IMAGE_BLIT_2
	PNext          unsafe.Pointer
	SrcSubresource ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	SrcOffsets     [2]Offset3D
	DstSubresource ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	DstOffsets [2]Offset3D
}

type _vkImageBlit2 struct {
	sType          StructureType
	pNext          unsafe.Pointer
	srcSubresource _vkImageSubresourceLayers
	srcOffsets     [2]_vkOffset3D
	dstSubresource _vkImageSubresourceLayers
	dstOffsets     [2]_vkOffset3D
}

func (s *_vkImageBlit2) Goify() *ImageBlit2 {
	rval := &ImageBlit2{
		PNext:          (unsafe.Pointer)(s.pNext),
		SrcSubresource: (ImageSubresourceLayers)(s.srcSubresource),
		SrcOffsets:     ([2]Offset3D)(s.srcOffsets),
		DstSubresource: (ImageSubresourceLayers)(s.dstSubresource),
		DstOffsets:     ([2]Offset3D)(s.dstOffsets),
	}
	return rval
}
func (s *ImageBlit2) Vulkanize() *_vkImageBlit2 {
	if s == nil {
		return nil
	}
	rval := &_vkImageBlit2{
		sType:          STRUCTURE_TYPE_IMAGE_BLIT_2,                   /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                     /*cb*/
		srcSubresource: (_vkImageSubresourceLayers)(s.SrcSubresource), /*cb*/
		srcOffsets:     ([2]_vkOffset3D)(s.SrcOffsets),                /*cb*/
		dstSubresource: (_vkImageSubresourceLayers)(s.DstSubresource), /*cb*/
		dstOffsets:     ([2]_vkOffset3D)(s.DstOffsets),                /*cb*/
	}
	return rval
}

// ImageBlit2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit2KHR.html
type ImageBlit2KHR struct {
}

type _vkImageBlit2KHR = ImageBlit2KHR

func (s *_vkImageBlit2KHR) Goify() *ImageBlit2KHR {
	rval := (*ImageBlit2KHR)(s)
	return rval
}
func (s *ImageBlit2KHR) Vulkanize() *_vkImageBlit2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImageBlit2KHR)(s)
	return rval
}

// ImageCaptureDescriptorDataInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCaptureDescriptorDataInfoEXT.html
type ImageCaptureDescriptorDataInfoEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
	PNext unsafe.Pointer
	Image Image
}

type _vkImageCaptureDescriptorDataInfoEXT struct {
	sType StructureType
	pNext unsafe.Pointer
	image Image
}

func (s *_vkImageCaptureDescriptorDataInfoEXT) Goify() *ImageCaptureDescriptorDataInfoEXT {
	rval := &ImageCaptureDescriptorDataInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		Image: (Image)(s.image),
	}
	return rval
}
func (s *ImageCaptureDescriptorDataInfoEXT) Vulkanize() *_vkImageCaptureDescriptorDataInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkImageCaptureDescriptorDataInfoEXT{
		sType: STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                             /*cb*/
		image: (Image)(s.Image),                                      /*cb*/
	}
	return rval
}

// ImageCompressionControlEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionControlEXT.html
type ImageCompressionControlEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT
	PNext unsafe.Pointer
	Flags ImageCompressionFlagsEXT
	// compressionControlPlaneCount
	PFixedRateFlags []ImageCompressionFixedRateFlagsEXT
}

type _vkImageCompressionControlEXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	flags                        ImageCompressionFlagsEXT
	compressionControlPlaneCount uint32
	pFixedRateFlags              *ImageCompressionFixedRateFlagsEXT
}

func (s *_vkImageCompressionControlEXT) Goify() *ImageCompressionControlEXT {
	rval := &ImageCompressionControlEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (ImageCompressionFlagsEXT)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pFixedRateFlags in returned struct
	}
	return rval
}
func (s *ImageCompressionControlEXT) Vulkanize() *_vkImageCompressionControlEXT {
	if s == nil {
		return nil
	}

	var psl_pFixedRateFlags *ImageCompressionFixedRateFlagsEXT
	if len(s.PFixedRateFlags) > 0 {
		psl_pFixedRateFlags = &s.PFixedRateFlags[0]
	}
	rval := &_vkImageCompressionControlEXT{
		sType:                        STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                    /*cb*/
		flags:                        (ImageCompressionFlagsEXT)(s.Flags),          /*cb*/
		compressionControlPlaneCount: uint32(len(s.PFixedRateFlags)),               /*c6-a*/
		pFixedRateFlags:              psl_pFixedRateFlags,                          /*c rem*/
	}
	return rval
}

// ImageCompressionPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionPropertiesEXT.html
type ImageCompressionPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT
	PNext                          unsafe.Pointer
	ImageCompressionFlags          ImageCompressionFlagsEXT
	ImageCompressionFixedRateFlags ImageCompressionFixedRateFlagsEXT
}

// WARNING - struct ImageCompressionPropertiesEXT is returned only, which is not yet handled in the binding
type _vkImageCompressionPropertiesEXT struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	imageCompressionFlags          ImageCompressionFlagsEXT
	imageCompressionFixedRateFlags ImageCompressionFixedRateFlagsEXT
}

func (s *_vkImageCompressionPropertiesEXT) Goify() *ImageCompressionPropertiesEXT {
	rval := &ImageCompressionPropertiesEXT{
		PNext:                          (unsafe.Pointer)(s.pNext),
		ImageCompressionFlags:          (ImageCompressionFlagsEXT)(s.imageCompressionFlags),
		ImageCompressionFixedRateFlags: (ImageCompressionFixedRateFlagsEXT)(s.imageCompressionFixedRateFlags),
	}
	return rval
}
func (s *ImageCompressionPropertiesEXT) Vulkanize() *_vkImageCompressionPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkImageCompressionPropertiesEXT{
		sType:                          STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT,                       /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                             /*cb*/
		imageCompressionFlags:          (ImageCompressionFlagsEXT)(s.ImageCompressionFlags),                   /*cb*/
		imageCompressionFixedRateFlags: (ImageCompressionFixedRateFlagsEXT)(s.ImageCompressionFixedRateFlags), /*cb*/
	}
	return rval
}

// ImageCopy: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy.html
type ImageCopy struct {
	SrcSubresource ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	SrcOffset      Offset3D
	DstSubresource ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	DstOffset Offset3D
	//  Specified in pixels for both compressed and uncompressed images;
	Extent Extent3D
}

type _vkImageCopy struct {
	srcSubresource _vkImageSubresourceLayers
	srcOffset      _vkOffset3D
	dstSubresource _vkImageSubresourceLayers
	dstOffset      _vkOffset3D
	extent         _vkExtent3D
}

func (s *_vkImageCopy) Goify() *ImageCopy {
	rval := &ImageCopy{
		SrcSubresource: (ImageSubresourceLayers)(s.srcSubresource),
		SrcOffset:      (Offset3D)(s.srcOffset),
		DstSubresource: (ImageSubresourceLayers)(s.dstSubresource),
		DstOffset:      (Offset3D)(s.dstOffset),
		Extent:         (Extent3D)(s.extent),
	}
	return rval
}
func (s *ImageCopy) Vulkanize() *_vkImageCopy {
	if s == nil {
		return nil
	}
	rval := &_vkImageCopy{
		srcSubresource: (_vkImageSubresourceLayers)(s.SrcSubresource), /*cb*/
		srcOffset:      (_vkOffset3D)(s.SrcOffset),                    /*cb*/
		dstSubresource: (_vkImageSubresourceLayers)(s.DstSubresource), /*cb*/
		dstOffset:      (_vkOffset3D)(s.DstOffset),                    /*cb*/
		extent:         (_vkExtent3D)(s.Extent),                       /*cb*/
	}
	return rval
}

// ImageCopy2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy2.html
type ImageCopy2 struct {
	// SType = STRUCTURE_TYPE_IMAGE_COPY_2
	PNext          unsafe.Pointer
	SrcSubresource ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	SrcOffset      Offset3D
	DstSubresource ImageSubresourceLayers
	//  Specified in pixels for both compressed and uncompressed images;
	DstOffset Offset3D
	//  Specified in pixels for both compressed and uncompressed images;
	Extent Extent3D
}

type _vkImageCopy2 struct {
	sType          StructureType
	pNext          unsafe.Pointer
	srcSubresource _vkImageSubresourceLayers
	srcOffset      _vkOffset3D
	dstSubresource _vkImageSubresourceLayers
	dstOffset      _vkOffset3D
	extent         _vkExtent3D
}

func (s *_vkImageCopy2) Goify() *ImageCopy2 {
	rval := &ImageCopy2{
		PNext:          (unsafe.Pointer)(s.pNext),
		SrcSubresource: (ImageSubresourceLayers)(s.srcSubresource),
		SrcOffset:      (Offset3D)(s.srcOffset),
		DstSubresource: (ImageSubresourceLayers)(s.dstSubresource),
		DstOffset:      (Offset3D)(s.dstOffset),
		Extent:         (Extent3D)(s.extent),
	}
	return rval
}
func (s *ImageCopy2) Vulkanize() *_vkImageCopy2 {
	if s == nil {
		return nil
	}
	rval := &_vkImageCopy2{
		sType:          STRUCTURE_TYPE_IMAGE_COPY_2,                   /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                     /*cb*/
		srcSubresource: (_vkImageSubresourceLayers)(s.SrcSubresource), /*cb*/
		srcOffset:      (_vkOffset3D)(s.SrcOffset),                    /*cb*/
		dstSubresource: (_vkImageSubresourceLayers)(s.DstSubresource), /*cb*/
		dstOffset:      (_vkOffset3D)(s.DstOffset),                    /*cb*/
		extent:         (_vkExtent3D)(s.Extent),                       /*cb*/
	}
	return rval
}

// ImageCopy2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy2KHR.html
type ImageCopy2KHR struct {
}

type _vkImageCopy2KHR = ImageCopy2KHR

func (s *_vkImageCopy2KHR) Goify() *ImageCopy2KHR {
	rval := (*ImageCopy2KHR)(s)
	return rval
}
func (s *ImageCopy2KHR) Vulkanize() *_vkImageCopy2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImageCopy2KHR)(s)
	return rval
}

// ImageCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCreateInfo.html
type ImageCreateInfo struct {
	// SType = STRUCTURE_TYPE_IMAGE_CREATE_INFO
	PNext unsafe.Pointer
	//  Image creation flags;
	Flags       ImageCreateFlags
	ImageType   ImageType
	Format      Format
	Extent      Extent3D
	MipLevels   uint32
	ArrayLayers uint32
	Samples     SampleCountFlagBits
	Tiling      ImageTiling
	//  Image usage flags;
	Usage ImageUsageFlags
	//  Cross-queue-family sharing mode;
	SharingMode SharingMode
	//  Number of queue families to share across;
	// queueFamilyIndexCount
	//  Array of queue family indices to share across;
	PQueueFamilyIndices []uint32
	//  Initial image layout for all subresources;
	InitialLayout ImageLayout
}

type _vkImageCreateInfo struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	flags                 ImageCreateFlags
	imageType             ImageType
	format                Format
	extent                _vkExtent3D
	mipLevels             uint32
	arrayLayers           uint32
	samples               SampleCountFlagBits
	tiling                ImageTiling
	usage                 ImageUsageFlags
	sharingMode           SharingMode
	queueFamilyIndexCount uint32
	pQueueFamilyIndices   *uint32
	initialLayout         ImageLayout
}

func (s *_vkImageCreateInfo) Goify() *ImageCreateInfo {
	rval := &ImageCreateInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		Flags:       (ImageCreateFlags)(s.flags),
		ImageType:   (ImageType)(s.imageType),
		Format:      (Format)(s.format),
		Extent:      (Extent3D)(s.extent),
		MipLevels:   (uint32)(s.mipLevels),
		ArrayLayers: (uint32)(s.arrayLayers),
		Samples:     (SampleCountFlagBits)(s.samples),
		Tiling:      (ImageTiling)(s.tiling),
		Usage:       (ImageUsageFlags)(s.usage),
		SharingMode: (SharingMode)(s.sharingMode),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pQueueFamilyIndices in returned struct
		InitialLayout: (ImageLayout)(s.initialLayout),
	}
	return rval
}
func (s *ImageCreateInfo) Vulkanize() *_vkImageCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pQueueFamilyIndices *uint32
	if len(s.PQueueFamilyIndices) > 0 {
		psl_pQueueFamilyIndices = &s.PQueueFamilyIndices[0]
	}
	rval := &_vkImageCreateInfo{
		sType:                 STRUCTURE_TYPE_IMAGE_CREATE_INFO,   /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),          /*cb*/
		flags:                 (ImageCreateFlags)(s.Flags),        /*cb*/
		imageType:             (ImageType)(s.ImageType),           /*cb*/
		format:                (Format)(s.Format),                 /*cb*/
		extent:                (_vkExtent3D)(s.Extent),            /*cb*/
		mipLevels:             (uint32)(s.MipLevels),              /*cb*/
		arrayLayers:           (uint32)(s.ArrayLayers),            /*cb*/
		samples:               (SampleCountFlagBits)(s.Samples),   /*cb*/
		tiling:                (ImageTiling)(s.Tiling),            /*cb*/
		usage:                 (ImageUsageFlags)(s.Usage),         /*cb*/
		sharingMode:           (SharingMode)(s.SharingMode),       /*cb*/
		queueFamilyIndexCount: uint32(len(s.PQueueFamilyIndices)), /*c6-a*/
		pQueueFamilyIndices:   psl_pQueueFamilyIndices,            /*c rem*/
		initialLayout:         (ImageLayout)(s.InitialLayout),     /*cb*/
	}
	return rval
}

// ImageDrmFormatModifierExplicitCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html
type ImageDrmFormatModifierExplicitCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT
	PNext             unsafe.Pointer
	DrmFormatModifier uint64
	// drmFormatModifierPlaneCount
	PPlaneLayouts []SubresourceLayout
}

type _vkImageDrmFormatModifierExplicitCreateInfoEXT struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	drmFormatModifier           uint64
	drmFormatModifierPlaneCount uint32
	pPlaneLayouts               *_vkSubresourceLayout
}

func (s *_vkImageDrmFormatModifierExplicitCreateInfoEXT) Goify() *ImageDrmFormatModifierExplicitCreateInfoEXT {
	rval := &ImageDrmFormatModifierExplicitCreateInfoEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		DrmFormatModifier: (uint64)(s.drmFormatModifier),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPlaneLayouts in returned struct
	}
	return rval
}
func (s *ImageDrmFormatModifierExplicitCreateInfoEXT) Vulkanize() *_vkImageDrmFormatModifierExplicitCreateInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pPlaneLayouts *_vkSubresourceLayout
	if len(s.PPlaneLayouts) > 0 {
		psl_pPlaneLayouts = &s.PPlaneLayouts[0]
	}
	rval := &_vkImageDrmFormatModifierExplicitCreateInfoEXT{
		sType:                       STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                         /*cb*/
		drmFormatModifier:           (uint64)(s.DrmFormatModifier),                                     /*cb*/
		drmFormatModifierPlaneCount: uint32(len(s.PPlaneLayouts)),                                      /*c6-a*/
		pPlaneLayouts:               psl_pPlaneLayouts,                                                 /*c rem*/
	}
	return rval
}

// ImageDrmFormatModifierListCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html
type ImageDrmFormatModifierListCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT
	PNext unsafe.Pointer
	// drmFormatModifierCount
	PDrmFormatModifiers []uint64
}

type _vkImageDrmFormatModifierListCreateInfoEXT struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	drmFormatModifierCount uint32
	pDrmFormatModifiers    *uint64
}

func (s *_vkImageDrmFormatModifierListCreateInfoEXT) Goify() *ImageDrmFormatModifierListCreateInfoEXT {
	rval := &ImageDrmFormatModifierListCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDrmFormatModifiers in returned struct
	}
	return rval
}
func (s *ImageDrmFormatModifierListCreateInfoEXT) Vulkanize() *_vkImageDrmFormatModifierListCreateInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pDrmFormatModifiers *uint64
	if len(s.PDrmFormatModifiers) > 0 {
		psl_pDrmFormatModifiers = &s.PDrmFormatModifiers[0]
	}
	rval := &_vkImageDrmFormatModifierListCreateInfoEXT{
		sType:                  STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                     /*cb*/
		drmFormatModifierCount: uint32(len(s.PDrmFormatModifiers)),                            /*c6-a*/
		pDrmFormatModifiers:    psl_pDrmFormatModifiers,                                       /*c rem*/
	}
	return rval
}

// ImageDrmFormatModifierPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierPropertiesEXT.html
type ImageDrmFormatModifierPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT
	PNext             unsafe.Pointer
	DrmFormatModifier uint64
}

// WARNING - struct ImageDrmFormatModifierPropertiesEXT is returned only, which is not yet handled in the binding
type _vkImageDrmFormatModifierPropertiesEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	drmFormatModifier uint64
}

func (s *_vkImageDrmFormatModifierPropertiesEXT) Goify() *ImageDrmFormatModifierPropertiesEXT {
	rval := &ImageDrmFormatModifierPropertiesEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		DrmFormatModifier: (uint64)(s.drmFormatModifier),
	}
	return rval
}
func (s *ImageDrmFormatModifierPropertiesEXT) Vulkanize() *_vkImageDrmFormatModifierPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkImageDrmFormatModifierPropertiesEXT{
		sType:             STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                               /*cb*/
		drmFormatModifier: (uint64)(s.DrmFormatModifier),                           /*cb*/
	}
	return rval
}

// ImageFormatListCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatListCreateInfo.html
type ImageFormatListCreateInfo struct {
	// SType = STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO
	PNext unsafe.Pointer
	// viewFormatCount
	PViewFormats []Format
}

type _vkImageFormatListCreateInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	viewFormatCount uint32
	pViewFormats    *Format
}

func (s *_vkImageFormatListCreateInfo) Goify() *ImageFormatListCreateInfo {
	rval := &ImageFormatListCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pViewFormats in returned struct
	}
	return rval
}
func (s *ImageFormatListCreateInfo) Vulkanize() *_vkImageFormatListCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pViewFormats *Format
	if len(s.PViewFormats) > 0 {
		psl_pViewFormats = &s.PViewFormats[0]
	}
	rval := &_vkImageFormatListCreateInfo{
		sType:           STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                    /*cb*/
		viewFormatCount: uint32(len(s.PViewFormats)),                  /*c6-a*/
		pViewFormats:    psl_pViewFormats,                             /*c rem*/
	}
	return rval
}

// ImageFormatListCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatListCreateInfoKHR.html
type ImageFormatListCreateInfoKHR struct {
}

type _vkImageFormatListCreateInfoKHR = ImageFormatListCreateInfoKHR

func (s *_vkImageFormatListCreateInfoKHR) Goify() *ImageFormatListCreateInfoKHR {
	rval := (*ImageFormatListCreateInfoKHR)(s)
	return rval
}
func (s *ImageFormatListCreateInfoKHR) Vulkanize() *_vkImageFormatListCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImageFormatListCreateInfoKHR)(s)
	return rval
}

// ImageFormatProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties.html
type ImageFormatProperties struct {
	//  max image dimensions for this resource type;
	MaxExtent Extent3D
	//  max number of mipmap levels for this resource type;
	MaxMipLevels uint32
	//  max array size for this resource type;
	MaxArrayLayers uint32
	//  supported sample counts for this resource type;
	SampleCounts SampleCountFlags
	//  max size (in bytes) of this resource type;
	MaxResourceSize DeviceSize
}

// WARNING - struct ImageFormatProperties is returned only, which is not yet handled in the binding
type _vkImageFormatProperties struct {
	maxExtent       _vkExtent3D
	maxMipLevels    uint32
	maxArrayLayers  uint32
	sampleCounts    SampleCountFlags
	maxResourceSize DeviceSize
}

func (s *_vkImageFormatProperties) Goify() *ImageFormatProperties {
	rval := &ImageFormatProperties{
		MaxExtent:       (Extent3D)(s.maxExtent),
		MaxMipLevels:    (uint32)(s.maxMipLevels),
		MaxArrayLayers:  (uint32)(s.maxArrayLayers),
		SampleCounts:    (SampleCountFlags)(s.sampleCounts),
		MaxResourceSize: (DeviceSize)(s.maxResourceSize),
	}
	return rval
}
func (s *ImageFormatProperties) Vulkanize() *_vkImageFormatProperties {
	if s == nil {
		return nil
	}
	rval := &_vkImageFormatProperties{
		maxExtent:       (_vkExtent3D)(s.MaxExtent),         /*cb*/
		maxMipLevels:    (uint32)(s.MaxMipLevels),           /*cb*/
		maxArrayLayers:  (uint32)(s.MaxArrayLayers),         /*cb*/
		sampleCounts:    (SampleCountFlags)(s.SampleCounts), /*cb*/
		maxResourceSize: (DeviceSize)(s.MaxResourceSize),    /*cb*/
	}
	return rval
}

// ImageFormatProperties2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties2.html
type ImageFormatProperties2 struct {
	// SType = STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2
	PNext                 unsafe.Pointer
	ImageFormatProperties ImageFormatProperties
}

// WARNING - struct ImageFormatProperties2 is returned only, which is not yet handled in the binding
type _vkImageFormatProperties2 struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	imageFormatProperties _vkImageFormatProperties
}

func (s *_vkImageFormatProperties2) Goify() *ImageFormatProperties2 {
	rval := &ImageFormatProperties2{
		PNext:                 (unsafe.Pointer)(s.pNext),
		ImageFormatProperties: *(s.imageFormatProperties.Goify()),
	}
	return rval
}
func (s *ImageFormatProperties2) Vulkanize() *_vkImageFormatProperties2 {
	if s == nil {
		return nil
	}
	rval := &_vkImageFormatProperties2{
		sType:                 STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                /*cb*/
		imageFormatProperties: *(s.ImageFormatProperties.Vulkanize()),   /*c3*/
	}
	return rval
}

// ImageFormatProperties2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties2KHR.html
type ImageFormatProperties2KHR struct {
}

type _vkImageFormatProperties2KHR = ImageFormatProperties2KHR

func (s *_vkImageFormatProperties2KHR) Goify() *ImageFormatProperties2KHR {
	rval := (*ImageFormatProperties2KHR)(s)
	return rval
}
func (s *ImageFormatProperties2KHR) Vulkanize() *_vkImageFormatProperties2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImageFormatProperties2KHR)(s)
	return rval
}

// ImageMemoryBarrier: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier.html
type ImageMemoryBarrier struct {
	// SType = STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
	PNext unsafe.Pointer
	//  Memory accesses from the source of the dependency to synchronize;
	SrcAccessMask AccessFlags
	//  Memory accesses from the destination of the dependency to synchronize;
	DstAccessMask AccessFlags
	//  Current layout of the image;
	OldLayout ImageLayout
	//  New layout to transition the image to;
	NewLayout ImageLayout
	//  Queue family to transition ownership from;
	SrcQueueFamilyIndex uint32
	//  Queue family to transition ownership to;
	DstQueueFamilyIndex uint32
	//  Image to sync;
	Image Image
	//  Subresource range to sync;
	SubresourceRange ImageSubresourceRange
}

type _vkImageMemoryBarrier struct {
	sType               StructureType
	pNext               unsafe.Pointer
	srcAccessMask       AccessFlags
	dstAccessMask       AccessFlags
	oldLayout           ImageLayout
	newLayout           ImageLayout
	srcQueueFamilyIndex uint32
	dstQueueFamilyIndex uint32
	image               Image
	subresourceRange    _vkImageSubresourceRange
}

func (s *_vkImageMemoryBarrier) Goify() *ImageMemoryBarrier {
	rval := &ImageMemoryBarrier{
		PNext:               (unsafe.Pointer)(s.pNext),
		SrcAccessMask:       (AccessFlags)(s.srcAccessMask),
		DstAccessMask:       (AccessFlags)(s.dstAccessMask),
		OldLayout:           (ImageLayout)(s.oldLayout),
		NewLayout:           (ImageLayout)(s.newLayout),
		SrcQueueFamilyIndex: (uint32)(s.srcQueueFamilyIndex),
		DstQueueFamilyIndex: (uint32)(s.dstQueueFamilyIndex),
		Image:               (Image)(s.image),
		SubresourceRange:    (ImageSubresourceRange)(s.subresourceRange),
	}
	return rval
}
func (s *ImageMemoryBarrier) Vulkanize() *_vkImageMemoryBarrier {
	if s == nil {
		return nil
	}
	rval := &_vkImageMemoryBarrier{
		sType:               STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,            /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                      /*cb*/
		srcAccessMask:       (AccessFlags)(s.SrcAccessMask),                 /*cb*/
		dstAccessMask:       (AccessFlags)(s.DstAccessMask),                 /*cb*/
		oldLayout:           (ImageLayout)(s.OldLayout),                     /*cb*/
		newLayout:           (ImageLayout)(s.NewLayout),                     /*cb*/
		srcQueueFamilyIndex: (uint32)(s.SrcQueueFamilyIndex),                /*cb*/
		dstQueueFamilyIndex: (uint32)(s.DstQueueFamilyIndex),                /*cb*/
		image:               (Image)(s.Image),                               /*cb*/
		subresourceRange:    (_vkImageSubresourceRange)(s.SubresourceRange), /*cb*/
	}
	return rval
}

// ImageMemoryBarrier2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier2.html
type ImageMemoryBarrier2 struct {
	// SType = STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2
	PNext               unsafe.Pointer
	SrcStageMask        PipelineStageFlags2
	SrcAccessMask       AccessFlags2
	DstStageMask        PipelineStageFlags2
	DstAccessMask       AccessFlags2
	OldLayout           ImageLayout
	NewLayout           ImageLayout
	SrcQueueFamilyIndex uint32
	DstQueueFamilyIndex uint32
	Image               Image
	SubresourceRange    ImageSubresourceRange
}

type _vkImageMemoryBarrier2 struct {
	sType               StructureType
	pNext               unsafe.Pointer
	srcStageMask        PipelineStageFlags2
	srcAccessMask       AccessFlags2
	dstStageMask        PipelineStageFlags2
	dstAccessMask       AccessFlags2
	oldLayout           ImageLayout
	newLayout           ImageLayout
	srcQueueFamilyIndex uint32
	dstQueueFamilyIndex uint32
	image               Image
	subresourceRange    _vkImageSubresourceRange
}

func (s *_vkImageMemoryBarrier2) Goify() *ImageMemoryBarrier2 {
	rval := &ImageMemoryBarrier2{
		PNext:               (unsafe.Pointer)(s.pNext),
		SrcStageMask:        (PipelineStageFlags2)(s.srcStageMask),
		SrcAccessMask:       (AccessFlags2)(s.srcAccessMask),
		DstStageMask:        (PipelineStageFlags2)(s.dstStageMask),
		DstAccessMask:       (AccessFlags2)(s.dstAccessMask),
		OldLayout:           (ImageLayout)(s.oldLayout),
		NewLayout:           (ImageLayout)(s.newLayout),
		SrcQueueFamilyIndex: (uint32)(s.srcQueueFamilyIndex),
		DstQueueFamilyIndex: (uint32)(s.dstQueueFamilyIndex),
		Image:               (Image)(s.image),
		SubresourceRange:    (ImageSubresourceRange)(s.subresourceRange),
	}
	return rval
}
func (s *ImageMemoryBarrier2) Vulkanize() *_vkImageMemoryBarrier2 {
	if s == nil {
		return nil
	}
	rval := &_vkImageMemoryBarrier2{
		sType:               STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,          /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                      /*cb*/
		srcStageMask:        (PipelineStageFlags2)(s.SrcStageMask),          /*cb*/
		srcAccessMask:       (AccessFlags2)(s.SrcAccessMask),                /*cb*/
		dstStageMask:        (PipelineStageFlags2)(s.DstStageMask),          /*cb*/
		dstAccessMask:       (AccessFlags2)(s.DstAccessMask),                /*cb*/
		oldLayout:           (ImageLayout)(s.OldLayout),                     /*cb*/
		newLayout:           (ImageLayout)(s.NewLayout),                     /*cb*/
		srcQueueFamilyIndex: (uint32)(s.SrcQueueFamilyIndex),                /*cb*/
		dstQueueFamilyIndex: (uint32)(s.DstQueueFamilyIndex),                /*cb*/
		image:               (Image)(s.Image),                               /*cb*/
		subresourceRange:    (_vkImageSubresourceRange)(s.SubresourceRange), /*cb*/
	}
	return rval
}

// ImageMemoryBarrier2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier2KHR.html
type ImageMemoryBarrier2KHR struct {
}

type _vkImageMemoryBarrier2KHR = ImageMemoryBarrier2KHR

func (s *_vkImageMemoryBarrier2KHR) Goify() *ImageMemoryBarrier2KHR {
	rval := (*ImageMemoryBarrier2KHR)(s)
	return rval
}
func (s *ImageMemoryBarrier2KHR) Vulkanize() *_vkImageMemoryBarrier2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImageMemoryBarrier2KHR)(s)
	return rval
}

// ImageMemoryRequirementsInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryRequirementsInfo2.html
type ImageMemoryRequirementsInfo2 struct {
	// SType = STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2
	PNext unsafe.Pointer
	Image Image
}

type _vkImageMemoryRequirementsInfo2 struct {
	sType StructureType
	pNext unsafe.Pointer
	image Image
}

func (s *_vkImageMemoryRequirementsInfo2) Goify() *ImageMemoryRequirementsInfo2 {
	rval := &ImageMemoryRequirementsInfo2{
		PNext: (unsafe.Pointer)(s.pNext),
		Image: (Image)(s.image),
	}
	return rval
}
func (s *ImageMemoryRequirementsInfo2) Vulkanize() *_vkImageMemoryRequirementsInfo2 {
	if s == nil {
		return nil
	}
	rval := &_vkImageMemoryRequirementsInfo2{
		sType: STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                       /*cb*/
		image: (Image)(s.Image),                                /*cb*/
	}
	return rval
}

// ImageMemoryRequirementsInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryRequirementsInfo2KHR.html
type ImageMemoryRequirementsInfo2KHR struct {
}

type _vkImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2KHR

func (s *_vkImageMemoryRequirementsInfo2KHR) Goify() *ImageMemoryRequirementsInfo2KHR {
	rval := (*ImageMemoryRequirementsInfo2KHR)(s)
	return rval
}
func (s *ImageMemoryRequirementsInfo2KHR) Vulkanize() *_vkImageMemoryRequirementsInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImageMemoryRequirementsInfo2KHR)(s)
	return rval
}

// ImagePlaneMemoryRequirementsInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePlaneMemoryRequirementsInfo.html
type ImagePlaneMemoryRequirementsInfo struct {
	// SType = STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO
	PNext       unsafe.Pointer
	PlaneAspect ImageAspectFlagBits
}

type _vkImagePlaneMemoryRequirementsInfo struct {
	sType       StructureType
	pNext       unsafe.Pointer
	planeAspect ImageAspectFlagBits
}

func (s *_vkImagePlaneMemoryRequirementsInfo) Goify() *ImagePlaneMemoryRequirementsInfo {
	rval := &ImagePlaneMemoryRequirementsInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		PlaneAspect: (ImageAspectFlagBits)(s.planeAspect),
	}
	return rval
}
func (s *ImagePlaneMemoryRequirementsInfo) Vulkanize() *_vkImagePlaneMemoryRequirementsInfo {
	if s == nil {
		return nil
	}
	rval := &_vkImagePlaneMemoryRequirementsInfo{
		sType:       STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                           /*cb*/
		planeAspect: (ImageAspectFlagBits)(s.PlaneAspect),                /*cb*/
	}
	return rval
}

// ImagePlaneMemoryRequirementsInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePlaneMemoryRequirementsInfoKHR.html
type ImagePlaneMemoryRequirementsInfoKHR struct {
}

type _vkImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfoKHR

func (s *_vkImagePlaneMemoryRequirementsInfoKHR) Goify() *ImagePlaneMemoryRequirementsInfoKHR {
	rval := (*ImagePlaneMemoryRequirementsInfoKHR)(s)
	return rval
}
func (s *ImagePlaneMemoryRequirementsInfoKHR) Vulkanize() *_vkImagePlaneMemoryRequirementsInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImagePlaneMemoryRequirementsInfoKHR)(s)
	return rval
}

// ImageResolve: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve.html
type ImageResolve struct {
	SrcSubresource ImageSubresourceLayers
	SrcOffset      Offset3D
	DstSubresource ImageSubresourceLayers
	DstOffset      Offset3D
	Extent         Extent3D
}

type _vkImageResolve struct {
	srcSubresource _vkImageSubresourceLayers
	srcOffset      _vkOffset3D
	dstSubresource _vkImageSubresourceLayers
	dstOffset      _vkOffset3D
	extent         _vkExtent3D
}

func (s *_vkImageResolve) Goify() *ImageResolve {
	rval := &ImageResolve{
		SrcSubresource: (ImageSubresourceLayers)(s.srcSubresource),
		SrcOffset:      (Offset3D)(s.srcOffset),
		DstSubresource: (ImageSubresourceLayers)(s.dstSubresource),
		DstOffset:      (Offset3D)(s.dstOffset),
		Extent:         (Extent3D)(s.extent),
	}
	return rval
}
func (s *ImageResolve) Vulkanize() *_vkImageResolve {
	if s == nil {
		return nil
	}
	rval := &_vkImageResolve{
		srcSubresource: (_vkImageSubresourceLayers)(s.SrcSubresource), /*cb*/
		srcOffset:      (_vkOffset3D)(s.SrcOffset),                    /*cb*/
		dstSubresource: (_vkImageSubresourceLayers)(s.DstSubresource), /*cb*/
		dstOffset:      (_vkOffset3D)(s.DstOffset),                    /*cb*/
		extent:         (_vkExtent3D)(s.Extent),                       /*cb*/
	}
	return rval
}

// ImageResolve2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve2.html
type ImageResolve2 struct {
	// SType = STRUCTURE_TYPE_IMAGE_RESOLVE_2
	PNext          unsafe.Pointer
	SrcSubresource ImageSubresourceLayers
	SrcOffset      Offset3D
	DstSubresource ImageSubresourceLayers
	DstOffset      Offset3D
	Extent         Extent3D
}

type _vkImageResolve2 struct {
	sType          StructureType
	pNext          unsafe.Pointer
	srcSubresource _vkImageSubresourceLayers
	srcOffset      _vkOffset3D
	dstSubresource _vkImageSubresourceLayers
	dstOffset      _vkOffset3D
	extent         _vkExtent3D
}

func (s *_vkImageResolve2) Goify() *ImageResolve2 {
	rval := &ImageResolve2{
		PNext:          (unsafe.Pointer)(s.pNext),
		SrcSubresource: (ImageSubresourceLayers)(s.srcSubresource),
		SrcOffset:      (Offset3D)(s.srcOffset),
		DstSubresource: (ImageSubresourceLayers)(s.dstSubresource),
		DstOffset:      (Offset3D)(s.dstOffset),
		Extent:         (Extent3D)(s.extent),
	}
	return rval
}
func (s *ImageResolve2) Vulkanize() *_vkImageResolve2 {
	if s == nil {
		return nil
	}
	rval := &_vkImageResolve2{
		sType:          STRUCTURE_TYPE_IMAGE_RESOLVE_2,                /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                     /*cb*/
		srcSubresource: (_vkImageSubresourceLayers)(s.SrcSubresource), /*cb*/
		srcOffset:      (_vkOffset3D)(s.SrcOffset),                    /*cb*/
		dstSubresource: (_vkImageSubresourceLayers)(s.DstSubresource), /*cb*/
		dstOffset:      (_vkOffset3D)(s.DstOffset),                    /*cb*/
		extent:         (_vkExtent3D)(s.Extent),                       /*cb*/
	}
	return rval
}

// ImageResolve2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve2KHR.html
type ImageResolve2KHR struct {
}

type _vkImageResolve2KHR = ImageResolve2KHR

func (s *_vkImageResolve2KHR) Goify() *ImageResolve2KHR {
	rval := (*ImageResolve2KHR)(s)
	return rval
}
func (s *ImageResolve2KHR) Vulkanize() *_vkImageResolve2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImageResolve2KHR)(s)
	return rval
}

// ImageSparseMemoryRequirementsInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSparseMemoryRequirementsInfo2.html
type ImageSparseMemoryRequirementsInfo2 struct {
	// SType = STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2
	PNext unsafe.Pointer
	Image Image
}

type _vkImageSparseMemoryRequirementsInfo2 struct {
	sType StructureType
	pNext unsafe.Pointer
	image Image
}

func (s *_vkImageSparseMemoryRequirementsInfo2) Goify() *ImageSparseMemoryRequirementsInfo2 {
	rval := &ImageSparseMemoryRequirementsInfo2{
		PNext: (unsafe.Pointer)(s.pNext),
		Image: (Image)(s.image),
	}
	return rval
}
func (s *ImageSparseMemoryRequirementsInfo2) Vulkanize() *_vkImageSparseMemoryRequirementsInfo2 {
	if s == nil {
		return nil
	}
	rval := &_vkImageSparseMemoryRequirementsInfo2{
		sType: STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                              /*cb*/
		image: (Image)(s.Image),                                       /*cb*/
	}
	return rval
}

// ImageSparseMemoryRequirementsInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSparseMemoryRequirementsInfo2KHR.html
type ImageSparseMemoryRequirementsInfo2KHR struct {
}

type _vkImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2KHR

func (s *_vkImageSparseMemoryRequirementsInfo2KHR) Goify() *ImageSparseMemoryRequirementsInfo2KHR {
	rval := (*ImageSparseMemoryRequirementsInfo2KHR)(s)
	return rval
}
func (s *ImageSparseMemoryRequirementsInfo2KHR) Vulkanize() *_vkImageSparseMemoryRequirementsInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImageSparseMemoryRequirementsInfo2KHR)(s)
	return rval
}

// ImageStencilUsageCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageStencilUsageCreateInfo.html
type ImageStencilUsageCreateInfo struct {
	// SType = STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO
	PNext        unsafe.Pointer
	StencilUsage ImageUsageFlags
}

type _vkImageStencilUsageCreateInfo struct {
	sType        StructureType
	pNext        unsafe.Pointer
	stencilUsage ImageUsageFlags
}

func (s *_vkImageStencilUsageCreateInfo) Goify() *ImageStencilUsageCreateInfo {
	rval := &ImageStencilUsageCreateInfo{
		PNext:        (unsafe.Pointer)(s.pNext),
		StencilUsage: (ImageUsageFlags)(s.stencilUsage),
	}
	return rval
}
func (s *ImageStencilUsageCreateInfo) Vulkanize() *_vkImageStencilUsageCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkImageStencilUsageCreateInfo{
		sType:        STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                      /*cb*/
		stencilUsage: (ImageUsageFlags)(s.StencilUsage),              /*cb*/
	}
	return rval
}

// ImageStencilUsageCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageStencilUsageCreateInfoEXT.html
type ImageStencilUsageCreateInfoEXT struct {
}

type _vkImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfoEXT

func (s *_vkImageStencilUsageCreateInfoEXT) Goify() *ImageStencilUsageCreateInfoEXT {
	rval := (*ImageStencilUsageCreateInfoEXT)(s)
	return rval
}
func (s *ImageStencilUsageCreateInfoEXT) Vulkanize() *_vkImageStencilUsageCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkImageStencilUsageCreateInfoEXT)(s)
	return rval
}

// ImageSubresource: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource.html
type ImageSubresource struct {
	AspectMask ImageAspectFlags
	MipLevel   uint32
	ArrayLayer uint32
}

type _vkImageSubresource = ImageSubresource

func (s *_vkImageSubresource) Goify() *ImageSubresource {
	rval := (*ImageSubresource)(s)
	return rval
}
func (s *ImageSubresource) Vulkanize() *_vkImageSubresource {
	if s == nil {
		return nil
	}
	rval := (*_vkImageSubresource)(s)
	return rval
}

// ImageSubresource2EXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource2EXT.html
type ImageSubresource2EXT struct {
}

type _vkImageSubresource2EXT = ImageSubresource2EXT

func (s *_vkImageSubresource2EXT) Goify() *ImageSubresource2EXT {
	rval := (*ImageSubresource2EXT)(s)
	return rval
}
func (s *ImageSubresource2EXT) Vulkanize() *_vkImageSubresource2EXT {
	if s == nil {
		return nil
	}
	rval := (*_vkImageSubresource2EXT)(s)
	return rval
}

// ImageSubresource2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource2KHR.html
type ImageSubresource2KHR struct {
	// SType = STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR
	PNext            unsafe.Pointer
	ImageSubresource ImageSubresource
}

type _vkImageSubresource2KHR struct {
	sType            StructureType
	pNext            unsafe.Pointer
	imageSubresource _vkImageSubresource
}

func (s *_vkImageSubresource2KHR) Goify() *ImageSubresource2KHR {
	rval := &ImageSubresource2KHR{
		PNext:            (unsafe.Pointer)(s.pNext),
		ImageSubresource: (ImageSubresource)(s.imageSubresource),
	}
	return rval
}
func (s *ImageSubresource2KHR) Vulkanize() *_vkImageSubresource2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkImageSubresource2KHR{
		sType:            STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR,    /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                 /*cb*/
		imageSubresource: (_vkImageSubresource)(s.ImageSubresource), /*cb*/
	}
	return rval
}

// ImageSubresourceLayers: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceLayers.html
type ImageSubresourceLayers struct {
	AspectMask     ImageAspectFlags
	MipLevel       uint32
	BaseArrayLayer uint32
	LayerCount     uint32
}

type _vkImageSubresourceLayers = ImageSubresourceLayers

func (s *_vkImageSubresourceLayers) Goify() *ImageSubresourceLayers {
	rval := (*ImageSubresourceLayers)(s)
	return rval
}
func (s *ImageSubresourceLayers) Vulkanize() *_vkImageSubresourceLayers {
	if s == nil {
		return nil
	}
	rval := (*_vkImageSubresourceLayers)(s)
	return rval
}

// ImageSubresourceRange: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceRange.html
type ImageSubresourceRange struct {
	AspectMask     ImageAspectFlags
	BaseMipLevel   uint32
	LevelCount     uint32
	BaseArrayLayer uint32
	LayerCount     uint32
}

type _vkImageSubresourceRange = ImageSubresourceRange

func (s *_vkImageSubresourceRange) Goify() *ImageSubresourceRange {
	rval := (*ImageSubresourceRange)(s)
	return rval
}
func (s *ImageSubresourceRange) Vulkanize() *_vkImageSubresourceRange {
	if s == nil {
		return nil
	}
	rval := (*_vkImageSubresourceRange)(s)
	return rval
}

// ImageSwapchainCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSwapchainCreateInfoKHR.html
type ImageSwapchainCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR
	PNext     unsafe.Pointer
	Swapchain SwapchainKHR
}

type _vkImageSwapchainCreateInfoKHR struct {
	sType     StructureType
	pNext     unsafe.Pointer
	swapchain SwapchainKHR
}

func (s *_vkImageSwapchainCreateInfoKHR) Goify() *ImageSwapchainCreateInfoKHR {
	rval := &ImageSwapchainCreateInfoKHR{
		PNext:     (unsafe.Pointer)(s.pNext),
		Swapchain: (SwapchainKHR)(s.swapchain),
	}
	return rval
}
func (s *ImageSwapchainCreateInfoKHR) Vulkanize() *_vkImageSwapchainCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkImageSwapchainCreateInfoKHR{
		sType:     STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                      /*cb*/
		swapchain: (SwapchainKHR)(s.Swapchain),                    /*cb*/
	}
	return rval
}

// ImageToMemoryCopyEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageToMemoryCopyEXT.html
type ImageToMemoryCopyEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT
	PNext        unsafe.Pointer
	PHostPointer unsafe.Pointer
	//  Specified in texels;
	MemoryRowLength   uint32
	MemoryImageHeight uint32
	ImageSubresource  ImageSubresourceLayers
	ImageOffset       Offset3D
	ImageExtent       Extent3D
}

type _vkImageToMemoryCopyEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	pHostPointer      unsafe.Pointer
	memoryRowLength   uint32
	memoryImageHeight uint32
	imageSubresource  _vkImageSubresourceLayers
	imageOffset       _vkOffset3D
	imageExtent       _vkExtent3D
}

func (s *_vkImageToMemoryCopyEXT) Goify() *ImageToMemoryCopyEXT {
	rval := &ImageToMemoryCopyEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		PHostPointer:      (unsafe.Pointer)(s.pHostPointer),
		MemoryRowLength:   (uint32)(s.memoryRowLength),
		MemoryImageHeight: (uint32)(s.memoryImageHeight),
		ImageSubresource:  (ImageSubresourceLayers)(s.imageSubresource),
		ImageOffset:       (Offset3D)(s.imageOffset),
		ImageExtent:       (Extent3D)(s.imageExtent),
	}
	return rval
}
func (s *ImageToMemoryCopyEXT) Vulkanize() *_vkImageToMemoryCopyEXT {
	if s == nil {
		return nil
	}
	rval := &_vkImageToMemoryCopyEXT{
		sType:             STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT,         /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                       /*cb*/
		pHostPointer:      (unsafe.Pointer)(s.PHostPointer),                /*cb*/
		memoryRowLength:   (uint32)(s.MemoryRowLength),                     /*cb*/
		memoryImageHeight: (uint32)(s.MemoryImageHeight),                   /*cb*/
		imageSubresource:  (_vkImageSubresourceLayers)(s.ImageSubresource), /*cb*/
		imageOffset:       (_vkOffset3D)(s.ImageOffset),                    /*cb*/
		imageExtent:       (_vkExtent3D)(s.ImageExtent),                    /*cb*/
	}
	return rval
}

// ImageViewASTCDecodeModeEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewASTCDecodeModeEXT.html
type ImageViewASTCDecodeModeEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT
	PNext      unsafe.Pointer
	DecodeMode Format
}

type _vkImageViewASTCDecodeModeEXT struct {
	sType      StructureType
	pNext      unsafe.Pointer
	decodeMode Format
}

func (s *_vkImageViewASTCDecodeModeEXT) Goify() *ImageViewASTCDecodeModeEXT {
	rval := &ImageViewASTCDecodeModeEXT{
		PNext:      (unsafe.Pointer)(s.pNext),
		DecodeMode: (Format)(s.decodeMode),
	}
	return rval
}
func (s *ImageViewASTCDecodeModeEXT) Vulkanize() *_vkImageViewASTCDecodeModeEXT {
	if s == nil {
		return nil
	}
	rval := &_vkImageViewASTCDecodeModeEXT{
		sType:      STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                      /*cb*/
		decodeMode: (Format)(s.DecodeMode),                         /*cb*/
	}
	return rval
}

// ImageViewAddressPropertiesNVX: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewAddressPropertiesNVX.html
type ImageViewAddressPropertiesNVX struct {
	// SType = STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX
	PNext         unsafe.Pointer
	DeviceAddress DeviceAddress
	Size          DeviceSize
}

// WARNING - struct ImageViewAddressPropertiesNVX is returned only, which is not yet handled in the binding
type _vkImageViewAddressPropertiesNVX struct {
	sType         StructureType
	pNext         unsafe.Pointer
	deviceAddress DeviceAddress
	size          DeviceSize
}

func (s *_vkImageViewAddressPropertiesNVX) Goify() *ImageViewAddressPropertiesNVX {
	rval := &ImageViewAddressPropertiesNVX{
		PNext:         (unsafe.Pointer)(s.pNext),
		DeviceAddress: (DeviceAddress)(s.deviceAddress),
		Size:          (DeviceSize)(s.size),
	}
	return rval
}
func (s *ImageViewAddressPropertiesNVX) Vulkanize() *_vkImageViewAddressPropertiesNVX {
	if s == nil {
		return nil
	}
	rval := &_vkImageViewAddressPropertiesNVX{
		sType:         STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                        /*cb*/
		deviceAddress: (DeviceAddress)(s.DeviceAddress),                 /*cb*/
		size:          (DeviceSize)(s.Size),                             /*cb*/
	}
	return rval
}

// ImageViewCaptureDescriptorDataInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCaptureDescriptorDataInfoEXT.html
type ImageViewCaptureDescriptorDataInfoEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
	PNext     unsafe.Pointer
	ImageView ImageView
}

type _vkImageViewCaptureDescriptorDataInfoEXT struct {
	sType     StructureType
	pNext     unsafe.Pointer
	imageView ImageView
}

func (s *_vkImageViewCaptureDescriptorDataInfoEXT) Goify() *ImageViewCaptureDescriptorDataInfoEXT {
	rval := &ImageViewCaptureDescriptorDataInfoEXT{
		PNext:     (unsafe.Pointer)(s.pNext),
		ImageView: (ImageView)(s.imageView),
	}
	return rval
}
func (s *ImageViewCaptureDescriptorDataInfoEXT) Vulkanize() *_vkImageViewCaptureDescriptorDataInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkImageViewCaptureDescriptorDataInfoEXT{
		sType:     STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                                  /*cb*/
		imageView: (ImageView)(s.ImageView),                                   /*cb*/
	}
	return rval
}

// ImageViewCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateInfo.html
type ImageViewCreateInfo struct {
	// SType = STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
	PNext            unsafe.Pointer
	Flags            ImageViewCreateFlags
	Image            Image
	ViewType         ImageViewType
	Format           Format
	Components       ComponentMapping
	SubresourceRange ImageSubresourceRange
}

type _vkImageViewCreateInfo struct {
	sType            StructureType
	pNext            unsafe.Pointer
	flags            ImageViewCreateFlags
	image            Image
	viewType         ImageViewType
	format           Format
	components       _vkComponentMapping
	subresourceRange _vkImageSubresourceRange
}

func (s *_vkImageViewCreateInfo) Goify() *ImageViewCreateInfo {
	rval := &ImageViewCreateInfo{
		PNext:            (unsafe.Pointer)(s.pNext),
		Flags:            (ImageViewCreateFlags)(s.flags),
		Image:            (Image)(s.image),
		ViewType:         (ImageViewType)(s.viewType),
		Format:           (Format)(s.format),
		Components:       (ComponentMapping)(s.components),
		SubresourceRange: (ImageSubresourceRange)(s.subresourceRange),
	}
	return rval
}
func (s *ImageViewCreateInfo) Vulkanize() *_vkImageViewCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkImageViewCreateInfo{
		sType:            STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,          /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                      /*cb*/
		flags:            (ImageViewCreateFlags)(s.Flags),                /*cb*/
		image:            (Image)(s.Image),                               /*cb*/
		viewType:         (ImageViewType)(s.ViewType),                    /*cb*/
		format:           (Format)(s.Format),                             /*cb*/
		components:       (_vkComponentMapping)(s.Components),            /*cb*/
		subresourceRange: (_vkImageSubresourceRange)(s.SubresourceRange), /*cb*/
	}
	return rval
}

// ImageViewHandleInfoNVX: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewHandleInfoNVX.html
type ImageViewHandleInfoNVX struct {
	// SType = STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX
	PNext          unsafe.Pointer
	ImageView      ImageView
	DescriptorType DescriptorType
	Sampler        Sampler
}

type _vkImageViewHandleInfoNVX struct {
	sType          StructureType
	pNext          unsafe.Pointer
	imageView      ImageView
	descriptorType DescriptorType
	sampler        Sampler
}

func (s *_vkImageViewHandleInfoNVX) Goify() *ImageViewHandleInfoNVX {
	rval := &ImageViewHandleInfoNVX{
		PNext:          (unsafe.Pointer)(s.pNext),
		ImageView:      (ImageView)(s.imageView),
		DescriptorType: (DescriptorType)(s.descriptorType),
		Sampler:        (Sampler)(s.sampler),
	}
	return rval
}
func (s *ImageViewHandleInfoNVX) Vulkanize() *_vkImageViewHandleInfoNVX {
	if s == nil {
		return nil
	}
	rval := &_vkImageViewHandleInfoNVX{
		sType:          STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                 /*cb*/
		imageView:      (ImageView)(s.ImageView),                  /*cb*/
		descriptorType: (DescriptorType)(s.DescriptorType),        /*cb*/
		sampler:        (Sampler)(s.Sampler),                      /*cb*/
	}
	return rval
}

// ImageViewMinLodCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewMinLodCreateInfoEXT.html
type ImageViewMinLodCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT
	PNext  unsafe.Pointer
	MinLod float32
}

type _vkImageViewMinLodCreateInfoEXT struct {
	sType  StructureType
	pNext  unsafe.Pointer
	minLod float32
}

func (s *_vkImageViewMinLodCreateInfoEXT) Goify() *ImageViewMinLodCreateInfoEXT {
	rval := &ImageViewMinLodCreateInfoEXT{
		PNext:  (unsafe.Pointer)(s.pNext),
		MinLod: (float32)(s.minLod),
	}
	return rval
}
func (s *ImageViewMinLodCreateInfoEXT) Vulkanize() *_vkImageViewMinLodCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkImageViewMinLodCreateInfoEXT{
		sType:  STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                         /*cb*/
		minLod: (float32)(s.MinLod),                               /*cb*/
	}
	return rval
}

// ImageViewSampleWeightCreateInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewSampleWeightCreateInfoQCOM.html
type ImageViewSampleWeightCreateInfoQCOM struct {
	// SType = STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM
	PNext        unsafe.Pointer
	FilterCenter Offset2D
	FilterSize   Extent2D
	NumPhases    uint32
}

type _vkImageViewSampleWeightCreateInfoQCOM struct {
	sType        StructureType
	pNext        unsafe.Pointer
	filterCenter _vkOffset2D
	filterSize   _vkExtent2D
	numPhases    uint32
}

func (s *_vkImageViewSampleWeightCreateInfoQCOM) Goify() *ImageViewSampleWeightCreateInfoQCOM {
	rval := &ImageViewSampleWeightCreateInfoQCOM{
		PNext:        (unsafe.Pointer)(s.pNext),
		FilterCenter: (Offset2D)(s.filterCenter),
		FilterSize:   (Extent2D)(s.filterSize),
		NumPhases:    (uint32)(s.numPhases),
	}
	return rval
}
func (s *ImageViewSampleWeightCreateInfoQCOM) Vulkanize() *_vkImageViewSampleWeightCreateInfoQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkImageViewSampleWeightCreateInfoQCOM{
		sType:        STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                                /*cb*/
		filterCenter: (_vkOffset2D)(s.FilterCenter),                            /*cb*/
		filterSize:   (_vkExtent2D)(s.FilterSize),                              /*cb*/
		numPhases:    (uint32)(s.NumPhases),                                    /*cb*/
	}
	return rval
}

// ImageViewSlicedCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewSlicedCreateInfoEXT.html
type ImageViewSlicedCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT
	PNext       unsafe.Pointer
	SliceOffset uint32
	SliceCount  uint32
}

type _vkImageViewSlicedCreateInfoEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	sliceOffset uint32
	sliceCount  uint32
}

func (s *_vkImageViewSlicedCreateInfoEXT) Goify() *ImageViewSlicedCreateInfoEXT {
	rval := &ImageViewSlicedCreateInfoEXT{
		PNext:       (unsafe.Pointer)(s.pNext),
		SliceOffset: (uint32)(s.sliceOffset),
		SliceCount:  (uint32)(s.sliceCount),
	}
	return rval
}
func (s *ImageViewSlicedCreateInfoEXT) Vulkanize() *_vkImageViewSlicedCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkImageViewSlicedCreateInfoEXT{
		sType:       STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                        /*cb*/
		sliceOffset: (uint32)(s.SliceOffset),                          /*cb*/
		sliceCount:  (uint32)(s.SliceCount),                           /*cb*/
	}
	return rval
}

// ImageViewUsageCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewUsageCreateInfo.html
type ImageViewUsageCreateInfo struct {
	// SType = STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO
	PNext unsafe.Pointer
	Usage ImageUsageFlags
}

type _vkImageViewUsageCreateInfo struct {
	sType StructureType
	pNext unsafe.Pointer
	usage ImageUsageFlags
}

func (s *_vkImageViewUsageCreateInfo) Goify() *ImageViewUsageCreateInfo {
	rval := &ImageViewUsageCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Usage: (ImageUsageFlags)(s.usage),
	}
	return rval
}
func (s *ImageViewUsageCreateInfo) Vulkanize() *_vkImageViewUsageCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkImageViewUsageCreateInfo{
		sType: STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                   /*cb*/
		usage: (ImageUsageFlags)(s.Usage),                  /*cb*/
	}
	return rval
}

// ImageViewUsageCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewUsageCreateInfoKHR.html
type ImageViewUsageCreateInfoKHR struct {
}

type _vkImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfoKHR

func (s *_vkImageViewUsageCreateInfoKHR) Goify() *ImageViewUsageCreateInfoKHR {
	rval := (*ImageViewUsageCreateInfoKHR)(s)
	return rval
}
func (s *ImageViewUsageCreateInfoKHR) Vulkanize() *_vkImageViewUsageCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkImageViewUsageCreateInfoKHR)(s)
	return rval
}

// ImportFenceFdInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportFenceFdInfoKHR.html
type ImportFenceFdInfoKHR struct {
	// SType = STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR
	PNext      unsafe.Pointer
	Fence      Fence
	Flags      FenceImportFlags
	HandleType ExternalFenceHandleTypeFlagBits
	Fd         int32
}

type _vkImportFenceFdInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	fence      Fence
	flags      FenceImportFlags
	handleType ExternalFenceHandleTypeFlagBits
	fd         int32
}

func (s *_vkImportFenceFdInfoKHR) Goify() *ImportFenceFdInfoKHR {
	rval := &ImportFenceFdInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		Fence:      (Fence)(s.fence),
		Flags:      (FenceImportFlags)(s.flags),
		HandleType: (ExternalFenceHandleTypeFlagBits)(s.handleType),
		Fd:         (int32)(s.fd),
	}
	return rval
}
func (s *ImportFenceFdInfoKHR) Vulkanize() *_vkImportFenceFdInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkImportFenceFdInfoKHR{
		sType:      STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,         /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                       /*cb*/
		fence:      (Fence)(s.Fence),                                /*cb*/
		flags:      (FenceImportFlags)(s.Flags),                     /*cb*/
		handleType: (ExternalFenceHandleTypeFlagBits)(s.HandleType), /*cb*/
		fd:         (int32)(s.Fd),                                   /*cb*/
	}
	return rval
}

// ImportMemoryFdInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryFdInfoKHR.html
type ImportMemoryFdInfoKHR struct {
	// SType = STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR
	PNext      unsafe.Pointer
	HandleType ExternalMemoryHandleTypeFlagBits
	Fd         int32
}

type _vkImportMemoryFdInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	handleType ExternalMemoryHandleTypeFlagBits
	fd         int32
}

func (s *_vkImportMemoryFdInfoKHR) Goify() *ImportMemoryFdInfoKHR {
	rval := &ImportMemoryFdInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		HandleType: (ExternalMemoryHandleTypeFlagBits)(s.handleType),
		Fd:         (int32)(s.fd),
	}
	return rval
}
func (s *ImportMemoryFdInfoKHR) Vulkanize() *_vkImportMemoryFdInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkImportMemoryFdInfoKHR{
		sType:      STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,         /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                        /*cb*/
		handleType: (ExternalMemoryHandleTypeFlagBits)(s.HandleType), /*cb*/
		fd:         (int32)(s.Fd),                                    /*cb*/
	}
	return rval
}

// ImportMemoryHostPointerInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryHostPointerInfoEXT.html
type ImportMemoryHostPointerInfoEXT struct {
	// SType = STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT
	PNext        unsafe.Pointer
	HandleType   ExternalMemoryHandleTypeFlagBits
	PHostPointer unsafe.Pointer
}

type _vkImportMemoryHostPointerInfoEXT struct {
	sType        StructureType
	pNext        unsafe.Pointer
	handleType   ExternalMemoryHandleTypeFlagBits
	pHostPointer unsafe.Pointer
}

func (s *_vkImportMemoryHostPointerInfoEXT) Goify() *ImportMemoryHostPointerInfoEXT {
	rval := &ImportMemoryHostPointerInfoEXT{
		PNext:        (unsafe.Pointer)(s.pNext),
		HandleType:   (ExternalMemoryHandleTypeFlagBits)(s.handleType),
		PHostPointer: (unsafe.Pointer)(s.pHostPointer),
	}
	return rval
}
func (s *ImportMemoryHostPointerInfoEXT) Vulkanize() *_vkImportMemoryHostPointerInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkImportMemoryHostPointerInfoEXT{
		sType:        STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                          /*cb*/
		handleType:   (ExternalMemoryHandleTypeFlagBits)(s.HandleType),   /*cb*/
		pHostPointer: (unsafe.Pointer)(s.PHostPointer),                   /*cb*/
	}
	return rval
}

// ImportSemaphoreFdInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreFdInfoKHR.html
type ImportSemaphoreFdInfoKHR struct {
	// SType = STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR
	PNext      unsafe.Pointer
	Semaphore  Semaphore
	Flags      SemaphoreImportFlags
	HandleType ExternalSemaphoreHandleTypeFlagBits
	Fd         int32
}

type _vkImportSemaphoreFdInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	semaphore  Semaphore
	flags      SemaphoreImportFlags
	handleType ExternalSemaphoreHandleTypeFlagBits
	fd         int32
}

func (s *_vkImportSemaphoreFdInfoKHR) Goify() *ImportSemaphoreFdInfoKHR {
	rval := &ImportSemaphoreFdInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		Semaphore:  (Semaphore)(s.semaphore),
		Flags:      (SemaphoreImportFlags)(s.flags),
		HandleType: (ExternalSemaphoreHandleTypeFlagBits)(s.handleType),
		Fd:         (int32)(s.fd),
	}
	return rval
}
func (s *ImportSemaphoreFdInfoKHR) Vulkanize() *_vkImportSemaphoreFdInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkImportSemaphoreFdInfoKHR{
		sType:      STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,         /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                           /*cb*/
		semaphore:  (Semaphore)(s.Semaphore),                            /*cb*/
		flags:      (SemaphoreImportFlags)(s.Flags),                     /*cb*/
		handleType: (ExternalSemaphoreHandleTypeFlagBits)(s.HandleType), /*cb*/
		fd:         (int32)(s.Fd),                                       /*cb*/
	}
	return rval
}

// IndirectCommandsLayoutCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html
type IndirectCommandsLayoutCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV
	PNext             unsafe.Pointer
	Flags             IndirectCommandsLayoutUsageFlagsNV
	PipelineBindPoint PipelineBindPoint
	// tokenCount
	PTokens []IndirectCommandsLayoutTokenNV
	// streamCount
	PStreamStrides []uint32
}

type _vkIndirectCommandsLayoutCreateInfoNV struct {
	sType             StructureType
	pNext             unsafe.Pointer
	flags             IndirectCommandsLayoutUsageFlagsNV
	pipelineBindPoint PipelineBindPoint
	tokenCount        uint32
	pTokens           *_vkIndirectCommandsLayoutTokenNV
	streamCount       uint32
	pStreamStrides    *uint32
}

func (s *_vkIndirectCommandsLayoutCreateInfoNV) Goify() *IndirectCommandsLayoutCreateInfoNV {
	rval := &IndirectCommandsLayoutCreateInfoNV{
		PNext:             (unsafe.Pointer)(s.pNext),
		Flags:             (IndirectCommandsLayoutUsageFlagsNV)(s.flags),
		PipelineBindPoint: (PipelineBindPoint)(s.pipelineBindPoint),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pTokens in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStreamStrides in returned struct
	}
	return rval
}
func (s *IndirectCommandsLayoutCreateInfoNV) Vulkanize() *_vkIndirectCommandsLayoutCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pTokens *_vkIndirectCommandsLayoutTokenNV
	if len(s.PTokens) > 0 {
		sl_pTokens := make([]_vkIndirectCommandsLayoutTokenNV, len(s.PTokens))
		for i, v := range s.PTokens {
			sl_pTokens[i] = *(v.Vulkanize())
		}
		psl_pTokens = &sl_pTokens[0]
	}

	var psl_pStreamStrides *uint32
	if len(s.PStreamStrides) > 0 {
		psl_pStreamStrides = &s.PStreamStrides[0]
	}
	rval := &_vkIndirectCommandsLayoutCreateInfoNV{
		sType:             STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                              /*cb*/
		flags:             (IndirectCommandsLayoutUsageFlagsNV)(s.Flags),          /*cb*/
		pipelineBindPoint: (PipelineBindPoint)(s.PipelineBindPoint),               /*cb*/
		tokenCount:        uint32(len(s.PTokens)),                                 /*c6-a*/
		pTokens:           psl_pTokens,                                            /*c rem*/
		streamCount:       uint32(len(s.PStreamStrides)),                          /*c6-a*/
		pStreamStrides:    psl_pStreamStrides,                                     /*c rem*/
	}
	return rval
}

// IndirectCommandsLayoutTokenNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html
type IndirectCommandsLayoutTokenNV struct {
	// SType = STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV
	PNext                        unsafe.Pointer
	TokenType                    IndirectCommandsTokenTypeNV
	Stream                       uint32
	Offset                       uint32
	VertexBindingUnit            uint32
	VertexDynamicStride          bool
	PushconstantPipelineLayout   PipelineLayout
	PushconstantShaderStageFlags ShaderStageFlags
	PushconstantOffset           uint32
	PushconstantSize             uint32
	IndirectStateFlags           IndirectStateFlagsNV
	// indexTypeCount
	PIndexTypes      []IndexType
	PIndexTypeValues []uint32
}

type _vkIndirectCommandsLayoutTokenNV struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	tokenType                    IndirectCommandsTokenTypeNV
	stream                       uint32
	offset                       uint32
	vertexBindingUnit            uint32
	vertexDynamicStride          Bool32
	pushconstantPipelineLayout   PipelineLayout
	pushconstantShaderStageFlags ShaderStageFlags
	pushconstantOffset           uint32
	pushconstantSize             uint32
	indirectStateFlags           IndirectStateFlagsNV
	indexTypeCount               uint32
	pIndexTypes                  *IndexType
	pIndexTypeValues             *uint32
}

func (s *_vkIndirectCommandsLayoutTokenNV) Goify() *IndirectCommandsLayoutTokenNV {
	rval := &IndirectCommandsLayoutTokenNV{
		PNext:                        (unsafe.Pointer)(s.pNext),
		TokenType:                    (IndirectCommandsTokenTypeNV)(s.tokenType),
		Stream:                       (uint32)(s.stream),
		Offset:                       (uint32)(s.offset),
		VertexBindingUnit:            (uint32)(s.vertexBindingUnit),
		VertexDynamicStride:          translatePublic_Bool32(s.vertexDynamicStride), /*default*/
		PushconstantPipelineLayout:   (PipelineLayout)(s.pushconstantPipelineLayout),
		PushconstantShaderStageFlags: (ShaderStageFlags)(s.pushconstantShaderStageFlags),
		PushconstantOffset:           (uint32)(s.pushconstantOffset),
		PushconstantSize:             (uint32)(s.pushconstantSize),
		IndirectStateFlags:           (IndirectStateFlagsNV)(s.indirectStateFlags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pIndexTypes in returned struct
		// Unexpected pointer member pIndexTypeValues in returned struct
	}
	return rval
}
func (s *IndirectCommandsLayoutTokenNV) Vulkanize() *_vkIndirectCommandsLayoutTokenNV {
	if s == nil {
		return nil
	}

	var psl_pIndexTypes *IndexType
	if len(s.PIndexTypes) > 0 {
		psl_pIndexTypes = &s.PIndexTypes[0]
	}

	var psl_pIndexTypeValues *uint32
	if len(s.PIndexTypeValues) > 0 {
		psl_pIndexTypeValues = &s.PIndexTypeValues[0]
	}
	rval := &_vkIndirectCommandsLayoutTokenNV{
		sType:                        STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,   /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                          /*cb*/
		tokenType:                    (IndirectCommandsTokenTypeNV)(s.TokenType),         /*cb*/
		stream:                       (uint32)(s.Stream),                                 /*cb*/
		offset:                       (uint32)(s.Offset),                                 /*cb*/
		vertexBindingUnit:            (uint32)(s.VertexBindingUnit),                      /*cb*/
		vertexDynamicStride:          translateInternal_Bool32(s.VertexDynamicStride),    /*default*/
		pushconstantPipelineLayout:   (PipelineLayout)(s.PushconstantPipelineLayout),     /*cb*/
		pushconstantShaderStageFlags: (ShaderStageFlags)(s.PushconstantShaderStageFlags), /*cb*/
		pushconstantOffset:           (uint32)(s.PushconstantOffset),                     /*cb*/
		pushconstantSize:             (uint32)(s.PushconstantSize),                       /*cb*/
		indirectStateFlags:           (IndirectStateFlagsNV)(s.IndirectStateFlags),       /*cb*/
		pIndexTypes:                  psl_pIndexTypes,                                    /*c rem*/
		pIndexTypeValues:             psl_pIndexTypeValues,                               /*c rem*/
	}
	rval.indexTypeCount = 0 // c6-b
	if uint32(len(s.PIndexTypes)) > rval.indexTypeCount {
		rval.indexTypeCount = uint32(len(s.PIndexTypes))
	}
	if uint32(len(s.PIndexTypeValues)) > rval.indexTypeCount {
		rval.indexTypeCount = uint32(len(s.PIndexTypeValues))
	}
	return rval
}

// IndirectCommandsStreamNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsStreamNV.html
type IndirectCommandsStreamNV struct {
	Buffer Buffer
	Offset DeviceSize
}

type _vkIndirectCommandsStreamNV = IndirectCommandsStreamNV

func (s *_vkIndirectCommandsStreamNV) Goify() *IndirectCommandsStreamNV {
	rval := (*IndirectCommandsStreamNV)(s)
	return rval
}
func (s *IndirectCommandsStreamNV) Vulkanize() *_vkIndirectCommandsStreamNV {
	if s == nil {
		return nil
	}
	rval := (*_vkIndirectCommandsStreamNV)(s)
	return rval
}

// InitializePerformanceApiInfoINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInitializePerformanceApiInfoINTEL.html
type InitializePerformanceApiInfoINTEL struct {
	// SType = STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL
	PNext     unsafe.Pointer
	PUserData unsafe.Pointer
}

type _vkInitializePerformanceApiInfoINTEL struct {
	sType     StructureType
	pNext     unsafe.Pointer
	pUserData unsafe.Pointer
}

func (s *_vkInitializePerformanceApiInfoINTEL) Goify() *InitializePerformanceApiInfoINTEL {
	rval := &InitializePerformanceApiInfoINTEL{
		PNext:     (unsafe.Pointer)(s.pNext),
		PUserData: (unsafe.Pointer)(s.pUserData),
	}
	return rval
}
func (s *InitializePerformanceApiInfoINTEL) Vulkanize() *_vkInitializePerformanceApiInfoINTEL {
	if s == nil {
		return nil
	}
	rval := &_vkInitializePerformanceApiInfoINTEL{
		sType:     STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                            /*cb*/
		pUserData: (unsafe.Pointer)(s.PUserData),                        /*cb*/
	}
	return rval
}

// InputAttachmentAspectReference: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInputAttachmentAspectReference.html
type InputAttachmentAspectReference struct {
	Subpass              uint32
	InputAttachmentIndex uint32
	AspectMask           ImageAspectFlags
}

type _vkInputAttachmentAspectReference = InputAttachmentAspectReference

func (s *_vkInputAttachmentAspectReference) Goify() *InputAttachmentAspectReference {
	rval := (*InputAttachmentAspectReference)(s)
	return rval
}
func (s *InputAttachmentAspectReference) Vulkanize() *_vkInputAttachmentAspectReference {
	if s == nil {
		return nil
	}
	rval := (*_vkInputAttachmentAspectReference)(s)
	return rval
}

// InputAttachmentAspectReferenceKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInputAttachmentAspectReferenceKHR.html
type InputAttachmentAspectReferenceKHR struct {
}

type _vkInputAttachmentAspectReferenceKHR = InputAttachmentAspectReferenceKHR

func (s *_vkInputAttachmentAspectReferenceKHR) Goify() *InputAttachmentAspectReferenceKHR {
	rval := (*InputAttachmentAspectReferenceKHR)(s)
	return rval
}
func (s *InputAttachmentAspectReferenceKHR) Vulkanize() *_vkInputAttachmentAspectReferenceKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkInputAttachmentAspectReferenceKHR)(s)
	return rval
}

// InstanceCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateInfo.html
type InstanceCreateInfo struct {
	// SType = STRUCTURE_TYPE_INSTANCE_CREATE_INFO
	PNext            unsafe.Pointer
	Flags            InstanceCreateFlags
	PApplicationInfo *ApplicationInfo
	// enabledLayerCount
	//  Ordered list of layer names to be enabled;
	PpEnabledLayerNames []string
	// enabledExtensionCount
	//  Extension names to be enabled;
	PpEnabledExtensionNames []string
}

type _vkInstanceCreateInfo struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	flags                   InstanceCreateFlags
	pApplicationInfo        *_vkApplicationInfo
	enabledLayerCount       uint32
	ppEnabledLayerNames     **byte
	enabledExtensionCount   uint32
	ppEnabledExtensionNames **byte
}

func (s *_vkInstanceCreateInfo) Goify() *InstanceCreateInfo {
	rval := &InstanceCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (InstanceCreateFlags)(s.flags),
		// Unexpected pointer member pApplicationInfo in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member ppEnabledLayerNames in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member ppEnabledExtensionNames in returned struct
	}
	return rval
}
func (s *InstanceCreateInfo) Vulkanize() *_vkInstanceCreateInfo {
	if s == nil {
		return nil
	}

	var psl_ppEnabledLayerNames **byte
	if len(s.PpEnabledLayerNames) > 0 {
		sl_ppEnabledLayerNames := make([]*byte, len(s.PpEnabledLayerNames))
		for i, v := range s.PpEnabledLayerNames {
			sl_ppEnabledLayerNames[i] = sys_stringToBytePointer(v)
		}
		psl_ppEnabledLayerNames = &sl_ppEnabledLayerNames[0]
	}

	var psl_ppEnabledExtensionNames **byte
	if len(s.PpEnabledExtensionNames) > 0 {
		sl_ppEnabledExtensionNames := make([]*byte, len(s.PpEnabledExtensionNames))
		for i, v := range s.PpEnabledExtensionNames {
			sl_ppEnabledExtensionNames[i] = sys_stringToBytePointer(v)
		}
		psl_ppEnabledExtensionNames = &sl_ppEnabledExtensionNames[0]
	}
	rval := &_vkInstanceCreateInfo{
		sType:                   STRUCTURE_TYPE_INSTANCE_CREATE_INFO,    /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),              /*cb*/
		flags:                   (InstanceCreateFlags)(s.Flags),         /*cb*/
		pApplicationInfo:        (s.PApplicationInfo.Vulkanize()),       /*c rem*/
		enabledLayerCount:       uint32(len(s.PpEnabledLayerNames)),     /*c6-a*/
		ppEnabledLayerNames:     psl_ppEnabledLayerNames,                /*c rem*/
		enabledExtensionCount:   uint32(len(s.PpEnabledExtensionNames)), /*c6-a*/
		ppEnabledExtensionNames: psl_ppEnabledExtensionNames,            /*c rem*/
	}
	return rval
}

// LatencySleepInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLatencySleepInfoNV.html
type LatencySleepInfoNV struct {
	// SType = STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV
	PNext           unsafe.Pointer
	SignalSemaphore Semaphore
	Value           uint64
}

type _vkLatencySleepInfoNV struct {
	sType           StructureType
	pNext           unsafe.Pointer
	signalSemaphore Semaphore
	value           uint64
}

func (s *_vkLatencySleepInfoNV) Goify() *LatencySleepInfoNV {
	rval := &LatencySleepInfoNV{
		PNext:           (unsafe.Pointer)(s.pNext),
		SignalSemaphore: (Semaphore)(s.signalSemaphore),
		Value:           (uint64)(s.value),
	}
	return rval
}
func (s *LatencySleepInfoNV) Vulkanize() *_vkLatencySleepInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkLatencySleepInfoNV{
		sType:           STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),            /*cb*/
		signalSemaphore: (Semaphore)(s.SignalSemaphore),       /*cb*/
		value:           (uint64)(s.Value),                    /*cb*/
	}
	return rval
}

// LatencySleepModeInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLatencySleepModeInfoNV.html
type LatencySleepModeInfoNV struct {
	// SType = STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV
	PNext             unsafe.Pointer
	LowLatencyMode    bool
	LowLatencyBoost   bool
	MinimumIntervalUs uint32
}

type _vkLatencySleepModeInfoNV struct {
	sType             StructureType
	pNext             unsafe.Pointer
	lowLatencyMode    Bool32
	lowLatencyBoost   Bool32
	minimumIntervalUs uint32
}

func (s *_vkLatencySleepModeInfoNV) Goify() *LatencySleepModeInfoNV {
	rval := &LatencySleepModeInfoNV{
		PNext:             (unsafe.Pointer)(s.pNext),
		LowLatencyMode:    translatePublic_Bool32(s.lowLatencyMode),  /*default*/
		LowLatencyBoost:   translatePublic_Bool32(s.lowLatencyBoost), /*default*/
		MinimumIntervalUs: (uint32)(s.minimumIntervalUs),
	}
	return rval
}
func (s *LatencySleepModeInfoNV) Vulkanize() *_vkLatencySleepModeInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkLatencySleepModeInfoNV{
		sType:             STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV,   /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                   /*cb*/
		lowLatencyMode:    translateInternal_Bool32(s.LowLatencyMode),  /*default*/
		lowLatencyBoost:   translateInternal_Bool32(s.LowLatencyBoost), /*default*/
		minimumIntervalUs: (uint32)(s.MinimumIntervalUs),               /*cb*/
	}
	return rval
}

// LatencySubmissionPresentIdNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLatencySubmissionPresentIdNV.html
type LatencySubmissionPresentIdNV struct {
	// SType = STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV
	PNext     unsafe.Pointer
	PresentID uint64
}

type _vkLatencySubmissionPresentIdNV struct {
	sType     StructureType
	pNext     unsafe.Pointer
	presentID uint64
}

func (s *_vkLatencySubmissionPresentIdNV) Goify() *LatencySubmissionPresentIdNV {
	rval := &LatencySubmissionPresentIdNV{
		PNext:     (unsafe.Pointer)(s.pNext),
		PresentID: (uint64)(s.presentID),
	}
	return rval
}
func (s *LatencySubmissionPresentIdNV) Vulkanize() *_vkLatencySubmissionPresentIdNV {
	if s == nil {
		return nil
	}
	rval := &_vkLatencySubmissionPresentIdNV{
		sType:     STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                       /*cb*/
		presentID: (uint64)(s.PresentID),                           /*cb*/
	}
	return rval
}

// LatencySurfaceCapabilitiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLatencySurfaceCapabilitiesNV.html
type LatencySurfaceCapabilitiesNV struct {
	// SType = STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV
	PNext unsafe.Pointer
	// presentModeCount
	PPresentModes []PresentModeKHR
}

type _vkLatencySurfaceCapabilitiesNV struct {
	sType            StructureType
	pNext            unsafe.Pointer
	presentModeCount uint32
	pPresentModes    *PresentModeKHR
}

func (s *_vkLatencySurfaceCapabilitiesNV) Goify() *LatencySurfaceCapabilitiesNV {
	rval := &LatencySurfaceCapabilitiesNV{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPresentModes in returned struct
	}
	return rval
}
func (s *LatencySurfaceCapabilitiesNV) Vulkanize() *_vkLatencySurfaceCapabilitiesNV {
	if s == nil {
		return nil
	}

	var psl_pPresentModes *PresentModeKHR
	if len(s.PPresentModes) > 0 {
		psl_pPresentModes = &s.PPresentModes[0]
	}
	rval := &_vkLatencySurfaceCapabilitiesNV{
		sType:            STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                      /*cb*/
		presentModeCount: uint32(len(s.PPresentModes)),                   /*c6-a*/
		pPresentModes:    psl_pPresentModes,                              /*c rem*/
	}
	return rval
}

// LatencyTimingsFrameReportNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLatencyTimingsFrameReportNV.html
type LatencyTimingsFrameReportNV struct {
	// SType = STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV
	PNext                    unsafe.Pointer
	PresentID                uint64
	InputSampleTimeUs        uint64
	SimStartTimeUs           uint64
	SimEndTimeUs             uint64
	RenderSubmitStartTimeUs  uint64
	RenderSubmitEndTimeUs    uint64
	PresentStartTimeUs       uint64
	PresentEndTimeUs         uint64
	DriverStartTimeUs        uint64
	DriverEndTimeUs          uint64
	OsRenderQueueStartTimeUs uint64
	OsRenderQueueEndTimeUs   uint64
	GpuRenderStartTimeUs     uint64
	GpuRenderEndTimeUs       uint64
}

type _vkLatencyTimingsFrameReportNV struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	presentID                uint64
	inputSampleTimeUs        uint64
	simStartTimeUs           uint64
	simEndTimeUs             uint64
	renderSubmitStartTimeUs  uint64
	renderSubmitEndTimeUs    uint64
	presentStartTimeUs       uint64
	presentEndTimeUs         uint64
	driverStartTimeUs        uint64
	driverEndTimeUs          uint64
	osRenderQueueStartTimeUs uint64
	osRenderQueueEndTimeUs   uint64
	gpuRenderStartTimeUs     uint64
	gpuRenderEndTimeUs       uint64
}

func (s *_vkLatencyTimingsFrameReportNV) Goify() *LatencyTimingsFrameReportNV {
	rval := &LatencyTimingsFrameReportNV{
		PNext:                    (unsafe.Pointer)(s.pNext),
		PresentID:                (uint64)(s.presentID),
		InputSampleTimeUs:        (uint64)(s.inputSampleTimeUs),
		SimStartTimeUs:           (uint64)(s.simStartTimeUs),
		SimEndTimeUs:             (uint64)(s.simEndTimeUs),
		RenderSubmitStartTimeUs:  (uint64)(s.renderSubmitStartTimeUs),
		RenderSubmitEndTimeUs:    (uint64)(s.renderSubmitEndTimeUs),
		PresentStartTimeUs:       (uint64)(s.presentStartTimeUs),
		PresentEndTimeUs:         (uint64)(s.presentEndTimeUs),
		DriverStartTimeUs:        (uint64)(s.driverStartTimeUs),
		DriverEndTimeUs:          (uint64)(s.driverEndTimeUs),
		OsRenderQueueStartTimeUs: (uint64)(s.osRenderQueueStartTimeUs),
		OsRenderQueueEndTimeUs:   (uint64)(s.osRenderQueueEndTimeUs),
		GpuRenderStartTimeUs:     (uint64)(s.gpuRenderStartTimeUs),
		GpuRenderEndTimeUs:       (uint64)(s.gpuRenderEndTimeUs),
	}
	return rval
}
func (s *LatencyTimingsFrameReportNV) Vulkanize() *_vkLatencyTimingsFrameReportNV {
	if s == nil {
		return nil
	}
	rval := &_vkLatencyTimingsFrameReportNV{
		sType:                    STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                      /*cb*/
		presentID:                (uint64)(s.PresentID),                          /*cb*/
		inputSampleTimeUs:        (uint64)(s.InputSampleTimeUs),                  /*cb*/
		simStartTimeUs:           (uint64)(s.SimStartTimeUs),                     /*cb*/
		simEndTimeUs:             (uint64)(s.SimEndTimeUs),                       /*cb*/
		renderSubmitStartTimeUs:  (uint64)(s.RenderSubmitStartTimeUs),            /*cb*/
		renderSubmitEndTimeUs:    (uint64)(s.RenderSubmitEndTimeUs),              /*cb*/
		presentStartTimeUs:       (uint64)(s.PresentStartTimeUs),                 /*cb*/
		presentEndTimeUs:         (uint64)(s.PresentEndTimeUs),                   /*cb*/
		driverStartTimeUs:        (uint64)(s.DriverStartTimeUs),                  /*cb*/
		driverEndTimeUs:          (uint64)(s.DriverEndTimeUs),                    /*cb*/
		osRenderQueueStartTimeUs: (uint64)(s.OsRenderQueueStartTimeUs),           /*cb*/
		osRenderQueueEndTimeUs:   (uint64)(s.OsRenderQueueEndTimeUs),             /*cb*/
		gpuRenderStartTimeUs:     (uint64)(s.GpuRenderStartTimeUs),               /*cb*/
		gpuRenderEndTimeUs:       (uint64)(s.GpuRenderEndTimeUs),                 /*cb*/
	}
	return rval
}

// LayerProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLayerProperties.html
type LayerProperties struct {
	//  layer name;
	LayerName string
	//  version of the layer specification implemented;
	SpecVersion uint32
	//  build or release version of the layer's library;
	ImplementationVersion uint32
	//  Free-form description of the layer;
	Description string
}

// WARNING - struct LayerProperties is returned only, which is not yet handled in the binding
type _vkLayerProperties struct {
	layerName             [MAX_EXTENSION_NAME_SIZE]byte
	specVersion           uint32
	implementationVersion uint32
	description           [MAX_DESCRIPTION_SIZE]byte
}

func (s *_vkLayerProperties) Goify() *LayerProperties {
	rval := &LayerProperties{
		LayerName:             nullTermBytesToString(s.layerName[:]), /*c arr*/
		SpecVersion:           (uint32)(s.specVersion),
		ImplementationVersion: (uint32)(s.implementationVersion),
		Description:           nullTermBytesToString(s.description[:]), /*c arr*/
	}
	return rval
}
func (s *LayerProperties) Vulkanize() *_vkLayerProperties {
	if s == nil {
		return nil
	}
	rval := &_vkLayerProperties{
		// layerName : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		specVersion:           (uint32)(s.SpecVersion),           /*cb*/
		implementationVersion: (uint32)(s.ImplementationVersion), /*cb*/
		// description : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
	}
	return rval
}

// MappedMemoryRange: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMappedMemoryRange.html
type MappedMemoryRange struct {
	// SType = STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
	PNext unsafe.Pointer
	//  Mapped memory object;
	Memory DeviceMemory
	//  Offset within the memory object where the range starts;
	Offset DeviceSize
	//  Size of the range within the memory object;
	Size DeviceSize
}

type _vkMappedMemoryRange struct {
	sType  StructureType
	pNext  unsafe.Pointer
	memory DeviceMemory
	offset DeviceSize
	size   DeviceSize
}

func (s *_vkMappedMemoryRange) Goify() *MappedMemoryRange {
	rval := &MappedMemoryRange{
		PNext:  (unsafe.Pointer)(s.pNext),
		Memory: (DeviceMemory)(s.memory),
		Offset: (DeviceSize)(s.offset),
		Size:   (DeviceSize)(s.size),
	}
	return rval
}
func (s *MappedMemoryRange) Vulkanize() *_vkMappedMemoryRange {
	if s == nil {
		return nil
	}
	rval := &_vkMappedMemoryRange{
		sType:  STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),          /*cb*/
		memory: (DeviceMemory)(s.Memory),           /*cb*/
		offset: (DeviceSize)(s.Offset),             /*cb*/
		size:   (DeviceSize)(s.Size),               /*cb*/
	}
	return rval
}

// MemoryAllocateFlagsInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlagsInfo.html
type MemoryAllocateFlagsInfo struct {
	// SType = STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO
	PNext      unsafe.Pointer
	Flags      MemoryAllocateFlags
	DeviceMask uint32
}

type _vkMemoryAllocateFlagsInfo struct {
	sType      StructureType
	pNext      unsafe.Pointer
	flags      MemoryAllocateFlags
	deviceMask uint32
}

func (s *_vkMemoryAllocateFlagsInfo) Goify() *MemoryAllocateFlagsInfo {
	rval := &MemoryAllocateFlagsInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		Flags:      (MemoryAllocateFlags)(s.flags),
		DeviceMask: (uint32)(s.deviceMask),
	}
	return rval
}
func (s *MemoryAllocateFlagsInfo) Vulkanize() *_vkMemoryAllocateFlagsInfo {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryAllocateFlagsInfo{
		sType:      STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                 /*cb*/
		flags:      (MemoryAllocateFlags)(s.Flags),            /*cb*/
		deviceMask: (uint32)(s.DeviceMask),                    /*cb*/
	}
	return rval
}

// MemoryAllocateFlagsInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlagsInfoKHR.html
type MemoryAllocateFlagsInfoKHR struct {
}

type _vkMemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfoKHR

func (s *_vkMemoryAllocateFlagsInfoKHR) Goify() *MemoryAllocateFlagsInfoKHR {
	rval := (*MemoryAllocateFlagsInfoKHR)(s)
	return rval
}
func (s *MemoryAllocateFlagsInfoKHR) Vulkanize() *_vkMemoryAllocateFlagsInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkMemoryAllocateFlagsInfoKHR)(s)
	return rval
}

// MemoryAllocateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateInfo.html
type MemoryAllocateInfo struct {
	// SType = STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
	PNext unsafe.Pointer
	//  Size of memory allocation;
	AllocationSize DeviceSize
	//  Index of the of the memory type to allocate from;
	MemoryTypeIndex uint32
}

type _vkMemoryAllocateInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	allocationSize  DeviceSize
	memoryTypeIndex uint32
}

func (s *_vkMemoryAllocateInfo) Goify() *MemoryAllocateInfo {
	rval := &MemoryAllocateInfo{
		PNext:           (unsafe.Pointer)(s.pNext),
		AllocationSize:  (DeviceSize)(s.allocationSize),
		MemoryTypeIndex: (uint32)(s.memoryTypeIndex),
	}
	return rval
}
func (s *MemoryAllocateInfo) Vulkanize() *_vkMemoryAllocateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryAllocateInfo{
		sType:           STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),           /*cb*/
		allocationSize:  (DeviceSize)(s.AllocationSize),      /*cb*/
		memoryTypeIndex: (uint32)(s.MemoryTypeIndex),         /*cb*/
	}
	return rval
}

// MemoryBarrier: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier.html
type MemoryBarrier struct {
	// SType = STRUCTURE_TYPE_MEMORY_BARRIER
	PNext unsafe.Pointer
	//  Memory accesses from the source of the dependency to synchronize;
	SrcAccessMask AccessFlags
	//  Memory accesses from the destination of the dependency to synchronize;
	DstAccessMask AccessFlags
}

type _vkMemoryBarrier struct {
	sType         StructureType
	pNext         unsafe.Pointer
	srcAccessMask AccessFlags
	dstAccessMask AccessFlags
}

func (s *_vkMemoryBarrier) Goify() *MemoryBarrier {
	rval := &MemoryBarrier{
		PNext:         (unsafe.Pointer)(s.pNext),
		SrcAccessMask: (AccessFlags)(s.srcAccessMask),
		DstAccessMask: (AccessFlags)(s.dstAccessMask),
	}
	return rval
}
func (s *MemoryBarrier) Vulkanize() *_vkMemoryBarrier {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryBarrier{
		sType:         STRUCTURE_TYPE_MEMORY_BARRIER,  /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),      /*cb*/
		srcAccessMask: (AccessFlags)(s.SrcAccessMask), /*cb*/
		dstAccessMask: (AccessFlags)(s.DstAccessMask), /*cb*/
	}
	return rval
}

// MemoryBarrier2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier2.html
type MemoryBarrier2 struct {
	// SType = STRUCTURE_TYPE_MEMORY_BARRIER_2
	PNext         unsafe.Pointer
	SrcStageMask  PipelineStageFlags2
	SrcAccessMask AccessFlags2
	DstStageMask  PipelineStageFlags2
	DstAccessMask AccessFlags2
}

type _vkMemoryBarrier2 struct {
	sType         StructureType
	pNext         unsafe.Pointer
	srcStageMask  PipelineStageFlags2
	srcAccessMask AccessFlags2
	dstStageMask  PipelineStageFlags2
	dstAccessMask AccessFlags2
}

func (s *_vkMemoryBarrier2) Goify() *MemoryBarrier2 {
	rval := &MemoryBarrier2{
		PNext:         (unsafe.Pointer)(s.pNext),
		SrcStageMask:  (PipelineStageFlags2)(s.srcStageMask),
		SrcAccessMask: (AccessFlags2)(s.srcAccessMask),
		DstStageMask:  (PipelineStageFlags2)(s.dstStageMask),
		DstAccessMask: (AccessFlags2)(s.dstAccessMask),
	}
	return rval
}
func (s *MemoryBarrier2) Vulkanize() *_vkMemoryBarrier2 {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryBarrier2{
		sType:         STRUCTURE_TYPE_MEMORY_BARRIER_2,       /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),             /*cb*/
		srcStageMask:  (PipelineStageFlags2)(s.SrcStageMask), /*cb*/
		srcAccessMask: (AccessFlags2)(s.SrcAccessMask),       /*cb*/
		dstStageMask:  (PipelineStageFlags2)(s.DstStageMask), /*cb*/
		dstAccessMask: (AccessFlags2)(s.DstAccessMask),       /*cb*/
	}
	return rval
}

// MemoryBarrier2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier2KHR.html
type MemoryBarrier2KHR struct {
}

type _vkMemoryBarrier2KHR = MemoryBarrier2KHR

func (s *_vkMemoryBarrier2KHR) Goify() *MemoryBarrier2KHR {
	rval := (*MemoryBarrier2KHR)(s)
	return rval
}
func (s *MemoryBarrier2KHR) Vulkanize() *_vkMemoryBarrier2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkMemoryBarrier2KHR)(s)
	return rval
}

// MemoryDedicatedAllocateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedAllocateInfo.html
type MemoryDedicatedAllocateInfo struct {
	// SType = STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO
	PNext unsafe.Pointer
	//  Image that this allocation will be bound to;
	Image Image
	//  Buffer that this allocation will be bound to;
	Buffer Buffer
}

type _vkMemoryDedicatedAllocateInfo struct {
	sType  StructureType
	pNext  unsafe.Pointer
	image  Image
	buffer Buffer
}

func (s *_vkMemoryDedicatedAllocateInfo) Goify() *MemoryDedicatedAllocateInfo {
	rval := &MemoryDedicatedAllocateInfo{
		PNext:  (unsafe.Pointer)(s.pNext),
		Image:  (Image)(s.image),
		Buffer: (Buffer)(s.buffer),
	}
	return rval
}
func (s *MemoryDedicatedAllocateInfo) Vulkanize() *_vkMemoryDedicatedAllocateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryDedicatedAllocateInfo{
		sType:  STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                     /*cb*/
		image:  (Image)(s.Image),                              /*cb*/
		buffer: (Buffer)(s.Buffer),                            /*cb*/
	}
	return rval
}

// MemoryDedicatedAllocateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedAllocateInfoKHR.html
type MemoryDedicatedAllocateInfoKHR struct {
}

type _vkMemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfoKHR

func (s *_vkMemoryDedicatedAllocateInfoKHR) Goify() *MemoryDedicatedAllocateInfoKHR {
	rval := (*MemoryDedicatedAllocateInfoKHR)(s)
	return rval
}
func (s *MemoryDedicatedAllocateInfoKHR) Vulkanize() *_vkMemoryDedicatedAllocateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkMemoryDedicatedAllocateInfoKHR)(s)
	return rval
}

// MemoryDedicatedRequirements: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedRequirements.html
type MemoryDedicatedRequirements struct {
	// SType = STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS
	PNext                       unsafe.Pointer
	PrefersDedicatedAllocation  bool
	RequiresDedicatedAllocation bool
}

// WARNING - struct MemoryDedicatedRequirements is returned only, which is not yet handled in the binding
type _vkMemoryDedicatedRequirements struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	prefersDedicatedAllocation  Bool32
	requiresDedicatedAllocation Bool32
}

func (s *_vkMemoryDedicatedRequirements) Goify() *MemoryDedicatedRequirements {
	rval := &MemoryDedicatedRequirements{
		PNext:                       (unsafe.Pointer)(s.pNext),
		PrefersDedicatedAllocation:  translatePublic_Bool32(s.prefersDedicatedAllocation),  /*default*/
		RequiresDedicatedAllocation: translatePublic_Bool32(s.requiresDedicatedAllocation), /*default*/
	}
	return rval
}
func (s *MemoryDedicatedRequirements) Vulkanize() *_vkMemoryDedicatedRequirements {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryDedicatedRequirements{
		sType:                       STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,            /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                               /*cb*/
		prefersDedicatedAllocation:  translateInternal_Bool32(s.PrefersDedicatedAllocation),  /*default*/
		requiresDedicatedAllocation: translateInternal_Bool32(s.RequiresDedicatedAllocation), /*default*/
	}
	return rval
}

// MemoryDedicatedRequirementsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedRequirementsKHR.html
type MemoryDedicatedRequirementsKHR struct {
}

type _vkMemoryDedicatedRequirementsKHR = MemoryDedicatedRequirementsKHR

func (s *_vkMemoryDedicatedRequirementsKHR) Goify() *MemoryDedicatedRequirementsKHR {
	rval := (*MemoryDedicatedRequirementsKHR)(s)
	return rval
}
func (s *MemoryDedicatedRequirementsKHR) Vulkanize() *_vkMemoryDedicatedRequirementsKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkMemoryDedicatedRequirementsKHR)(s)
	return rval
}

// MemoryFdPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryFdPropertiesKHR.html
type MemoryFdPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR
	PNext          unsafe.Pointer
	MemoryTypeBits uint32
}

// WARNING - struct MemoryFdPropertiesKHR is returned only, which is not yet handled in the binding
type _vkMemoryFdPropertiesKHR struct {
	sType          StructureType
	pNext          unsafe.Pointer
	memoryTypeBits uint32
}

func (s *_vkMemoryFdPropertiesKHR) Goify() *MemoryFdPropertiesKHR {
	rval := &MemoryFdPropertiesKHR{
		PNext:          (unsafe.Pointer)(s.pNext),
		MemoryTypeBits: (uint32)(s.memoryTypeBits),
	}
	return rval
}
func (s *MemoryFdPropertiesKHR) Vulkanize() *_vkMemoryFdPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryFdPropertiesKHR{
		sType:          STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),               /*cb*/
		memoryTypeBits: (uint32)(s.MemoryTypeBits),              /*cb*/
	}
	return rval
}

// MemoryGetFdInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetFdInfoKHR.html
type MemoryGetFdInfoKHR struct {
	// SType = STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR
	PNext      unsafe.Pointer
	Memory     DeviceMemory
	HandleType ExternalMemoryHandleTypeFlagBits
}

type _vkMemoryGetFdInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	memory     DeviceMemory
	handleType ExternalMemoryHandleTypeFlagBits
}

func (s *_vkMemoryGetFdInfoKHR) Goify() *MemoryGetFdInfoKHR {
	rval := &MemoryGetFdInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		Memory:     (DeviceMemory)(s.memory),
		HandleType: (ExternalMemoryHandleTypeFlagBits)(s.handleType),
	}
	return rval
}
func (s *MemoryGetFdInfoKHR) Vulkanize() *_vkMemoryGetFdInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryGetFdInfoKHR{
		sType:      STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,            /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                        /*cb*/
		memory:     (DeviceMemory)(s.Memory),                         /*cb*/
		handleType: (ExternalMemoryHandleTypeFlagBits)(s.HandleType), /*cb*/
	}
	return rval
}

// MemoryGetRemoteAddressInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetRemoteAddressInfoNV.html
type MemoryGetRemoteAddressInfoNV struct {
	// SType = STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV
	PNext      unsafe.Pointer
	Memory     DeviceMemory
	HandleType ExternalMemoryHandleTypeFlagBits
}

type _vkMemoryGetRemoteAddressInfoNV struct {
	sType      StructureType
	pNext      unsafe.Pointer
	memory     DeviceMemory
	handleType ExternalMemoryHandleTypeFlagBits
}

func (s *_vkMemoryGetRemoteAddressInfoNV) Goify() *MemoryGetRemoteAddressInfoNV {
	rval := &MemoryGetRemoteAddressInfoNV{
		PNext:      (unsafe.Pointer)(s.pNext),
		Memory:     (DeviceMemory)(s.memory),
		HandleType: (ExternalMemoryHandleTypeFlagBits)(s.handleType),
	}
	return rval
}
func (s *MemoryGetRemoteAddressInfoNV) Vulkanize() *_vkMemoryGetRemoteAddressInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryGetRemoteAddressInfoNV{
		sType:      STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                        /*cb*/
		memory:     (DeviceMemory)(s.Memory),                         /*cb*/
		handleType: (ExternalMemoryHandleTypeFlagBits)(s.HandleType), /*cb*/
	}
	return rval
}

// MemoryHeap: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHeap.html
type MemoryHeap struct {
	//  Available memory in the heap;
	Size DeviceSize
	//  Flags for the heap;
	Flags MemoryHeapFlags
}

type _vkMemoryHeap = MemoryHeap

func (s *_vkMemoryHeap) Goify() *MemoryHeap {
	rval := (*MemoryHeap)(s)
	return rval
}
func (s *MemoryHeap) Vulkanize() *_vkMemoryHeap {
	if s == nil {
		return nil
	}
	rval := (*_vkMemoryHeap)(s)
	return rval
}

// MemoryHostPointerPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHostPointerPropertiesEXT.html
type MemoryHostPointerPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT
	PNext          unsafe.Pointer
	MemoryTypeBits uint32
}

// WARNING - struct MemoryHostPointerPropertiesEXT is returned only, which is not yet handled in the binding
type _vkMemoryHostPointerPropertiesEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	memoryTypeBits uint32
}

func (s *_vkMemoryHostPointerPropertiesEXT) Goify() *MemoryHostPointerPropertiesEXT {
	rval := &MemoryHostPointerPropertiesEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		MemoryTypeBits: (uint32)(s.memoryTypeBits),
	}
	return rval
}
func (s *MemoryHostPointerPropertiesEXT) Vulkanize() *_vkMemoryHostPointerPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryHostPointerPropertiesEXT{
		sType:          STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                         /*cb*/
		memoryTypeBits: (uint32)(s.MemoryTypeBits),                        /*cb*/
	}
	return rval
}

// MemoryMapInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryMapInfoKHR.html
type MemoryMapInfoKHR struct {
	// SType = STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR
	PNext  unsafe.Pointer
	Flags  MemoryMapFlags
	Memory DeviceMemory
	Offset DeviceSize
	Size   DeviceSize
}

type _vkMemoryMapInfoKHR struct {
	sType  StructureType
	pNext  unsafe.Pointer
	flags  MemoryMapFlags
	memory DeviceMemory
	offset DeviceSize
	size   DeviceSize
}

func (s *_vkMemoryMapInfoKHR) Goify() *MemoryMapInfoKHR {
	rval := &MemoryMapInfoKHR{
		PNext:  (unsafe.Pointer)(s.pNext),
		Flags:  (MemoryMapFlags)(s.flags),
		Memory: (DeviceMemory)(s.memory),
		Offset: (DeviceSize)(s.offset),
		Size:   (DeviceSize)(s.size),
	}
	return rval
}
func (s *MemoryMapInfoKHR) Vulkanize() *_vkMemoryMapInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryMapInfoKHR{
		sType:  STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),          /*cb*/
		flags:  (MemoryMapFlags)(s.Flags),          /*cb*/
		memory: (DeviceMemory)(s.Memory),           /*cb*/
		offset: (DeviceSize)(s.Offset),             /*cb*/
		size:   (DeviceSize)(s.Size),               /*cb*/
	}
	return rval
}

// MemoryOpaqueCaptureAddressAllocateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html
type MemoryOpaqueCaptureAddressAllocateInfo struct {
	// SType = STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO
	PNext                unsafe.Pointer
	OpaqueCaptureAddress uint64
}

type _vkMemoryOpaqueCaptureAddressAllocateInfo struct {
	sType                StructureType
	pNext                unsafe.Pointer
	opaqueCaptureAddress uint64
}

func (s *_vkMemoryOpaqueCaptureAddressAllocateInfo) Goify() *MemoryOpaqueCaptureAddressAllocateInfo {
	rval := &MemoryOpaqueCaptureAddressAllocateInfo{
		PNext:                (unsafe.Pointer)(s.pNext),
		OpaqueCaptureAddress: (uint64)(s.opaqueCaptureAddress),
	}
	return rval
}
func (s *MemoryOpaqueCaptureAddressAllocateInfo) Vulkanize() *_vkMemoryOpaqueCaptureAddressAllocateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryOpaqueCaptureAddressAllocateInfo{
		sType:                STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                  /*cb*/
		opaqueCaptureAddress: (uint64)(s.OpaqueCaptureAddress),                           /*cb*/
	}
	return rval
}

// MemoryOpaqueCaptureAddressAllocateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryOpaqueCaptureAddressAllocateInfoKHR.html
type MemoryOpaqueCaptureAddressAllocateInfoKHR struct {
}

type _vkMemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfoKHR

func (s *_vkMemoryOpaqueCaptureAddressAllocateInfoKHR) Goify() *MemoryOpaqueCaptureAddressAllocateInfoKHR {
	rval := (*MemoryOpaqueCaptureAddressAllocateInfoKHR)(s)
	return rval
}
func (s *MemoryOpaqueCaptureAddressAllocateInfoKHR) Vulkanize() *_vkMemoryOpaqueCaptureAddressAllocateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkMemoryOpaqueCaptureAddressAllocateInfoKHR)(s)
	return rval
}

// MemoryPriorityAllocateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryPriorityAllocateInfoEXT.html
type MemoryPriorityAllocateInfoEXT struct {
	// SType = STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT
	PNext    unsafe.Pointer
	Priority float32
}

type _vkMemoryPriorityAllocateInfoEXT struct {
	sType    StructureType
	pNext    unsafe.Pointer
	priority float32
}

func (s *_vkMemoryPriorityAllocateInfoEXT) Goify() *MemoryPriorityAllocateInfoEXT {
	rval := &MemoryPriorityAllocateInfoEXT{
		PNext:    (unsafe.Pointer)(s.pNext),
		Priority: (float32)(s.priority),
	}
	return rval
}
func (s *MemoryPriorityAllocateInfoEXT) Vulkanize() *_vkMemoryPriorityAllocateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryPriorityAllocateInfoEXT{
		sType:    STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                        /*cb*/
		priority: (float32)(s.Priority),                            /*cb*/
	}
	return rval
}

// MemoryRequirements: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements.html
type MemoryRequirements struct {
	//  Specified in bytes;
	Size DeviceSize
	//  Specified in bytes;
	Alignment DeviceSize
	//  Bitmask of the allowed memory type indices into memoryTypes[] for this object;
	MemoryTypeBits uint32
}

type _vkMemoryRequirements = MemoryRequirements

func (s *_vkMemoryRequirements) Goify() *MemoryRequirements {
	rval := (*MemoryRequirements)(s)
	return rval
}
func (s *MemoryRequirements) Vulkanize() *_vkMemoryRequirements {
	if s == nil {
		return nil
	}
	rval := (*_vkMemoryRequirements)(s)
	return rval
}

// MemoryRequirements2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements2.html
type MemoryRequirements2 struct {
	// SType = STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2
	PNext              unsafe.Pointer
	MemoryRequirements MemoryRequirements
}

// WARNING - struct MemoryRequirements2 is returned only, which is not yet handled in the binding
type _vkMemoryRequirements2 struct {
	sType              StructureType
	pNext              unsafe.Pointer
	memoryRequirements _vkMemoryRequirements
}

func (s *_vkMemoryRequirements2) Goify() *MemoryRequirements2 {
	rval := &MemoryRequirements2{
		PNext:              (unsafe.Pointer)(s.pNext),
		MemoryRequirements: (MemoryRequirements)(s.memoryRequirements),
	}
	return rval
}
func (s *MemoryRequirements2) Vulkanize() *_vkMemoryRequirements2 {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryRequirements2{
		sType:              STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,          /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                     /*cb*/
		memoryRequirements: (_vkMemoryRequirements)(s.MemoryRequirements), /*cb*/
	}
	return rval
}

// MemoryRequirements2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements2KHR.html
type MemoryRequirements2KHR struct {
}

type _vkMemoryRequirements2KHR = MemoryRequirements2KHR

func (s *_vkMemoryRequirements2KHR) Goify() *MemoryRequirements2KHR {
	rval := (*MemoryRequirements2KHR)(s)
	return rval
}
func (s *MemoryRequirements2KHR) Vulkanize() *_vkMemoryRequirements2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkMemoryRequirements2KHR)(s)
	return rval
}

// MemoryToImageCopyEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryToImageCopyEXT.html
type MemoryToImageCopyEXT struct {
	// SType = STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT
	PNext        unsafe.Pointer
	PHostPointer unsafe.Pointer
	//  Specified in texels;
	MemoryRowLength   uint32
	MemoryImageHeight uint32
	ImageSubresource  ImageSubresourceLayers
	ImageOffset       Offset3D
	ImageExtent       Extent3D
}

type _vkMemoryToImageCopyEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	pHostPointer      unsafe.Pointer
	memoryRowLength   uint32
	memoryImageHeight uint32
	imageSubresource  _vkImageSubresourceLayers
	imageOffset       _vkOffset3D
	imageExtent       _vkExtent3D
}

func (s *_vkMemoryToImageCopyEXT) Goify() *MemoryToImageCopyEXT {
	rval := &MemoryToImageCopyEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		PHostPointer:      (unsafe.Pointer)(s.pHostPointer),
		MemoryRowLength:   (uint32)(s.memoryRowLength),
		MemoryImageHeight: (uint32)(s.memoryImageHeight),
		ImageSubresource:  (ImageSubresourceLayers)(s.imageSubresource),
		ImageOffset:       (Offset3D)(s.imageOffset),
		ImageExtent:       (Extent3D)(s.imageExtent),
	}
	return rval
}
func (s *MemoryToImageCopyEXT) Vulkanize() *_vkMemoryToImageCopyEXT {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryToImageCopyEXT{
		sType:             STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT,         /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                       /*cb*/
		pHostPointer:      (unsafe.Pointer)(s.PHostPointer),                /*cb*/
		memoryRowLength:   (uint32)(s.MemoryRowLength),                     /*cb*/
		memoryImageHeight: (uint32)(s.MemoryImageHeight),                   /*cb*/
		imageSubresource:  (_vkImageSubresourceLayers)(s.ImageSubresource), /*cb*/
		imageOffset:       (_vkOffset3D)(s.ImageOffset),                    /*cb*/
		imageExtent:       (_vkExtent3D)(s.ImageExtent),                    /*cb*/
	}
	return rval
}

// MemoryType: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryType.html
type MemoryType struct {
	//  Memory properties of this memory type;
	PropertyFlags MemoryPropertyFlags
	//  Index of the memory heap allocations of this memory type are taken from;
	HeapIndex uint32
}

type _vkMemoryType = MemoryType

func (s *_vkMemoryType) Goify() *MemoryType {
	rval := (*MemoryType)(s)
	return rval
}
func (s *MemoryType) Vulkanize() *_vkMemoryType {
	if s == nil {
		return nil
	}
	rval := (*_vkMemoryType)(s)
	return rval
}

// MemoryUnmapInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryUnmapInfoKHR.html
type MemoryUnmapInfoKHR struct {
	// SType = STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR
	PNext  unsafe.Pointer
	Flags  MemoryUnmapFlagsKHR
	Memory DeviceMemory
}

type _vkMemoryUnmapInfoKHR struct {
	sType  StructureType
	pNext  unsafe.Pointer
	flags  MemoryUnmapFlagsKHR
	memory DeviceMemory
}

func (s *_vkMemoryUnmapInfoKHR) Goify() *MemoryUnmapInfoKHR {
	rval := &MemoryUnmapInfoKHR{
		PNext:  (unsafe.Pointer)(s.pNext),
		Flags:  (MemoryUnmapFlagsKHR)(s.flags),
		Memory: (DeviceMemory)(s.memory),
	}
	return rval
}
func (s *MemoryUnmapInfoKHR) Vulkanize() *_vkMemoryUnmapInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkMemoryUnmapInfoKHR{
		sType:  STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),            /*cb*/
		flags:  (MemoryUnmapFlagsKHR)(s.Flags),       /*cb*/
		memory: (DeviceMemory)(s.Memory),             /*cb*/
	}
	return rval
}

// MicromapBuildInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapBuildInfoEXT.html
type MicromapBuildInfoEXT struct {
	// SType = STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT
	PNext       unsafe.Pointer
	Typ         MicromapTypeEXT
	Flags       BuildMicromapFlagsEXT
	Mode        BuildMicromapModeEXT
	DstMicromap MicromapEXT
	// usageCountsCount
	PUsageCounts        []MicromapUsageEXT
	PpUsageCounts       []*MicromapUsageEXT
	Data                DeviceOrHostAddressConstKHR
	ScratchData         DeviceOrHostAddressKHR
	TriangleArray       DeviceOrHostAddressConstKHR
	TriangleArrayStride DeviceSize
}

type _vkMicromapBuildInfoEXT struct {
	sType               StructureType
	pNext               unsafe.Pointer
	typ                 MicromapTypeEXT
	flags               BuildMicromapFlagsEXT
	mode                BuildMicromapModeEXT
	dstMicromap         MicromapEXT
	usageCountsCount    uint32
	pUsageCounts        *_vkMicromapUsageEXT
	ppUsageCounts       **_vkMicromapUsageEXT
	data                _vkDeviceOrHostAddressConstKHR
	scratchData         _vkDeviceOrHostAddressKHR
	triangleArray       _vkDeviceOrHostAddressConstKHR
	triangleArrayStride DeviceSize
}

func (s *_vkMicromapBuildInfoEXT) Goify() *MicromapBuildInfoEXT {
	rval := &MicromapBuildInfoEXT{
		PNext:       (unsafe.Pointer)(s.pNext),
		Typ:         (MicromapTypeEXT)(s.typ),
		Flags:       (BuildMicromapFlagsEXT)(s.flags),
		Mode:        (BuildMicromapModeEXT)(s.mode),
		DstMicromap: (MicromapEXT)(s.dstMicromap),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pUsageCounts in returned struct
		// Unexpected pointer member ppUsageCounts in returned struct
		// Can't Goify union member data
		// Can't Goify union member scratchData
		// Can't Goify union member triangleArray
		TriangleArrayStride: (DeviceSize)(s.triangleArrayStride),
	}
	return rval
}
func (s *MicromapBuildInfoEXT) Vulkanize() *_vkMicromapBuildInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pUsageCounts *_vkMicromapUsageEXT
	if len(s.PUsageCounts) > 0 {
		psl_pUsageCounts = &s.PUsageCounts[0]
	}

	var psl_ppUsageCounts **_vkMicromapUsageEXT
	if len(s.PpUsageCounts) > 0 {
		psl_ppUsageCounts = &s.PpUsageCounts[0]
	}
	rval := &_vkMicromapBuildInfoEXT{
		sType:               STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),              /*cb*/
		typ:                 (MicromapTypeEXT)(s.Typ),               /*cb*/
		flags:               (BuildMicromapFlagsEXT)(s.Flags),       /*cb*/
		mode:                (BuildMicromapModeEXT)(s.Mode),         /*cb*/
		dstMicromap:         (MicromapEXT)(s.DstMicromap),           /*cb*/
		pUsageCounts:        psl_pUsageCounts,                       /*c rem*/
		ppUsageCounts:       psl_ppUsageCounts,                      /*c rem*/
		data:                *s.Data.Vulkanize(),                    /*c union*/
		scratchData:         *s.ScratchData.Vulkanize(),             /*c union*/
		triangleArray:       *s.TriangleArray.Vulkanize(),           /*c union*/
		triangleArrayStride: (DeviceSize)(s.TriangleArrayStride),    /*cb*/
	}
	rval.usageCountsCount = 0 // c6-b
	if uint32(len(s.PUsageCounts)) > rval.usageCountsCount {
		rval.usageCountsCount = uint32(len(s.PUsageCounts))
	}
	if uint32(len(s.PpUsageCounts)) > rval.usageCountsCount {
		rval.usageCountsCount = uint32(len(s.PpUsageCounts))
	}
	return rval
}

// MicromapBuildSizesInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapBuildSizesInfoEXT.html
type MicromapBuildSizesInfoEXT struct {
	// SType = STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT
	PNext            unsafe.Pointer
	MicromapSize     DeviceSize
	BuildScratchSize DeviceSize
	Discardable      bool
}

type _vkMicromapBuildSizesInfoEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	micromapSize     DeviceSize
	buildScratchSize DeviceSize
	discardable      Bool32
}

func (s *_vkMicromapBuildSizesInfoEXT) Goify() *MicromapBuildSizesInfoEXT {
	rval := &MicromapBuildSizesInfoEXT{
		PNext:            (unsafe.Pointer)(s.pNext),
		MicromapSize:     (DeviceSize)(s.micromapSize),
		BuildScratchSize: (DeviceSize)(s.buildScratchSize),
		Discardable:      translatePublic_Bool32(s.discardable), /*default*/
	}
	return rval
}
func (s *MicromapBuildSizesInfoEXT) Vulkanize() *_vkMicromapBuildSizesInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkMicromapBuildSizesInfoEXT{
		sType:            STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                    /*cb*/
		micromapSize:     (DeviceSize)(s.MicromapSize),                 /*cb*/
		buildScratchSize: (DeviceSize)(s.BuildScratchSize),             /*cb*/
		discardable:      translateInternal_Bool32(s.Discardable),      /*default*/
	}
	return rval
}

// MicromapCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapCreateInfoEXT.html
type MicromapCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT
	PNext       unsafe.Pointer
	CreateFlags MicromapCreateFlagsEXT
	Buffer      Buffer
	//  Specified in bytes;
	Offset        DeviceSize
	Size          DeviceSize
	Typ           MicromapTypeEXT
	DeviceAddress DeviceAddress
}

type _vkMicromapCreateInfoEXT struct {
	sType         StructureType
	pNext         unsafe.Pointer
	createFlags   MicromapCreateFlagsEXT
	buffer        Buffer
	offset        DeviceSize
	size          DeviceSize
	typ           MicromapTypeEXT
	deviceAddress DeviceAddress
}

func (s *_vkMicromapCreateInfoEXT) Goify() *MicromapCreateInfoEXT {
	rval := &MicromapCreateInfoEXT{
		PNext:         (unsafe.Pointer)(s.pNext),
		CreateFlags:   (MicromapCreateFlagsEXT)(s.createFlags),
		Buffer:        (Buffer)(s.buffer),
		Offset:        (DeviceSize)(s.offset),
		Size:          (DeviceSize)(s.size),
		Typ:           (MicromapTypeEXT)(s.typ),
		DeviceAddress: (DeviceAddress)(s.deviceAddress),
	}
	return rval
}
func (s *MicromapCreateInfoEXT) Vulkanize() *_vkMicromapCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkMicromapCreateInfoEXT{
		sType:         STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),               /*cb*/
		createFlags:   (MicromapCreateFlagsEXT)(s.CreateFlags), /*cb*/
		buffer:        (Buffer)(s.Buffer),                      /*cb*/
		offset:        (DeviceSize)(s.Offset),                  /*cb*/
		size:          (DeviceSize)(s.Size),                    /*cb*/
		typ:           (MicromapTypeEXT)(s.Typ),                /*cb*/
		deviceAddress: (DeviceAddress)(s.DeviceAddress),        /*cb*/
	}
	return rval
}

// MicromapTriangleEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapTriangleEXT.html
type MicromapTriangleEXT struct {
	//  Specified in bytes;
	DataOffset       uint32
	SubdivisionLevel uint16
	Format           uint16
}

type _vkMicromapTriangleEXT = MicromapTriangleEXT

func (s *_vkMicromapTriangleEXT) Goify() *MicromapTriangleEXT {
	rval := (*MicromapTriangleEXT)(s)
	return rval
}
func (s *MicromapTriangleEXT) Vulkanize() *_vkMicromapTriangleEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkMicromapTriangleEXT)(s)
	return rval
}

// MicromapUsageEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapUsageEXT.html
type MicromapUsageEXT struct {
	Count            uint32
	SubdivisionLevel uint32
	//  Interpretation depends on parent type;
	Format uint32
}

type _vkMicromapUsageEXT = MicromapUsageEXT

func (s *_vkMicromapUsageEXT) Goify() *MicromapUsageEXT {
	rval := (*MicromapUsageEXT)(s)
	return rval
}
func (s *MicromapUsageEXT) Vulkanize() *_vkMicromapUsageEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkMicromapUsageEXT)(s)
	return rval
}

// MicromapVersionInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapVersionInfoEXT.html
type MicromapVersionInfoEXT struct {
	// SType = STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT
	PNext        unsafe.Pointer
	PVersionData *uint8
}

type _vkMicromapVersionInfoEXT struct {
	sType        StructureType
	pNext        unsafe.Pointer
	pVersionData *uint8
}

func (s *_vkMicromapVersionInfoEXT) Goify() *MicromapVersionInfoEXT {
	rval := &MicromapVersionInfoEXT{
		PNext:        (unsafe.Pointer)(s.pNext),
		PVersionData: (*uint8)(s.pVersionData),
	}
	return rval
}
func (s *MicromapVersionInfoEXT) Vulkanize() *_vkMicromapVersionInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkMicromapVersionInfoEXT{
		sType:        STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                /*cb*/
		pVersionData: (*uint8)(s.PVersionData),                 /*cb*/
	}
	return rval
}

// MultiDrawIndexedInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawIndexedInfoEXT.html
type MultiDrawIndexedInfoEXT struct {
	FirstIndex   uint32
	IndexCount   uint32
	VertexOffset int32
}

type _vkMultiDrawIndexedInfoEXT = MultiDrawIndexedInfoEXT

func (s *_vkMultiDrawIndexedInfoEXT) Goify() *MultiDrawIndexedInfoEXT {
	rval := (*MultiDrawIndexedInfoEXT)(s)
	return rval
}
func (s *MultiDrawIndexedInfoEXT) Vulkanize() *_vkMultiDrawIndexedInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkMultiDrawIndexedInfoEXT)(s)
	return rval
}

// MultiDrawInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawInfoEXT.html
type MultiDrawInfoEXT struct {
	FirstVertex uint32
	VertexCount uint32
}

type _vkMultiDrawInfoEXT = MultiDrawInfoEXT

func (s *_vkMultiDrawInfoEXT) Goify() *MultiDrawInfoEXT {
	rval := (*MultiDrawInfoEXT)(s)
	return rval
}
func (s *MultiDrawInfoEXT) Vulkanize() *_vkMultiDrawInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkMultiDrawInfoEXT)(s)
	return rval
}

// MultisamplePropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultisamplePropertiesEXT.html
type MultisamplePropertiesEXT struct {
	// SType = STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT
	PNext                     unsafe.Pointer
	MaxSampleLocationGridSize Extent2D
}

// WARNING - struct MultisamplePropertiesEXT is returned only, which is not yet handled in the binding
type _vkMultisamplePropertiesEXT struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	maxSampleLocationGridSize _vkExtent2D
}

func (s *_vkMultisamplePropertiesEXT) Goify() *MultisamplePropertiesEXT {
	rval := &MultisamplePropertiesEXT{
		PNext:                     (unsafe.Pointer)(s.pNext),
		MaxSampleLocationGridSize: (Extent2D)(s.maxSampleLocationGridSize),
	}
	return rval
}
func (s *MultisamplePropertiesEXT) Vulkanize() *_vkMultisamplePropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkMultisamplePropertiesEXT{
		sType:                     STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT,  /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                  /*cb*/
		maxSampleLocationGridSize: (_vkExtent2D)(s.MaxSampleLocationGridSize), /*cb*/
	}
	return rval
}

// MultisampledRenderToSingleSampledInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultisampledRenderToSingleSampledInfoEXT.html
type MultisampledRenderToSingleSampledInfoEXT struct {
	// SType = STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT
	PNext                                   unsafe.Pointer
	MultisampledRenderToSingleSampledEnable bool
	RasterizationSamples                    SampleCountFlagBits
}

type _vkMultisampledRenderToSingleSampledInfoEXT struct {
	sType                                   StructureType
	pNext                                   unsafe.Pointer
	multisampledRenderToSingleSampledEnable Bool32
	rasterizationSamples                    SampleCountFlagBits
}

func (s *_vkMultisampledRenderToSingleSampledInfoEXT) Goify() *MultisampledRenderToSingleSampledInfoEXT {
	rval := &MultisampledRenderToSingleSampledInfoEXT{
		PNext:                                   (unsafe.Pointer)(s.pNext),
		MultisampledRenderToSingleSampledEnable: translatePublic_Bool32(s.multisampledRenderToSingleSampledEnable), /*default*/
		RasterizationSamples:                    (SampleCountFlagBits)(s.rasterizationSamples),
	}
	return rval
}
func (s *MultisampledRenderToSingleSampledInfoEXT) Vulkanize() *_vkMultisampledRenderToSingleSampledInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkMultisampledRenderToSingleSampledInfoEXT{
		sType:                                   STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT,       /*c1*/
		pNext:                                   (unsafe.Pointer)(s.PNext),                                           /*cb*/
		multisampledRenderToSingleSampledEnable: translateInternal_Bool32(s.MultisampledRenderToSingleSampledEnable), /*default*/
		rasterizationSamples:                    (SampleCountFlagBits)(s.RasterizationSamples),                       /*cb*/
	}
	return rval
}

// MultiviewPerViewAttributesInfoNVX: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiviewPerViewAttributesInfoNVX.html
type MultiviewPerViewAttributesInfoNVX struct {
	// SType = STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX
	PNext                          unsafe.Pointer
	PerViewAttributes              bool
	PerViewAttributesPositionXOnly bool
}

type _vkMultiviewPerViewAttributesInfoNVX struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	perViewAttributes              Bool32
	perViewAttributesPositionXOnly Bool32
}

func (s *_vkMultiviewPerViewAttributesInfoNVX) Goify() *MultiviewPerViewAttributesInfoNVX {
	rval := &MultiviewPerViewAttributesInfoNVX{
		PNext:                          (unsafe.Pointer)(s.pNext),
		PerViewAttributes:              translatePublic_Bool32(s.perViewAttributes),              /*default*/
		PerViewAttributesPositionXOnly: translatePublic_Bool32(s.perViewAttributesPositionXOnly), /*default*/
	}
	return rval
}
func (s *MultiviewPerViewAttributesInfoNVX) Vulkanize() *_vkMultiviewPerViewAttributesInfoNVX {
	if s == nil {
		return nil
	}
	rval := &_vkMultiviewPerViewAttributesInfoNVX{
		sType:                          STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX,      /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                  /*cb*/
		perViewAttributes:              translateInternal_Bool32(s.PerViewAttributes),              /*default*/
		perViewAttributesPositionXOnly: translateInternal_Bool32(s.PerViewAttributesPositionXOnly), /*default*/
	}
	return rval
}

// MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.html
type MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM struct {
	// SType = STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM
	PNext unsafe.Pointer
	// perViewRenderAreaCount
	PPerViewRenderAreas []Rect2D
}

type _vkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	perViewRenderAreaCount uint32
	pPerViewRenderAreas    *_vkRect2D
}

func (s *_vkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM) Goify() *MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
	rval := &MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPerViewRenderAreas in returned struct
	}
	return rval
}
func (s *MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM) Vulkanize() *_vkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
	if s == nil {
		return nil
	}

	var psl_pPerViewRenderAreas *_vkRect2D
	if len(s.PPerViewRenderAreas) > 0 {
		sl_pPerViewRenderAreas := make([]_vkRect2D, len(s.PPerViewRenderAreas))
		for i, v := range s.PPerViewRenderAreas {
			sl_pPerViewRenderAreas[i] = *(v.Vulkanize())
		}
		psl_pPerViewRenderAreas = &sl_pPerViewRenderAreas[0]
	}
	rval := &_vkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM{
		sType:                  STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                                  /*cb*/
		perViewRenderAreaCount: uint32(len(s.PPerViewRenderAreas)),                                         /*c6-a*/
		pPerViewRenderAreas:    psl_pPerViewRenderAreas,                                                    /*c rem*/
	}
	return rval
}

// MutableDescriptorTypeCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeCreateInfoEXT.html
type MutableDescriptorTypeCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT
	PNext unsafe.Pointer
	// mutableDescriptorTypeListCount
	PMutableDescriptorTypeLists []MutableDescriptorTypeListEXT
}

type _vkMutableDescriptorTypeCreateInfoEXT struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	mutableDescriptorTypeListCount uint32
	pMutableDescriptorTypeLists    *_vkMutableDescriptorTypeListEXT
}

func (s *_vkMutableDescriptorTypeCreateInfoEXT) Goify() *MutableDescriptorTypeCreateInfoEXT {
	rval := &MutableDescriptorTypeCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pMutableDescriptorTypeLists in returned struct
	}
	return rval
}
func (s *MutableDescriptorTypeCreateInfoEXT) Vulkanize() *_vkMutableDescriptorTypeCreateInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pMutableDescriptorTypeLists *_vkMutableDescriptorTypeListEXT
	if len(s.PMutableDescriptorTypeLists) > 0 {
		sl_pMutableDescriptorTypeLists := make([]_vkMutableDescriptorTypeListEXT, len(s.PMutableDescriptorTypeLists))
		for i, v := range s.PMutableDescriptorTypeLists {
			sl_pMutableDescriptorTypeLists[i] = *(v.Vulkanize())
		}
		psl_pMutableDescriptorTypeLists = &sl_pMutableDescriptorTypeLists[0]
	}
	rval := &_vkMutableDescriptorTypeCreateInfoEXT{
		sType:                          STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                              /*cb*/
		mutableDescriptorTypeListCount: uint32(len(s.PMutableDescriptorTypeLists)),             /*c6-a*/
		pMutableDescriptorTypeLists:    psl_pMutableDescriptorTypeLists,                        /*c rem*/
	}
	return rval
}

// MutableDescriptorTypeCreateInfoVALVE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeCreateInfoVALVE.html
type MutableDescriptorTypeCreateInfoVALVE struct {
}

type _vkMutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoVALVE

func (s *_vkMutableDescriptorTypeCreateInfoVALVE) Goify() *MutableDescriptorTypeCreateInfoVALVE {
	rval := (*MutableDescriptorTypeCreateInfoVALVE)(s)
	return rval
}
func (s *MutableDescriptorTypeCreateInfoVALVE) Vulkanize() *_vkMutableDescriptorTypeCreateInfoVALVE {
	if s == nil {
		return nil
	}
	rval := (*_vkMutableDescriptorTypeCreateInfoVALVE)(s)
	return rval
}

// MutableDescriptorTypeListEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeListEXT.html
type MutableDescriptorTypeListEXT struct {
	// descriptorTypeCount
	PDescriptorTypes []DescriptorType
}

type _vkMutableDescriptorTypeListEXT struct {
	descriptorTypeCount uint32
	pDescriptorTypes    *DescriptorType
}

func (s *_vkMutableDescriptorTypeListEXT) Goify() *MutableDescriptorTypeListEXT {
	rval := &MutableDescriptorTypeListEXT{
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDescriptorTypes in returned struct
	}
	return rval
}
func (s *MutableDescriptorTypeListEXT) Vulkanize() *_vkMutableDescriptorTypeListEXT {
	if s == nil {
		return nil
	}

	var psl_pDescriptorTypes *DescriptorType
	if len(s.PDescriptorTypes) > 0 {
		psl_pDescriptorTypes = &s.PDescriptorTypes[0]
	}
	rval := &_vkMutableDescriptorTypeListEXT{
		descriptorTypeCount: uint32(len(s.PDescriptorTypes)), /*c6-a*/
		pDescriptorTypes:    psl_pDescriptorTypes,            /*c rem*/
	}
	return rval
}

// MutableDescriptorTypeListVALVE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeListVALVE.html
type MutableDescriptorTypeListVALVE struct {
}

type _vkMutableDescriptorTypeListVALVE = MutableDescriptorTypeListVALVE

func (s *_vkMutableDescriptorTypeListVALVE) Goify() *MutableDescriptorTypeListVALVE {
	rval := (*MutableDescriptorTypeListVALVE)(s)
	return rval
}
func (s *MutableDescriptorTypeListVALVE) Vulkanize() *_vkMutableDescriptorTypeListVALVE {
	if s == nil {
		return nil
	}
	rval := (*_vkMutableDescriptorTypeListVALVE)(s)
	return rval
}

// Offset2D: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset2D.html
type Offset2D struct {
	X int32
	Y int32
}

type _vkOffset2D = Offset2D

func (s *_vkOffset2D) Goify() *Offset2D {
	rval := (*Offset2D)(s)
	return rval
}
func (s *Offset2D) Vulkanize() *_vkOffset2D {
	if s == nil {
		return nil
	}
	rval := (*_vkOffset2D)(s)
	return rval
}

// Offset3D: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset3D.html
type Offset3D struct {
	X int32
	Y int32
	Z int32
}

type _vkOffset3D = Offset3D

func (s *_vkOffset3D) Goify() *Offset3D {
	rval := (*Offset3D)(s)
	return rval
}
func (s *Offset3D) Vulkanize() *_vkOffset3D {
	if s == nil {
		return nil
	}
	rval := (*_vkOffset3D)(s)
	return rval
}

// OpaqueCaptureDescriptorDataCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpaqueCaptureDescriptorDataCreateInfoEXT.html
type OpaqueCaptureDescriptorDataCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT
	PNext                       unsafe.Pointer
	OpaqueCaptureDescriptorData unsafe.Pointer
}

type _vkOpaqueCaptureDescriptorDataCreateInfoEXT struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	opaqueCaptureDescriptorData unsafe.Pointer
}

func (s *_vkOpaqueCaptureDescriptorDataCreateInfoEXT) Goify() *OpaqueCaptureDescriptorDataCreateInfoEXT {
	rval := &OpaqueCaptureDescriptorDataCreateInfoEXT{
		PNext:                       (unsafe.Pointer)(s.pNext),
		OpaqueCaptureDescriptorData: (unsafe.Pointer)(s.opaqueCaptureDescriptorData),
	}
	return rval
}
func (s *OpaqueCaptureDescriptorDataCreateInfoEXT) Vulkanize() *_vkOpaqueCaptureDescriptorDataCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkOpaqueCaptureDescriptorDataCreateInfoEXT{
		sType:                       STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                     /*cb*/
		opaqueCaptureDescriptorData: (unsafe.Pointer)(s.OpaqueCaptureDescriptorData),               /*cb*/
	}
	return rval
}

// OpticalFlowExecuteInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowExecuteInfoNV.html
type OpticalFlowExecuteInfoNV struct {
	// SType = STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV
	PNext unsafe.Pointer
	Flags OpticalFlowExecuteFlagsNV
	// regionCount
	PRegions []Rect2D
}

type _vkOpticalFlowExecuteInfoNV struct {
	sType       StructureType
	pNext       unsafe.Pointer
	flags       OpticalFlowExecuteFlagsNV
	regionCount uint32
	pRegions    *_vkRect2D
}

func (s *_vkOpticalFlowExecuteInfoNV) Goify() *OpticalFlowExecuteInfoNV {
	rval := &OpticalFlowExecuteInfoNV{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (OpticalFlowExecuteFlagsNV)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *OpticalFlowExecuteInfoNV) Vulkanize() *_vkOpticalFlowExecuteInfoNV {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkRect2D
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkRect2D, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkOpticalFlowExecuteInfoNV{
		sType:       STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                   /*cb*/
		flags:       (OpticalFlowExecuteFlagsNV)(s.Flags),        /*cb*/
		regionCount: uint32(len(s.PRegions)),                     /*c6-a*/
		pRegions:    psl_pRegions,                                /*c rem*/
	}
	return rval
}

// OpticalFlowImageFormatInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowImageFormatInfoNV.html
type OpticalFlowImageFormatInfoNV struct {
	// SType = STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV
	PNext unsafe.Pointer
	Usage OpticalFlowUsageFlagsNV
}

type _vkOpticalFlowImageFormatInfoNV struct {
	sType StructureType
	pNext unsafe.Pointer
	usage OpticalFlowUsageFlagsNV
}

func (s *_vkOpticalFlowImageFormatInfoNV) Goify() *OpticalFlowImageFormatInfoNV {
	rval := &OpticalFlowImageFormatInfoNV{
		PNext: (unsafe.Pointer)(s.pNext),
		Usage: (OpticalFlowUsageFlagsNV)(s.usage),
	}
	return rval
}
func (s *OpticalFlowImageFormatInfoNV) Vulkanize() *_vkOpticalFlowImageFormatInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkOpticalFlowImageFormatInfoNV{
		sType: STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                        /*cb*/
		usage: (OpticalFlowUsageFlagsNV)(s.Usage),               /*cb*/
	}
	return rval
}

// OpticalFlowImageFormatPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowImageFormatPropertiesNV.html
type OpticalFlowImageFormatPropertiesNV struct {
	// SType = STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV
	PNext  unsafe.Pointer
	Format Format
}

// WARNING - struct OpticalFlowImageFormatPropertiesNV is returned only, which is not yet handled in the binding
type _vkOpticalFlowImageFormatPropertiesNV struct {
	sType  StructureType
	pNext  unsafe.Pointer
	format Format
}

func (s *_vkOpticalFlowImageFormatPropertiesNV) Goify() *OpticalFlowImageFormatPropertiesNV {
	rval := &OpticalFlowImageFormatPropertiesNV{
		PNext:  (unsafe.Pointer)(s.pNext),
		Format: (Format)(s.format),
	}
	return rval
}
func (s *OpticalFlowImageFormatPropertiesNV) Vulkanize() *_vkOpticalFlowImageFormatPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkOpticalFlowImageFormatPropertiesNV{
		sType:  STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                              /*cb*/
		format: (Format)(s.Format),                                     /*cb*/
	}
	return rval
}

// OpticalFlowSessionCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionCreateInfoNV.html
type OpticalFlowSessionCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV
	PNext            unsafe.Pointer
	Width            uint32
	Height           uint32
	ImageFormat      Format
	FlowVectorFormat Format
	CostFormat       Format
	OutputGridSize   OpticalFlowGridSizeFlagsNV
	HintGridSize     OpticalFlowGridSizeFlagsNV
	PerformanceLevel OpticalFlowPerformanceLevelNV
	Flags            OpticalFlowSessionCreateFlagsNV
}

type _vkOpticalFlowSessionCreateInfoNV struct {
	sType            StructureType
	pNext            unsafe.Pointer
	width            uint32
	height           uint32
	imageFormat      Format
	flowVectorFormat Format
	costFormat       Format
	outputGridSize   OpticalFlowGridSizeFlagsNV
	hintGridSize     OpticalFlowGridSizeFlagsNV
	performanceLevel OpticalFlowPerformanceLevelNV
	flags            OpticalFlowSessionCreateFlagsNV
}

func (s *_vkOpticalFlowSessionCreateInfoNV) Goify() *OpticalFlowSessionCreateInfoNV {
	rval := &OpticalFlowSessionCreateInfoNV{
		PNext:            (unsafe.Pointer)(s.pNext),
		Width:            (uint32)(s.width),
		Height:           (uint32)(s.height),
		ImageFormat:      (Format)(s.imageFormat),
		FlowVectorFormat: (Format)(s.flowVectorFormat),
		CostFormat:       (Format)(s.costFormat),
		OutputGridSize:   (OpticalFlowGridSizeFlagsNV)(s.outputGridSize),
		HintGridSize:     (OpticalFlowGridSizeFlagsNV)(s.hintGridSize),
		PerformanceLevel: (OpticalFlowPerformanceLevelNV)(s.performanceLevel),
		Flags:            (OpticalFlowSessionCreateFlagsNV)(s.flags),
	}
	return rval
}
func (s *OpticalFlowSessionCreateInfoNV) Vulkanize() *_vkOpticalFlowSessionCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkOpticalFlowSessionCreateInfoNV{
		sType:            STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV,  /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                           /*cb*/
		width:            (uint32)(s.Width),                                   /*cb*/
		height:           (uint32)(s.Height),                                  /*cb*/
		imageFormat:      (Format)(s.ImageFormat),                             /*cb*/
		flowVectorFormat: (Format)(s.FlowVectorFormat),                        /*cb*/
		costFormat:       (Format)(s.CostFormat),                              /*cb*/
		outputGridSize:   (OpticalFlowGridSizeFlagsNV)(s.OutputGridSize),      /*cb*/
		hintGridSize:     (OpticalFlowGridSizeFlagsNV)(s.HintGridSize),        /*cb*/
		performanceLevel: (OpticalFlowPerformanceLevelNV)(s.PerformanceLevel), /*cb*/
		flags:            (OpticalFlowSessionCreateFlagsNV)(s.Flags),          /*cb*/
	}
	return rval
}

// OpticalFlowSessionCreatePrivateDataInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionCreatePrivateDataInfoNV.html
type OpticalFlowSessionCreatePrivateDataInfoNV struct {
	// SType = STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV
	PNext        unsafe.Pointer
	Id           uint32
	Size         uint32
	PPrivateData unsafe.Pointer
}

type _vkOpticalFlowSessionCreatePrivateDataInfoNV struct {
	sType        StructureType
	pNext        unsafe.Pointer
	id           uint32
	size         uint32
	pPrivateData unsafe.Pointer
}

func (s *_vkOpticalFlowSessionCreatePrivateDataInfoNV) Goify() *OpticalFlowSessionCreatePrivateDataInfoNV {
	rval := &OpticalFlowSessionCreatePrivateDataInfoNV{
		PNext:        (unsafe.Pointer)(s.pNext),
		Id:           (uint32)(s.id),
		Size:         (uint32)(s.size),
		PPrivateData: (unsafe.Pointer)(s.pPrivateData),
	}
	return rval
}
func (s *OpticalFlowSessionCreatePrivateDataInfoNV) Vulkanize() *_vkOpticalFlowSessionCreatePrivateDataInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkOpticalFlowSessionCreatePrivateDataInfoNV{
		sType:        STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                                       /*cb*/
		id:           (uint32)(s.Id),                                                  /*cb*/
		size:         (uint32)(s.Size),                                                /*cb*/
		pPrivateData: (unsafe.Pointer)(s.PPrivateData),                                /*cb*/
	}
	return rval
}

// OutOfBandQueueTypeInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOutOfBandQueueTypeInfoNV.html
type OutOfBandQueueTypeInfoNV struct {
	// SType = STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV
	PNext     unsafe.Pointer
	QueueType OutOfBandQueueTypeNV
}

type _vkOutOfBandQueueTypeInfoNV struct {
	sType     StructureType
	pNext     unsafe.Pointer
	queueType OutOfBandQueueTypeNV
}

func (s *_vkOutOfBandQueueTypeInfoNV) Goify() *OutOfBandQueueTypeInfoNV {
	rval := &OutOfBandQueueTypeInfoNV{
		PNext:     (unsafe.Pointer)(s.pNext),
		QueueType: (OutOfBandQueueTypeNV)(s.queueType),
	}
	return rval
}
func (s *OutOfBandQueueTypeInfoNV) Vulkanize() *_vkOutOfBandQueueTypeInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkOutOfBandQueueTypeInfoNV{
		sType:     STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                     /*cb*/
		queueType: (OutOfBandQueueTypeNV)(s.QueueType),           /*cb*/
	}
	return rval
}

// PastPresentationTimingGOOGLE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPastPresentationTimingGOOGLE.html
type PastPresentationTimingGOOGLE struct {
	//  Application-provided identifier, previously given to vkQueuePresentKHR;
	PresentID uint32
	//  Earliest time an image should have been presented, previously given to vkQueuePresentKHR;
	DesiredPresentTime uint64
	//  Time the image was actually displayed;
	ActualPresentTime uint64
	//  Earliest time the image could have been displayed;
	EarliestPresentTime uint64
	//  How early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime;
	PresentMargin uint64
}

type _vkPastPresentationTimingGOOGLE = PastPresentationTimingGOOGLE

func (s *_vkPastPresentationTimingGOOGLE) Goify() *PastPresentationTimingGOOGLE {
	rval := (*PastPresentationTimingGOOGLE)(s)
	return rval
}
func (s *PastPresentationTimingGOOGLE) Vulkanize() *_vkPastPresentationTimingGOOGLE {
	if s == nil {
		return nil
	}
	rval := (*_vkPastPresentationTimingGOOGLE)(s)
	return rval
}

// PerformanceConfigurationAcquireInfoINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html
type PerformanceConfigurationAcquireInfoINTEL struct {
	// SType = STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL
	PNext unsafe.Pointer
	Typ   PerformanceConfigurationTypeINTEL
}

type _vkPerformanceConfigurationAcquireInfoINTEL struct {
	sType StructureType
	pNext unsafe.Pointer
	typ   PerformanceConfigurationTypeINTEL
}

func (s *_vkPerformanceConfigurationAcquireInfoINTEL) Goify() *PerformanceConfigurationAcquireInfoINTEL {
	rval := &PerformanceConfigurationAcquireInfoINTEL{
		PNext: (unsafe.Pointer)(s.pNext),
		Typ:   (PerformanceConfigurationTypeINTEL)(s.typ),
	}
	return rval
}
func (s *PerformanceConfigurationAcquireInfoINTEL) Vulkanize() *_vkPerformanceConfigurationAcquireInfoINTEL {
	if s == nil {
		return nil
	}
	rval := &_vkPerformanceConfigurationAcquireInfoINTEL{
		sType: STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                   /*cb*/
		typ:   (PerformanceConfigurationTypeINTEL)(s.Typ),                  /*cb*/
	}
	return rval
}

// PerformanceCounterDescriptionKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterDescriptionKHR.html
type PerformanceCounterDescriptionKHR struct {
	// SType = STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR
	PNext       unsafe.Pointer
	Flags       PerformanceCounterDescriptionFlagsKHR
	Name        string
	Category    string
	Description string
}

// WARNING - struct PerformanceCounterDescriptionKHR is returned only, which is not yet handled in the binding
type _vkPerformanceCounterDescriptionKHR struct {
	sType       StructureType
	pNext       unsafe.Pointer
	flags       PerformanceCounterDescriptionFlagsKHR
	name        [MAX_DESCRIPTION_SIZE]byte
	category    [MAX_DESCRIPTION_SIZE]byte
	description [MAX_DESCRIPTION_SIZE]byte
}

func (s *_vkPerformanceCounterDescriptionKHR) Goify() *PerformanceCounterDescriptionKHR {
	rval := &PerformanceCounterDescriptionKHR{
		PNext:       (unsafe.Pointer)(s.pNext),
		Flags:       (PerformanceCounterDescriptionFlagsKHR)(s.flags),
		Name:        nullTermBytesToString(s.name[:]),        /*c arr*/
		Category:    nullTermBytesToString(s.category[:]),    /*c arr*/
		Description: nullTermBytesToString(s.description[:]), /*c arr*/
	}
	return rval
}
func (s *PerformanceCounterDescriptionKHR) Vulkanize() *_vkPerformanceCounterDescriptionKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPerformanceCounterDescriptionKHR{
		sType: STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                          /*cb*/
		flags: (PerformanceCounterDescriptionFlagsKHR)(s.Flags),   /*cb*/
		// name : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		// category : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		// description : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
	}
	return rval
}

// PerformanceCounterKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterKHR.html
type PerformanceCounterKHR struct {
	// SType = STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR
	PNext   unsafe.Pointer
	Unit    PerformanceCounterUnitKHR
	Scope   PerformanceCounterScopeKHR
	Storage PerformanceCounterStorageKHR
	Uuid    [UUID_SIZE]uint8
}

// WARNING - struct PerformanceCounterKHR is returned only, which is not yet handled in the binding
type _vkPerformanceCounterKHR struct {
	sType   StructureType
	pNext   unsafe.Pointer
	unit    PerformanceCounterUnitKHR
	scope   PerformanceCounterScopeKHR
	storage PerformanceCounterStorageKHR
	uuid    [UUID_SIZE]uint8
}

func (s *_vkPerformanceCounterKHR) Goify() *PerformanceCounterKHR {
	rval := &PerformanceCounterKHR{
		PNext:   (unsafe.Pointer)(s.pNext),
		Unit:    (PerformanceCounterUnitKHR)(s.unit),
		Scope:   (PerformanceCounterScopeKHR)(s.scope),
		Storage: (PerformanceCounterStorageKHR)(s.storage),
		Uuid:    ([UUID_SIZE]uint8)(s.uuid),
	}
	return rval
}
func (s *PerformanceCounterKHR) Vulkanize() *_vkPerformanceCounterKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPerformanceCounterKHR{
		sType:   STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR,    /*c1*/
		pNext:   (unsafe.Pointer)(s.PNext),                 /*cb*/
		unit:    (PerformanceCounterUnitKHR)(s.Unit),       /*cb*/
		scope:   (PerformanceCounterScopeKHR)(s.Scope),     /*cb*/
		storage: (PerformanceCounterStorageKHR)(s.Storage), /*cb*/
		uuid:    ([UUID_SIZE]uint8)(s.Uuid),                /*cb*/
	}
	return rval
}

// PerformanceMarkerInfoINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceMarkerInfoINTEL.html
type PerformanceMarkerInfoINTEL struct {
	// SType = STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL
	PNext  unsafe.Pointer
	Marker uint64
}

type _vkPerformanceMarkerInfoINTEL struct {
	sType  StructureType
	pNext  unsafe.Pointer
	marker uint64
}

func (s *_vkPerformanceMarkerInfoINTEL) Goify() *PerformanceMarkerInfoINTEL {
	rval := &PerformanceMarkerInfoINTEL{
		PNext:  (unsafe.Pointer)(s.pNext),
		Marker: (uint64)(s.marker),
	}
	return rval
}
func (s *PerformanceMarkerInfoINTEL) Vulkanize() *_vkPerformanceMarkerInfoINTEL {
	if s == nil {
		return nil
	}
	rval := &_vkPerformanceMarkerInfoINTEL{
		sType:  STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                    /*cb*/
		marker: (uint64)(s.Marker),                           /*cb*/
	}
	return rval
}

// PerformanceOverrideInfoINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceOverrideInfoINTEL.html
type PerformanceOverrideInfoINTEL struct {
	// SType = STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL
	PNext     unsafe.Pointer
	Typ       PerformanceOverrideTypeINTEL
	Enable    bool
	Parameter uint64
}

type _vkPerformanceOverrideInfoINTEL struct {
	sType     StructureType
	pNext     unsafe.Pointer
	typ       PerformanceOverrideTypeINTEL
	enable    Bool32
	parameter uint64
}

func (s *_vkPerformanceOverrideInfoINTEL) Goify() *PerformanceOverrideInfoINTEL {
	rval := &PerformanceOverrideInfoINTEL{
		PNext:     (unsafe.Pointer)(s.pNext),
		Typ:       (PerformanceOverrideTypeINTEL)(s.typ),
		Enable:    translatePublic_Bool32(s.enable), /*default*/
		Parameter: (uint64)(s.parameter),
	}
	return rval
}
func (s *PerformanceOverrideInfoINTEL) Vulkanize() *_vkPerformanceOverrideInfoINTEL {
	if s == nil {
		return nil
	}
	rval := &_vkPerformanceOverrideInfoINTEL{
		sType:     STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                      /*cb*/
		typ:       (PerformanceOverrideTypeINTEL)(s.Typ),          /*cb*/
		enable:    translateInternal_Bool32(s.Enable),             /*default*/
		parameter: (uint64)(s.Parameter),                          /*cb*/
	}
	return rval
}

// PerformanceQueryReservationInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceQueryReservationInfoKHR.html
type PerformanceQueryReservationInfoKHR struct {
	// SType = STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR
	PNext unsafe.Pointer
	//  Maximum number of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR queries in a query pool;
	MaxPerformanceQueriesPerPool uint32
}

type _vkPerformanceQueryReservationInfoKHR struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	maxPerformanceQueriesPerPool uint32
}

func (s *_vkPerformanceQueryReservationInfoKHR) Goify() *PerformanceQueryReservationInfoKHR {
	rval := &PerformanceQueryReservationInfoKHR{
		PNext:                        (unsafe.Pointer)(s.pNext),
		MaxPerformanceQueriesPerPool: (uint32)(s.maxPerformanceQueriesPerPool),
	}
	return rval
}
func (s *PerformanceQueryReservationInfoKHR) Vulkanize() *_vkPerformanceQueryReservationInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPerformanceQueryReservationInfoKHR{
		sType:                        STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                             /*cb*/
		maxPerformanceQueriesPerPool: (uint32)(s.MaxPerformanceQueriesPerPool),              /*cb*/
	}
	return rval
}

// PerformanceQuerySubmitInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceQuerySubmitInfoKHR.html
type PerformanceQuerySubmitInfoKHR struct {
	// SType = STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR
	PNext unsafe.Pointer
	//  Index for which counter pass to submit;
	CounterPassIndex uint32
}

type _vkPerformanceQuerySubmitInfoKHR struct {
	sType            StructureType
	pNext            unsafe.Pointer
	counterPassIndex uint32
}

func (s *_vkPerformanceQuerySubmitInfoKHR) Goify() *PerformanceQuerySubmitInfoKHR {
	rval := &PerformanceQuerySubmitInfoKHR{
		PNext:            (unsafe.Pointer)(s.pNext),
		CounterPassIndex: (uint32)(s.counterPassIndex),
	}
	return rval
}
func (s *PerformanceQuerySubmitInfoKHR) Vulkanize() *_vkPerformanceQuerySubmitInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPerformanceQuerySubmitInfoKHR{
		sType:            STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                        /*cb*/
		counterPassIndex: (uint32)(s.CounterPassIndex),                     /*cb*/
	}
	return rval
}

// PerformanceStreamMarkerInfoINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceStreamMarkerInfoINTEL.html
type PerformanceStreamMarkerInfoINTEL struct {
	// SType = STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL
	PNext  unsafe.Pointer
	Marker uint32
}

type _vkPerformanceStreamMarkerInfoINTEL struct {
	sType  StructureType
	pNext  unsafe.Pointer
	marker uint32
}

func (s *_vkPerformanceStreamMarkerInfoINTEL) Goify() *PerformanceStreamMarkerInfoINTEL {
	rval := &PerformanceStreamMarkerInfoINTEL{
		PNext:  (unsafe.Pointer)(s.pNext),
		Marker: (uint32)(s.marker),
	}
	return rval
}
func (s *PerformanceStreamMarkerInfoINTEL) Vulkanize() *_vkPerformanceStreamMarkerInfoINTEL {
	if s == nil {
		return nil
	}
	rval := &_vkPerformanceStreamMarkerInfoINTEL{
		sType:  STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                           /*cb*/
		marker: (uint32)(s.Marker),                                  /*cb*/
	}
	return rval
}

// PerformanceValueINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueINTEL.html
type PerformanceValueINTEL struct {
	Typ  PerformanceValueTypeINTEL
	Data PerformanceValueDataINTEL
}

type _vkPerformanceValueINTEL struct {
	typ  PerformanceValueTypeINTEL
	data _vkPerformanceValueDataINTEL
}

func (s *_vkPerformanceValueINTEL) Goify() *PerformanceValueINTEL {
	rval := &PerformanceValueINTEL{
		Typ: (PerformanceValueTypeINTEL)(s.typ),
		// Can't Goify union member data
	}
	return rval
}
func (s *PerformanceValueINTEL) Vulkanize() *_vkPerformanceValueINTEL {
	if s == nil {
		return nil
	}
	rval := &_vkPerformanceValueINTEL{
		typ:  (PerformanceValueTypeINTEL)(s.Typ), /*cb*/
		data: *s.Data.Vulkanize(),                /*c union*/
	}
	return rval
}

// PhysicalDevice16BitStorageFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice16BitStorageFeatures.html
type PhysicalDevice16BitStorageFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES
	PNext unsafe.Pointer
	//  16-bit integer/floating-point variables supported in BufferBlock;
	StorageBuffer16BitAccess bool
	//  16-bit integer/floating-point variables supported in BufferBlock and Block;
	UniformAndStorageBuffer16BitAccess bool
	//  16-bit integer/floating-point variables supported in PushConstant;
	StoragePushConstant16 bool
	//  16-bit integer/floating-point variables supported in shader inputs and outputs;
	StorageInputOutput16 bool
}

type _vkPhysicalDevice16BitStorageFeatures struct {
	sType                              StructureType
	pNext                              unsafe.Pointer
	storageBuffer16BitAccess           Bool32
	uniformAndStorageBuffer16BitAccess Bool32
	storagePushConstant16              Bool32
	storageInputOutput16               Bool32
}

func (s *_vkPhysicalDevice16BitStorageFeatures) Goify() *PhysicalDevice16BitStorageFeatures {
	rval := &PhysicalDevice16BitStorageFeatures{
		PNext:                              (unsafe.Pointer)(s.pNext),
		StorageBuffer16BitAccess:           translatePublic_Bool32(s.storageBuffer16BitAccess),           /*default*/
		UniformAndStorageBuffer16BitAccess: translatePublic_Bool32(s.uniformAndStorageBuffer16BitAccess), /*default*/
		StoragePushConstant16:              translatePublic_Bool32(s.storagePushConstant16),              /*default*/
		StorageInputOutput16:               translatePublic_Bool32(s.storageInputOutput16),               /*default*/
	}
	return rval
}
func (s *PhysicalDevice16BitStorageFeatures) Vulkanize() *_vkPhysicalDevice16BitStorageFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevice16BitStorageFeatures{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,          /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                      /*cb*/
		storageBuffer16BitAccess:           translateInternal_Bool32(s.StorageBuffer16BitAccess),           /*default*/
		uniformAndStorageBuffer16BitAccess: translateInternal_Bool32(s.UniformAndStorageBuffer16BitAccess), /*default*/
		storagePushConstant16:              translateInternal_Bool32(s.StoragePushConstant16),              /*default*/
		storageInputOutput16:               translateInternal_Bool32(s.StorageInputOutput16),               /*default*/
	}
	return rval
}

// PhysicalDevice16BitStorageFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice16BitStorageFeaturesKHR.html
type PhysicalDevice16BitStorageFeaturesKHR struct {
}

type _vkPhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeaturesKHR

func (s *_vkPhysicalDevice16BitStorageFeaturesKHR) Goify() *PhysicalDevice16BitStorageFeaturesKHR {
	rval := (*PhysicalDevice16BitStorageFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDevice16BitStorageFeaturesKHR) Vulkanize() *_vkPhysicalDevice16BitStorageFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDevice16BitStorageFeaturesKHR)(s)
	return rval
}

// PhysicalDevice4444FormatsFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html
type PhysicalDevice4444FormatsFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT
	PNext          unsafe.Pointer
	FormatA4R4G4B4 bool
	FormatA4B4G4R4 bool
}

type _vkPhysicalDevice4444FormatsFeaturesEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	formatA4R4G4B4 Bool32
	formatA4B4G4R4 Bool32
}

func (s *_vkPhysicalDevice4444FormatsFeaturesEXT) Goify() *PhysicalDevice4444FormatsFeaturesEXT {
	rval := &PhysicalDevice4444FormatsFeaturesEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		FormatA4R4G4B4: translatePublic_Bool32(s.formatA4R4G4B4), /*default*/
		FormatA4B4G4R4: translatePublic_Bool32(s.formatA4B4G4R4), /*default*/
	}
	return rval
}
func (s *PhysicalDevice4444FormatsFeaturesEXT) Vulkanize() *_vkPhysicalDevice4444FormatsFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevice4444FormatsFeaturesEXT{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                /*cb*/
		formatA4R4G4B4: translateInternal_Bool32(s.FormatA4R4G4B4),               /*default*/
		formatA4B4G4R4: translateInternal_Bool32(s.FormatA4B4G4R4),               /*default*/
	}
	return rval
}

// PhysicalDevice8BitStorageFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice8BitStorageFeatures.html
type PhysicalDevice8BitStorageFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES
	PNext unsafe.Pointer
	//  8-bit integer variables supported in StorageBuffer;
	StorageBuffer8BitAccess bool
	//  8-bit integer variables supported in StorageBuffer and Uniform;
	UniformAndStorageBuffer8BitAccess bool
	//  8-bit integer variables supported in PushConstant;
	StoragePushConstant8 bool
}

type _vkPhysicalDevice8BitStorageFeatures struct {
	sType                             StructureType
	pNext                             unsafe.Pointer
	storageBuffer8BitAccess           Bool32
	uniformAndStorageBuffer8BitAccess Bool32
	storagePushConstant8              Bool32
}

func (s *_vkPhysicalDevice8BitStorageFeatures) Goify() *PhysicalDevice8BitStorageFeatures {
	rval := &PhysicalDevice8BitStorageFeatures{
		PNext:                             (unsafe.Pointer)(s.pNext),
		StorageBuffer8BitAccess:           translatePublic_Bool32(s.storageBuffer8BitAccess),           /*default*/
		UniformAndStorageBuffer8BitAccess: translatePublic_Bool32(s.uniformAndStorageBuffer8BitAccess), /*default*/
		StoragePushConstant8:              translatePublic_Bool32(s.storagePushConstant8),              /*default*/
	}
	return rval
}
func (s *PhysicalDevice8BitStorageFeatures) Vulkanize() *_vkPhysicalDevice8BitStorageFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevice8BitStorageFeatures{
		sType:                             STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,          /*c1*/
		pNext:                             (unsafe.Pointer)(s.PNext),                                     /*cb*/
		storageBuffer8BitAccess:           translateInternal_Bool32(s.StorageBuffer8BitAccess),           /*default*/
		uniformAndStorageBuffer8BitAccess: translateInternal_Bool32(s.UniformAndStorageBuffer8BitAccess), /*default*/
		storagePushConstant8:              translateInternal_Bool32(s.StoragePushConstant8),              /*default*/
	}
	return rval
}

// PhysicalDevice8BitStorageFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice8BitStorageFeaturesKHR.html
type PhysicalDevice8BitStorageFeaturesKHR struct {
}

type _vkPhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeaturesKHR

func (s *_vkPhysicalDevice8BitStorageFeaturesKHR) Goify() *PhysicalDevice8BitStorageFeaturesKHR {
	rval := (*PhysicalDevice8BitStorageFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDevice8BitStorageFeaturesKHR) Vulkanize() *_vkPhysicalDevice8BitStorageFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDevice8BitStorageFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceASTCDecodeFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html
type PhysicalDeviceASTCDecodeFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT
	PNext                    unsafe.Pointer
	DecodeModeSharedExponent bool
}

type _vkPhysicalDeviceASTCDecodeFeaturesEXT struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	decodeModeSharedExponent Bool32
}

func (s *_vkPhysicalDeviceASTCDecodeFeaturesEXT) Goify() *PhysicalDeviceASTCDecodeFeaturesEXT {
	rval := &PhysicalDeviceASTCDecodeFeaturesEXT{
		PNext:                    (unsafe.Pointer)(s.pNext),
		DecodeModeSharedExponent: translatePublic_Bool32(s.decodeModeSharedExponent), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceASTCDecodeFeaturesEXT) Vulkanize() *_vkPhysicalDeviceASTCDecodeFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceASTCDecodeFeaturesEXT{
		sType:                    STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                               /*cb*/
		decodeModeSharedExponent: translateInternal_Bool32(s.DecodeModeSharedExponent),    /*default*/
	}
	return rval
}

// PhysicalDeviceAccelerationStructureFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html
type PhysicalDeviceAccelerationStructureFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR
	PNext                                                 unsafe.Pointer
	AccelerationStructure                                 bool
	AccelerationStructureCaptureReplay                    bool
	AccelerationStructureIndirectBuild                    bool
	AccelerationStructureHostCommands                     bool
	DescriptorBindingAccelerationStructureUpdateAfterBind bool
}

type _vkPhysicalDeviceAccelerationStructureFeaturesKHR struct {
	sType                                                 StructureType
	pNext                                                 unsafe.Pointer
	accelerationStructure                                 Bool32
	accelerationStructureCaptureReplay                    Bool32
	accelerationStructureIndirectBuild                    Bool32
	accelerationStructureHostCommands                     Bool32
	descriptorBindingAccelerationStructureUpdateAfterBind Bool32
}

func (s *_vkPhysicalDeviceAccelerationStructureFeaturesKHR) Goify() *PhysicalDeviceAccelerationStructureFeaturesKHR {
	rval := &PhysicalDeviceAccelerationStructureFeaturesKHR{
		PNext:                              (unsafe.Pointer)(s.pNext),
		AccelerationStructure:              translatePublic_Bool32(s.accelerationStructure),              /*default*/
		AccelerationStructureCaptureReplay: translatePublic_Bool32(s.accelerationStructureCaptureReplay), /*default*/
		AccelerationStructureIndirectBuild: translatePublic_Bool32(s.accelerationStructureIndirectBuild), /*default*/
		AccelerationStructureHostCommands:  translatePublic_Bool32(s.accelerationStructureHostCommands),  /*default*/
		DescriptorBindingAccelerationStructureUpdateAfterBind: translatePublic_Bool32(s.descriptorBindingAccelerationStructureUpdateAfterBind), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceAccelerationStructureFeaturesKHR) Vulkanize() *_vkPhysicalDeviceAccelerationStructureFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceAccelerationStructureFeaturesKHR{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                          /*cb*/
		accelerationStructure:              translateInternal_Bool32(s.AccelerationStructure),                  /*default*/
		accelerationStructureCaptureReplay: translateInternal_Bool32(s.AccelerationStructureCaptureReplay),     /*default*/
		accelerationStructureIndirectBuild: translateInternal_Bool32(s.AccelerationStructureIndirectBuild),     /*default*/
		accelerationStructureHostCommands:  translateInternal_Bool32(s.AccelerationStructureHostCommands),      /*default*/
		descriptorBindingAccelerationStructureUpdateAfterBind: translateInternal_Bool32(s.DescriptorBindingAccelerationStructureUpdateAfterBind), /*default*/
	}
	return rval
}

// PhysicalDeviceAccelerationStructurePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html
type PhysicalDeviceAccelerationStructurePropertiesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR
	PNext                                                      unsafe.Pointer
	MaxGeometryCount                                           uint64
	MaxInstanceCount                                           uint64
	MaxPrimitiveCount                                          uint64
	MaxPerStageDescriptorAccelerationStructures                uint32
	MaxPerStageDescriptorUpdateAfterBindAccelerationStructures uint32
	MaxDescriptorSetAccelerationStructures                     uint32
	MaxDescriptorSetUpdateAfterBindAccelerationStructures      uint32
	MinAccelerationStructureScratchOffsetAlignment             uint32
}

// WARNING - struct PhysicalDeviceAccelerationStructurePropertiesKHR is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceAccelerationStructurePropertiesKHR struct {
	sType                                                      StructureType
	pNext                                                      unsafe.Pointer
	maxGeometryCount                                           uint64
	maxInstanceCount                                           uint64
	maxPrimitiveCount                                          uint64
	maxPerStageDescriptorAccelerationStructures                uint32
	maxPerStageDescriptorUpdateAfterBindAccelerationStructures uint32
	maxDescriptorSetAccelerationStructures                     uint32
	maxDescriptorSetUpdateAfterBindAccelerationStructures      uint32
	minAccelerationStructureScratchOffsetAlignment             uint32
}

func (s *_vkPhysicalDeviceAccelerationStructurePropertiesKHR) Goify() *PhysicalDeviceAccelerationStructurePropertiesKHR {
	rval := &PhysicalDeviceAccelerationStructurePropertiesKHR{
		PNext:             (unsafe.Pointer)(s.pNext),
		MaxGeometryCount:  (uint64)(s.maxGeometryCount),
		MaxInstanceCount:  (uint64)(s.maxInstanceCount),
		MaxPrimitiveCount: (uint64)(s.maxPrimitiveCount),
		MaxPerStageDescriptorAccelerationStructures:                (uint32)(s.maxPerStageDescriptorAccelerationStructures),
		MaxPerStageDescriptorUpdateAfterBindAccelerationStructures: (uint32)(s.maxPerStageDescriptorUpdateAfterBindAccelerationStructures),
		MaxDescriptorSetAccelerationStructures:                     (uint32)(s.maxDescriptorSetAccelerationStructures),
		MaxDescriptorSetUpdateAfterBindAccelerationStructures:      (uint32)(s.maxDescriptorSetUpdateAfterBindAccelerationStructures),
		MinAccelerationStructureScratchOffsetAlignment:             (uint32)(s.minAccelerationStructureScratchOffsetAlignment),
	}
	return rval
}
func (s *PhysicalDeviceAccelerationStructurePropertiesKHR) Vulkanize() *_vkPhysicalDeviceAccelerationStructurePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceAccelerationStructurePropertiesKHR{
		sType:             STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                            /*cb*/
		maxGeometryCount:  (uint64)(s.MaxGeometryCount),                                         /*cb*/
		maxInstanceCount:  (uint64)(s.MaxInstanceCount),                                         /*cb*/
		maxPrimitiveCount: (uint64)(s.MaxPrimitiveCount),                                        /*cb*/
		maxPerStageDescriptorAccelerationStructures:                (uint32)(s.MaxPerStageDescriptorAccelerationStructures),                /*cb*/
		maxPerStageDescriptorUpdateAfterBindAccelerationStructures: (uint32)(s.MaxPerStageDescriptorUpdateAfterBindAccelerationStructures), /*cb*/
		maxDescriptorSetAccelerationStructures:                     (uint32)(s.MaxDescriptorSetAccelerationStructures),                     /*cb*/
		maxDescriptorSetUpdateAfterBindAccelerationStructures:      (uint32)(s.MaxDescriptorSetUpdateAfterBindAccelerationStructures),      /*cb*/
		minAccelerationStructureScratchOffsetAlignment:             (uint32)(s.MinAccelerationStructureScratchOffsetAlignment),             /*cb*/
	}
	return rval
}

// PhysicalDeviceAddressBindingReportFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAddressBindingReportFeaturesEXT.html
type PhysicalDeviceAddressBindingReportFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT
	PNext                unsafe.Pointer
	ReportAddressBinding bool
}

type _vkPhysicalDeviceAddressBindingReportFeaturesEXT struct {
	sType                StructureType
	pNext                unsafe.Pointer
	reportAddressBinding Bool32
}

func (s *_vkPhysicalDeviceAddressBindingReportFeaturesEXT) Goify() *PhysicalDeviceAddressBindingReportFeaturesEXT {
	rval := &PhysicalDeviceAddressBindingReportFeaturesEXT{
		PNext:                (unsafe.Pointer)(s.pNext),
		ReportAddressBinding: translatePublic_Bool32(s.reportAddressBinding), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceAddressBindingReportFeaturesEXT) Vulkanize() *_vkPhysicalDeviceAddressBindingReportFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceAddressBindingReportFeaturesEXT{
		sType:                STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                          /*cb*/
		reportAddressBinding: translateInternal_Bool32(s.ReportAddressBinding),                   /*default*/
	}
	return rval
}

// PhysicalDeviceAmigoProfilingFeaturesSEC: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAmigoProfilingFeaturesSEC.html
type PhysicalDeviceAmigoProfilingFeaturesSEC struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC
	PNext          unsafe.Pointer
	AmigoProfiling bool
}

type _vkPhysicalDeviceAmigoProfilingFeaturesSEC struct {
	sType          StructureType
	pNext          unsafe.Pointer
	amigoProfiling Bool32
}

func (s *_vkPhysicalDeviceAmigoProfilingFeaturesSEC) Goify() *PhysicalDeviceAmigoProfilingFeaturesSEC {
	rval := &PhysicalDeviceAmigoProfilingFeaturesSEC{
		PNext:          (unsafe.Pointer)(s.pNext),
		AmigoProfiling: translatePublic_Bool32(s.amigoProfiling), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceAmigoProfilingFeaturesSEC) Vulkanize() *_vkPhysicalDeviceAmigoProfilingFeaturesSEC {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceAmigoProfilingFeaturesSEC{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                   /*cb*/
		amigoProfiling: translateInternal_Bool32(s.AmigoProfiling),                  /*default*/
	}
	return rval
}

// PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.html
type PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT
	PNext                              unsafe.Pointer
	AttachmentFeedbackLoopDynamicState bool
}

type _vkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT struct {
	sType                              StructureType
	pNext                              unsafe.Pointer
	attachmentFeedbackLoopDynamicState Bool32
}

func (s *_vkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT) Goify() *PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
	rval := &PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT{
		PNext:                              (unsafe.Pointer)(s.pNext),
		AttachmentFeedbackLoopDynamicState: translatePublic_Bool32(s.attachmentFeedbackLoopDynamicState), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT) Vulkanize() *_vkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                                          /*cb*/
		attachmentFeedbackLoopDynamicState: translateInternal_Bool32(s.AttachmentFeedbackLoopDynamicState),                     /*default*/
	}
	return rval
}

// PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.html
type PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT
	PNext                        unsafe.Pointer
	AttachmentFeedbackLoopLayout bool
}

type _vkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	attachmentFeedbackLoopLayout Bool32
}

func (s *_vkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT) Goify() *PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
	rval := &PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT{
		PNext:                        (unsafe.Pointer)(s.pNext),
		AttachmentFeedbackLoopLayout: translatePublic_Bool32(s.attachmentFeedbackLoopLayout), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT) Vulkanize() *_vkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                                   /*cb*/
		attachmentFeedbackLoopLayout: translateInternal_Bool32(s.AttachmentFeedbackLoopLayout),                    /*default*/
	}
	return rval
}

// PhysicalDeviceBlendOperationAdvancedFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html
type PhysicalDeviceBlendOperationAdvancedFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT
	PNext                           unsafe.Pointer
	AdvancedBlendCoherentOperations bool
}

type _vkPhysicalDeviceBlendOperationAdvancedFeaturesEXT struct {
	sType                           StructureType
	pNext                           unsafe.Pointer
	advancedBlendCoherentOperations Bool32
}

func (s *_vkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) Goify() *PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
	rval := &PhysicalDeviceBlendOperationAdvancedFeaturesEXT{
		PNext:                           (unsafe.Pointer)(s.pNext),
		AdvancedBlendCoherentOperations: translatePublic_Bool32(s.advancedBlendCoherentOperations), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceBlendOperationAdvancedFeaturesEXT) Vulkanize() *_vkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceBlendOperationAdvancedFeaturesEXT{
		sType:                           STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, /*c1*/
		pNext:                           (unsafe.Pointer)(s.PNext),                                            /*cb*/
		advancedBlendCoherentOperations: translateInternal_Bool32(s.AdvancedBlendCoherentOperations),          /*default*/
	}
	return rval
}

// PhysicalDeviceBlendOperationAdvancedPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html
type PhysicalDeviceBlendOperationAdvancedPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT
	PNext                                 unsafe.Pointer
	AdvancedBlendMaxColorAttachments      uint32
	AdvancedBlendIndependentBlend         bool
	AdvancedBlendNonPremultipliedSrcColor bool
	AdvancedBlendNonPremultipliedDstColor bool
	AdvancedBlendCorrelatedOverlap        bool
	AdvancedBlendAllOperations            bool
}

// WARNING - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceBlendOperationAdvancedPropertiesEXT struct {
	sType                                 StructureType
	pNext                                 unsafe.Pointer
	advancedBlendMaxColorAttachments      uint32
	advancedBlendIndependentBlend         Bool32
	advancedBlendNonPremultipliedSrcColor Bool32
	advancedBlendNonPremultipliedDstColor Bool32
	advancedBlendCorrelatedOverlap        Bool32
	advancedBlendAllOperations            Bool32
}

func (s *_vkPhysicalDeviceBlendOperationAdvancedPropertiesEXT) Goify() *PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
	rval := &PhysicalDeviceBlendOperationAdvancedPropertiesEXT{
		PNext:                                 (unsafe.Pointer)(s.pNext),
		AdvancedBlendMaxColorAttachments:      (uint32)(s.advancedBlendMaxColorAttachments),
		AdvancedBlendIndependentBlend:         translatePublic_Bool32(s.advancedBlendIndependentBlend),         /*default*/
		AdvancedBlendNonPremultipliedSrcColor: translatePublic_Bool32(s.advancedBlendNonPremultipliedSrcColor), /*default*/
		AdvancedBlendNonPremultipliedDstColor: translatePublic_Bool32(s.advancedBlendNonPremultipliedDstColor), /*default*/
		AdvancedBlendCorrelatedOverlap:        translatePublic_Bool32(s.advancedBlendCorrelatedOverlap),        /*default*/
		AdvancedBlendAllOperations:            translatePublic_Bool32(s.advancedBlendAllOperations),            /*default*/
	}
	return rval
}
func (s *PhysicalDeviceBlendOperationAdvancedPropertiesEXT) Vulkanize() *_vkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceBlendOperationAdvancedPropertiesEXT{
		sType:                                 STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, /*c1*/
		pNext:                                 (unsafe.Pointer)(s.PNext),                                              /*cb*/
		advancedBlendMaxColorAttachments:      (uint32)(s.AdvancedBlendMaxColorAttachments),                           /*cb*/
		advancedBlendIndependentBlend:         translateInternal_Bool32(s.AdvancedBlendIndependentBlend),              /*default*/
		advancedBlendNonPremultipliedSrcColor: translateInternal_Bool32(s.AdvancedBlendNonPremultipliedSrcColor),      /*default*/
		advancedBlendNonPremultipliedDstColor: translateInternal_Bool32(s.AdvancedBlendNonPremultipliedDstColor),      /*default*/
		advancedBlendCorrelatedOverlap:        translateInternal_Bool32(s.AdvancedBlendCorrelatedOverlap),             /*default*/
		advancedBlendAllOperations:            translateInternal_Bool32(s.AdvancedBlendAllOperations),                 /*default*/
	}
	return rval
}

// PhysicalDeviceBorderColorSwizzleFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.html
type PhysicalDeviceBorderColorSwizzleFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT
	PNext                       unsafe.Pointer
	BorderColorSwizzle          bool
	BorderColorSwizzleFromImage bool
}

type _vkPhysicalDeviceBorderColorSwizzleFeaturesEXT struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	borderColorSwizzle          Bool32
	borderColorSwizzleFromImage Bool32
}

func (s *_vkPhysicalDeviceBorderColorSwizzleFeaturesEXT) Goify() *PhysicalDeviceBorderColorSwizzleFeaturesEXT {
	rval := &PhysicalDeviceBorderColorSwizzleFeaturesEXT{
		PNext:                       (unsafe.Pointer)(s.pNext),
		BorderColorSwizzle:          translatePublic_Bool32(s.borderColorSwizzle),          /*default*/
		BorderColorSwizzleFromImage: translatePublic_Bool32(s.borderColorSwizzleFromImage), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceBorderColorSwizzleFeaturesEXT) Vulkanize() *_vkPhysicalDeviceBorderColorSwizzleFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceBorderColorSwizzleFeaturesEXT{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                        /*cb*/
		borderColorSwizzle:          translateInternal_Bool32(s.BorderColorSwizzle),                   /*default*/
		borderColorSwizzleFromImage: translateInternal_Bool32(s.BorderColorSwizzleFromImage),          /*default*/
	}
	return rval
}

// PhysicalDeviceBufferAddressFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferAddressFeaturesEXT.html
type PhysicalDeviceBufferAddressFeaturesEXT struct {
}

type _vkPhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferAddressFeaturesEXT

func (s *_vkPhysicalDeviceBufferAddressFeaturesEXT) Goify() *PhysicalDeviceBufferAddressFeaturesEXT {
	rval := (*PhysicalDeviceBufferAddressFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceBufferAddressFeaturesEXT) Vulkanize() *_vkPhysicalDeviceBufferAddressFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceBufferAddressFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceBufferDeviceAddressFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html
type PhysicalDeviceBufferDeviceAddressFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES
	PNext                            unsafe.Pointer
	BufferDeviceAddress              bool
	BufferDeviceAddressCaptureReplay bool
	BufferDeviceAddressMultiDevice   bool
}

type _vkPhysicalDeviceBufferDeviceAddressFeatures struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	bufferDeviceAddress              Bool32
	bufferDeviceAddressCaptureReplay Bool32
	bufferDeviceAddressMultiDevice   Bool32
}

func (s *_vkPhysicalDeviceBufferDeviceAddressFeatures) Goify() *PhysicalDeviceBufferDeviceAddressFeatures {
	rval := &PhysicalDeviceBufferDeviceAddressFeatures{
		PNext:                            (unsafe.Pointer)(s.pNext),
		BufferDeviceAddress:              translatePublic_Bool32(s.bufferDeviceAddress),              /*default*/
		BufferDeviceAddressCaptureReplay: translatePublic_Bool32(s.bufferDeviceAddressCaptureReplay), /*default*/
		BufferDeviceAddressMultiDevice:   translatePublic_Bool32(s.bufferDeviceAddressMultiDevice),   /*default*/
	}
	return rval
}
func (s *PhysicalDeviceBufferDeviceAddressFeatures) Vulkanize() *_vkPhysicalDeviceBufferDeviceAddressFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceBufferDeviceAddressFeatures{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                     /*cb*/
		bufferDeviceAddress:              translateInternal_Bool32(s.BufferDeviceAddress),               /*default*/
		bufferDeviceAddressCaptureReplay: translateInternal_Bool32(s.BufferDeviceAddressCaptureReplay),  /*default*/
		bufferDeviceAddressMultiDevice:   translateInternal_Bool32(s.BufferDeviceAddressMultiDevice),    /*default*/
	}
	return rval
}

// PhysicalDeviceBufferDeviceAddressFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html
type PhysicalDeviceBufferDeviceAddressFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT
	PNext                            unsafe.Pointer
	BufferDeviceAddress              bool
	BufferDeviceAddressCaptureReplay bool
	BufferDeviceAddressMultiDevice   bool
}

type _vkPhysicalDeviceBufferDeviceAddressFeaturesEXT struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	bufferDeviceAddress              Bool32
	bufferDeviceAddressCaptureReplay Bool32
	bufferDeviceAddressMultiDevice   Bool32
}

func (s *_vkPhysicalDeviceBufferDeviceAddressFeaturesEXT) Goify() *PhysicalDeviceBufferDeviceAddressFeaturesEXT {
	rval := &PhysicalDeviceBufferDeviceAddressFeaturesEXT{
		PNext:                            (unsafe.Pointer)(s.pNext),
		BufferDeviceAddress:              translatePublic_Bool32(s.bufferDeviceAddress),              /*default*/
		BufferDeviceAddressCaptureReplay: translatePublic_Bool32(s.bufferDeviceAddressCaptureReplay), /*default*/
		BufferDeviceAddressMultiDevice:   translatePublic_Bool32(s.bufferDeviceAddressMultiDevice),   /*default*/
	}
	return rval
}
func (s *PhysicalDeviceBufferDeviceAddressFeaturesEXT) Vulkanize() *_vkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceBufferDeviceAddressFeaturesEXT{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                         /*cb*/
		bufferDeviceAddress:              translateInternal_Bool32(s.BufferDeviceAddress),                   /*default*/
		bufferDeviceAddressCaptureReplay: translateInternal_Bool32(s.BufferDeviceAddressCaptureReplay),      /*default*/
		bufferDeviceAddressMultiDevice:   translateInternal_Bool32(s.BufferDeviceAddressMultiDevice),        /*default*/
	}
	return rval
}

// PhysicalDeviceBufferDeviceAddressFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesKHR.html
type PhysicalDeviceBufferDeviceAddressFeaturesKHR struct {
}

type _vkPhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeaturesKHR

func (s *_vkPhysicalDeviceBufferDeviceAddressFeaturesKHR) Goify() *PhysicalDeviceBufferDeviceAddressFeaturesKHR {
	rval := (*PhysicalDeviceBufferDeviceAddressFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceBufferDeviceAddressFeaturesKHR) Vulkanize() *_vkPhysicalDeviceBufferDeviceAddressFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceBufferDeviceAddressFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceClusterCullingShaderFeaturesHUAWEI: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.html
type PhysicalDeviceClusterCullingShaderFeaturesHUAWEI struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI
	PNext                         unsafe.Pointer
	ClustercullingShader          bool
	MultiviewClusterCullingShader bool
}

type _vkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	clustercullingShader          Bool32
	multiviewClusterCullingShader Bool32
}

func (s *_vkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI) Goify() *PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
	rval := &PhysicalDeviceClusterCullingShaderFeaturesHUAWEI{
		PNext:                         (unsafe.Pointer)(s.pNext),
		ClustercullingShader:          translatePublic_Bool32(s.clustercullingShader),          /*default*/
		MultiviewClusterCullingShader: translatePublic_Bool32(s.multiviewClusterCullingShader), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceClusterCullingShaderFeaturesHUAWEI) Vulkanize() *_vkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI{
		sType:                         STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                             /*cb*/
		clustercullingShader:          translateInternal_Bool32(s.ClustercullingShader),                      /*default*/
		multiviewClusterCullingShader: translateInternal_Bool32(s.MultiviewClusterCullingShader),             /*default*/
	}
	return rval
}

// PhysicalDeviceClusterCullingShaderPropertiesHUAWEI: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.html
type PhysicalDeviceClusterCullingShaderPropertiesHUAWEI struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI
	PNext                         unsafe.Pointer
	MaxWorkGroupCount             [3]uint32
	MaxWorkGroupSize              [3]uint32
	MaxOutputClusterCount         uint32
	IndirectBufferOffsetAlignment DeviceSize
}

// WARNING - struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	maxWorkGroupCount             [3]uint32
	maxWorkGroupSize              [3]uint32
	maxOutputClusterCount         uint32
	indirectBufferOffsetAlignment DeviceSize
}

func (s *_vkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI) Goify() *PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
	rval := &PhysicalDeviceClusterCullingShaderPropertiesHUAWEI{
		PNext:                         (unsafe.Pointer)(s.pNext),
		MaxWorkGroupCount:             ([3]uint32)(s.maxWorkGroupCount),
		MaxWorkGroupSize:              ([3]uint32)(s.maxWorkGroupSize),
		MaxOutputClusterCount:         (uint32)(s.maxOutputClusterCount),
		IndirectBufferOffsetAlignment: (DeviceSize)(s.indirectBufferOffsetAlignment),
	}
	return rval
}
func (s *PhysicalDeviceClusterCullingShaderPropertiesHUAWEI) Vulkanize() *_vkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI{
		sType:                         STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                               /*cb*/
		maxWorkGroupCount:             ([3]uint32)(s.MaxWorkGroupCount),                                        /*cb*/
		maxWorkGroupSize:              ([3]uint32)(s.MaxWorkGroupSize),                                         /*cb*/
		maxOutputClusterCount:         (uint32)(s.MaxOutputClusterCount),                                       /*cb*/
		indirectBufferOffsetAlignment: (DeviceSize)(s.IndirectBufferOffsetAlignment),                           /*cb*/
	}
	return rval
}

// PhysicalDeviceCoherentMemoryFeaturesAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html
type PhysicalDeviceCoherentMemoryFeaturesAMD struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD
	PNext                unsafe.Pointer
	DeviceCoherentMemory bool
}

type _vkPhysicalDeviceCoherentMemoryFeaturesAMD struct {
	sType                StructureType
	pNext                unsafe.Pointer
	deviceCoherentMemory Bool32
}

func (s *_vkPhysicalDeviceCoherentMemoryFeaturesAMD) Goify() *PhysicalDeviceCoherentMemoryFeaturesAMD {
	rval := &PhysicalDeviceCoherentMemoryFeaturesAMD{
		PNext:                (unsafe.Pointer)(s.pNext),
		DeviceCoherentMemory: translatePublic_Bool32(s.deviceCoherentMemory), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCoherentMemoryFeaturesAMD) Vulkanize() *_vkPhysicalDeviceCoherentMemoryFeaturesAMD {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCoherentMemoryFeaturesAMD{
		sType:                STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                   /*cb*/
		deviceCoherentMemory: translateInternal_Bool32(s.DeviceCoherentMemory),            /*default*/
	}
	return rval
}

// PhysicalDeviceColorWriteEnableFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html
type PhysicalDeviceColorWriteEnableFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT
	PNext            unsafe.Pointer
	ColorWriteEnable bool
}

type _vkPhysicalDeviceColorWriteEnableFeaturesEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	colorWriteEnable Bool32
}

func (s *_vkPhysicalDeviceColorWriteEnableFeaturesEXT) Goify() *PhysicalDeviceColorWriteEnableFeaturesEXT {
	rval := &PhysicalDeviceColorWriteEnableFeaturesEXT{
		PNext:            (unsafe.Pointer)(s.pNext),
		ColorWriteEnable: translatePublic_Bool32(s.colorWriteEnable), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceColorWriteEnableFeaturesEXT) Vulkanize() *_vkPhysicalDeviceColorWriteEnableFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceColorWriteEnableFeaturesEXT{
		sType:            STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                      /*cb*/
		colorWriteEnable: translateInternal_Bool32(s.ColorWriteEnable),                   /*default*/
	}
	return rval
}

// PhysicalDeviceComputeShaderDerivativesFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html
type PhysicalDeviceComputeShaderDerivativesFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV
	PNext                        unsafe.Pointer
	ComputeDerivativeGroupQuads  bool
	ComputeDerivativeGroupLinear bool
}

type _vkPhysicalDeviceComputeShaderDerivativesFeaturesNV struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	computeDerivativeGroupQuads  Bool32
	computeDerivativeGroupLinear Bool32
}

func (s *_vkPhysicalDeviceComputeShaderDerivativesFeaturesNV) Goify() *PhysicalDeviceComputeShaderDerivativesFeaturesNV {
	rval := &PhysicalDeviceComputeShaderDerivativesFeaturesNV{
		PNext:                        (unsafe.Pointer)(s.pNext),
		ComputeDerivativeGroupQuads:  translatePublic_Bool32(s.computeDerivativeGroupQuads),  /*default*/
		ComputeDerivativeGroupLinear: translatePublic_Bool32(s.computeDerivativeGroupLinear), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceComputeShaderDerivativesFeaturesNV) Vulkanize() *_vkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceComputeShaderDerivativesFeaturesNV{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                             /*cb*/
		computeDerivativeGroupQuads:  translateInternal_Bool32(s.ComputeDerivativeGroupQuads),               /*default*/
		computeDerivativeGroupLinear: translateInternal_Bool32(s.ComputeDerivativeGroupLinear),              /*default*/
	}
	return rval
}

// PhysicalDeviceConditionalRenderingFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html
type PhysicalDeviceConditionalRenderingFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT
	PNext                         unsafe.Pointer
	ConditionalRendering          bool
	InheritedConditionalRendering bool
}

type _vkPhysicalDeviceConditionalRenderingFeaturesEXT struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	conditionalRendering          Bool32
	inheritedConditionalRendering Bool32
}

func (s *_vkPhysicalDeviceConditionalRenderingFeaturesEXT) Goify() *PhysicalDeviceConditionalRenderingFeaturesEXT {
	rval := &PhysicalDeviceConditionalRenderingFeaturesEXT{
		PNext:                         (unsafe.Pointer)(s.pNext),
		ConditionalRendering:          translatePublic_Bool32(s.conditionalRendering),          /*default*/
		InheritedConditionalRendering: translatePublic_Bool32(s.inheritedConditionalRendering), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceConditionalRenderingFeaturesEXT) Vulkanize() *_vkPhysicalDeviceConditionalRenderingFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceConditionalRenderingFeaturesEXT{
		sType:                         STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                         /*cb*/
		conditionalRendering:          translateInternal_Bool32(s.ConditionalRendering),                  /*default*/
		inheritedConditionalRendering: translateInternal_Bool32(s.InheritedConditionalRendering),         /*default*/
	}
	return rval
}

// PhysicalDeviceConservativeRasterizationPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html
type PhysicalDeviceConservativeRasterizationPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT
	PNext unsafe.Pointer
	//  The size in pixels the primitive is enlarged at each edge during conservative rasterization;
	PrimitiveOverestimationSize float32
	//  The maximum additional overestimation the client can specify in the pipeline state;
	MaxExtraPrimitiveOverestimationSize float32
	//  The granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize;
	ExtraPrimitiveOverestimationSizeGranularity float32
	//  true if the implementation supports conservative rasterization underestimation mode;
	PrimitiveUnderestimation bool
	//  true if conservative rasterization also applies to points and lines;
	ConservativePointAndLineRasterization bool
	//  true if degenerate triangles (those with zero area after snap) are rasterized;
	DegenerateTrianglesRasterized bool
	//  true if degenerate lines (those with zero length after snap) are rasterized;
	DegenerateLinesRasterized bool
	//  true if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable;
	FullyCoveredFragmentShaderInputVariable bool
	//  true if the implementation supports both conservative rasterization and post depth coverage sample coverage mask;
	ConservativeRasterizationPostDepthCoverage bool
}

// WARNING - struct PhysicalDeviceConservativeRasterizationPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceConservativeRasterizationPropertiesEXT struct {
	sType                                       StructureType
	pNext                                       unsafe.Pointer
	primitiveOverestimationSize                 float32
	maxExtraPrimitiveOverestimationSize         float32
	extraPrimitiveOverestimationSizeGranularity float32
	primitiveUnderestimation                    Bool32
	conservativePointAndLineRasterization       Bool32
	degenerateTrianglesRasterized               Bool32
	degenerateLinesRasterized                   Bool32
	fullyCoveredFragmentShaderInputVariable     Bool32
	conservativeRasterizationPostDepthCoverage  Bool32
}

func (s *_vkPhysicalDeviceConservativeRasterizationPropertiesEXT) Goify() *PhysicalDeviceConservativeRasterizationPropertiesEXT {
	rval := &PhysicalDeviceConservativeRasterizationPropertiesEXT{
		PNext:                               (unsafe.Pointer)(s.pNext),
		PrimitiveOverestimationSize:         (float32)(s.primitiveOverestimationSize),
		MaxExtraPrimitiveOverestimationSize: (float32)(s.maxExtraPrimitiveOverestimationSize),
		ExtraPrimitiveOverestimationSizeGranularity: (float32)(s.extraPrimitiveOverestimationSizeGranularity),
		PrimitiveUnderestimation:                    translatePublic_Bool32(s.primitiveUnderestimation),                   /*default*/
		ConservativePointAndLineRasterization:       translatePublic_Bool32(s.conservativePointAndLineRasterization),      /*default*/
		DegenerateTrianglesRasterized:               translatePublic_Bool32(s.degenerateTrianglesRasterized),              /*default*/
		DegenerateLinesRasterized:                   translatePublic_Bool32(s.degenerateLinesRasterized),                  /*default*/
		FullyCoveredFragmentShaderInputVariable:     translatePublic_Bool32(s.fullyCoveredFragmentShaderInputVariable),    /*default*/
		ConservativeRasterizationPostDepthCoverage:  translatePublic_Bool32(s.conservativeRasterizationPostDepthCoverage), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceConservativeRasterizationPropertiesEXT) Vulkanize() *_vkPhysicalDeviceConservativeRasterizationPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceConservativeRasterizationPropertiesEXT{
		sType:                               STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, /*c1*/
		pNext:                               (unsafe.Pointer)(s.PNext),                                                /*cb*/
		primitiveOverestimationSize:         (float32)(s.PrimitiveOverestimationSize),                                 /*cb*/
		maxExtraPrimitiveOverestimationSize: (float32)(s.MaxExtraPrimitiveOverestimationSize),                         /*cb*/
		extraPrimitiveOverestimationSizeGranularity: (float32)(s.ExtraPrimitiveOverestimationSizeGranularity),               /*cb*/
		primitiveUnderestimation:                    translateInternal_Bool32(s.PrimitiveUnderestimation),                   /*default*/
		conservativePointAndLineRasterization:       translateInternal_Bool32(s.ConservativePointAndLineRasterization),      /*default*/
		degenerateTrianglesRasterized:               translateInternal_Bool32(s.DegenerateTrianglesRasterized),              /*default*/
		degenerateLinesRasterized:                   translateInternal_Bool32(s.DegenerateLinesRasterized),                  /*default*/
		fullyCoveredFragmentShaderInputVariable:     translateInternal_Bool32(s.FullyCoveredFragmentShaderInputVariable),    /*default*/
		conservativeRasterizationPostDepthCoverage:  translateInternal_Bool32(s.ConservativeRasterizationPostDepthCoverage), /*default*/
	}
	return rval
}

// PhysicalDeviceCooperativeMatrixFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesKHR.html
type PhysicalDeviceCooperativeMatrixFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR
	PNext                               unsafe.Pointer
	CooperativeMatrix                   bool
	CooperativeMatrixRobustBufferAccess bool
}

type _vkPhysicalDeviceCooperativeMatrixFeaturesKHR struct {
	sType                               StructureType
	pNext                               unsafe.Pointer
	cooperativeMatrix                   Bool32
	cooperativeMatrixRobustBufferAccess Bool32
}

func (s *_vkPhysicalDeviceCooperativeMatrixFeaturesKHR) Goify() *PhysicalDeviceCooperativeMatrixFeaturesKHR {
	rval := &PhysicalDeviceCooperativeMatrixFeaturesKHR{
		PNext:                               (unsafe.Pointer)(s.pNext),
		CooperativeMatrix:                   translatePublic_Bool32(s.cooperativeMatrix),                   /*default*/
		CooperativeMatrixRobustBufferAccess: translatePublic_Bool32(s.cooperativeMatrixRobustBufferAccess), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCooperativeMatrixFeaturesKHR) Vulkanize() *_vkPhysicalDeviceCooperativeMatrixFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCooperativeMatrixFeaturesKHR{
		sType:                               STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR,  /*c1*/
		pNext:                               (unsafe.Pointer)(s.PNext),                                       /*cb*/
		cooperativeMatrix:                   translateInternal_Bool32(s.CooperativeMatrix),                   /*default*/
		cooperativeMatrixRobustBufferAccess: translateInternal_Bool32(s.CooperativeMatrixRobustBufferAccess), /*default*/
	}
	return rval
}

// PhysicalDeviceCooperativeMatrixFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html
type PhysicalDeviceCooperativeMatrixFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV
	PNext                               unsafe.Pointer
	CooperativeMatrix                   bool
	CooperativeMatrixRobustBufferAccess bool
}

type _vkPhysicalDeviceCooperativeMatrixFeaturesNV struct {
	sType                               StructureType
	pNext                               unsafe.Pointer
	cooperativeMatrix                   Bool32
	cooperativeMatrixRobustBufferAccess Bool32
}

func (s *_vkPhysicalDeviceCooperativeMatrixFeaturesNV) Goify() *PhysicalDeviceCooperativeMatrixFeaturesNV {
	rval := &PhysicalDeviceCooperativeMatrixFeaturesNV{
		PNext:                               (unsafe.Pointer)(s.pNext),
		CooperativeMatrix:                   translatePublic_Bool32(s.cooperativeMatrix),                   /*default*/
		CooperativeMatrixRobustBufferAccess: translatePublic_Bool32(s.cooperativeMatrixRobustBufferAccess), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCooperativeMatrixFeaturesNV) Vulkanize() *_vkPhysicalDeviceCooperativeMatrixFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCooperativeMatrixFeaturesNV{
		sType:                               STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,   /*c1*/
		pNext:                               (unsafe.Pointer)(s.PNext),                                       /*cb*/
		cooperativeMatrix:                   translateInternal_Bool32(s.CooperativeMatrix),                   /*default*/
		cooperativeMatrixRobustBufferAccess: translateInternal_Bool32(s.CooperativeMatrixRobustBufferAccess), /*default*/
	}
	return rval
}

// PhysicalDeviceCooperativeMatrixPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesKHR.html
type PhysicalDeviceCooperativeMatrixPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR
	PNext                            unsafe.Pointer
	CooperativeMatrixSupportedStages ShaderStageFlags
}

// WARNING - struct PhysicalDeviceCooperativeMatrixPropertiesKHR is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceCooperativeMatrixPropertiesKHR struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	cooperativeMatrixSupportedStages ShaderStageFlags
}

func (s *_vkPhysicalDeviceCooperativeMatrixPropertiesKHR) Goify() *PhysicalDeviceCooperativeMatrixPropertiesKHR {
	rval := &PhysicalDeviceCooperativeMatrixPropertiesKHR{
		PNext:                            (unsafe.Pointer)(s.pNext),
		CooperativeMatrixSupportedStages: (ShaderStageFlags)(s.cooperativeMatrixSupportedStages),
	}
	return rval
}
func (s *PhysicalDeviceCooperativeMatrixPropertiesKHR) Vulkanize() *_vkPhysicalDeviceCooperativeMatrixPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCooperativeMatrixPropertiesKHR{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                        /*cb*/
		cooperativeMatrixSupportedStages: (ShaderStageFlags)(s.CooperativeMatrixSupportedStages),           /*cb*/
	}
	return rval
}

// PhysicalDeviceCooperativeMatrixPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html
type PhysicalDeviceCooperativeMatrixPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV
	PNext                            unsafe.Pointer
	CooperativeMatrixSupportedStages ShaderStageFlags
}

// WARNING - struct PhysicalDeviceCooperativeMatrixPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceCooperativeMatrixPropertiesNV struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	cooperativeMatrixSupportedStages ShaderStageFlags
}

func (s *_vkPhysicalDeviceCooperativeMatrixPropertiesNV) Goify() *PhysicalDeviceCooperativeMatrixPropertiesNV {
	rval := &PhysicalDeviceCooperativeMatrixPropertiesNV{
		PNext:                            (unsafe.Pointer)(s.pNext),
		CooperativeMatrixSupportedStages: (ShaderStageFlags)(s.cooperativeMatrixSupportedStages),
	}
	return rval
}
func (s *PhysicalDeviceCooperativeMatrixPropertiesNV) Vulkanize() *_vkPhysicalDeviceCooperativeMatrixPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCooperativeMatrixPropertiesNV{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                       /*cb*/
		cooperativeMatrixSupportedStages: (ShaderStageFlags)(s.CooperativeMatrixSupportedStages),          /*cb*/
	}
	return rval
}

// PhysicalDeviceCopyMemoryIndirectFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.html
type PhysicalDeviceCopyMemoryIndirectFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV
	PNext        unsafe.Pointer
	IndirectCopy bool
}

type _vkPhysicalDeviceCopyMemoryIndirectFeaturesNV struct {
	sType        StructureType
	pNext        unsafe.Pointer
	indirectCopy Bool32
}

func (s *_vkPhysicalDeviceCopyMemoryIndirectFeaturesNV) Goify() *PhysicalDeviceCopyMemoryIndirectFeaturesNV {
	rval := &PhysicalDeviceCopyMemoryIndirectFeaturesNV{
		PNext:        (unsafe.Pointer)(s.pNext),
		IndirectCopy: translatePublic_Bool32(s.indirectCopy), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCopyMemoryIndirectFeaturesNV) Vulkanize() *_vkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCopyMemoryIndirectFeaturesNV{
		sType:        STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                                       /*cb*/
		indirectCopy: translateInternal_Bool32(s.IndirectCopy),                        /*default*/
	}
	return rval
}

// PhysicalDeviceCopyMemoryIndirectPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.html
type PhysicalDeviceCopyMemoryIndirectPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV
	PNext unsafe.Pointer
	//  Bitfield of which queues are supported for indirect copy;
	SupportedQueues QueueFlags
}

// WARNING - struct PhysicalDeviceCopyMemoryIndirectPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceCopyMemoryIndirectPropertiesNV struct {
	sType           StructureType
	pNext           unsafe.Pointer
	supportedQueues QueueFlags
}

func (s *_vkPhysicalDeviceCopyMemoryIndirectPropertiesNV) Goify() *PhysicalDeviceCopyMemoryIndirectPropertiesNV {
	rval := &PhysicalDeviceCopyMemoryIndirectPropertiesNV{
		PNext:           (unsafe.Pointer)(s.pNext),
		SupportedQueues: (QueueFlags)(s.supportedQueues),
	}
	return rval
}
func (s *PhysicalDeviceCopyMemoryIndirectPropertiesNV) Vulkanize() *_vkPhysicalDeviceCopyMemoryIndirectPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCopyMemoryIndirectPropertiesNV{
		sType:           STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                         /*cb*/
		supportedQueues: (QueueFlags)(s.SupportedQueues),                                   /*cb*/
	}
	return rval
}

// PhysicalDeviceCornerSampledImageFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html
type PhysicalDeviceCornerSampledImageFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV
	PNext              unsafe.Pointer
	CornerSampledImage bool
}

type _vkPhysicalDeviceCornerSampledImageFeaturesNV struct {
	sType              StructureType
	pNext              unsafe.Pointer
	cornerSampledImage Bool32
}

func (s *_vkPhysicalDeviceCornerSampledImageFeaturesNV) Goify() *PhysicalDeviceCornerSampledImageFeaturesNV {
	rval := &PhysicalDeviceCornerSampledImageFeaturesNV{
		PNext:              (unsafe.Pointer)(s.pNext),
		CornerSampledImage: translatePublic_Bool32(s.cornerSampledImage), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCornerSampledImageFeaturesNV) Vulkanize() *_vkPhysicalDeviceCornerSampledImageFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCornerSampledImageFeaturesNV{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                       /*cb*/
		cornerSampledImage: translateInternal_Bool32(s.CornerSampledImage),                  /*default*/
	}
	return rval
}

// PhysicalDeviceCoverageReductionModeFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html
type PhysicalDeviceCoverageReductionModeFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV
	PNext                 unsafe.Pointer
	CoverageReductionMode bool
}

type _vkPhysicalDeviceCoverageReductionModeFeaturesNV struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	coverageReductionMode Bool32
}

func (s *_vkPhysicalDeviceCoverageReductionModeFeaturesNV) Goify() *PhysicalDeviceCoverageReductionModeFeaturesNV {
	rval := &PhysicalDeviceCoverageReductionModeFeaturesNV{
		PNext:                 (unsafe.Pointer)(s.pNext),
		CoverageReductionMode: translatePublic_Bool32(s.coverageReductionMode), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCoverageReductionModeFeaturesNV) Vulkanize() *_vkPhysicalDeviceCoverageReductionModeFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCoverageReductionModeFeaturesNV{
		sType:                 STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                          /*cb*/
		coverageReductionMode: translateInternal_Bool32(s.CoverageReductionMode),                  /*default*/
	}
	return rval
}

// PhysicalDeviceCubicClampFeaturesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCubicClampFeaturesQCOM.html
type PhysicalDeviceCubicClampFeaturesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM
	PNext           unsafe.Pointer
	CubicRangeClamp bool
}

type _vkPhysicalDeviceCubicClampFeaturesQCOM struct {
	sType           StructureType
	pNext           unsafe.Pointer
	cubicRangeClamp Bool32
}

func (s *_vkPhysicalDeviceCubicClampFeaturesQCOM) Goify() *PhysicalDeviceCubicClampFeaturesQCOM {
	rval := &PhysicalDeviceCubicClampFeaturesQCOM{
		PNext:           (unsafe.Pointer)(s.pNext),
		CubicRangeClamp: translatePublic_Bool32(s.cubicRangeClamp), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCubicClampFeaturesQCOM) Vulkanize() *_vkPhysicalDeviceCubicClampFeaturesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCubicClampFeaturesQCOM{
		sType:           STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                /*cb*/
		cubicRangeClamp: translateInternal_Bool32(s.CubicRangeClamp),              /*default*/
	}
	return rval
}

// PhysicalDeviceCubicWeightsFeaturesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCubicWeightsFeaturesQCOM.html
type PhysicalDeviceCubicWeightsFeaturesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM
	PNext                  unsafe.Pointer
	SelectableCubicWeights bool
}

type _vkPhysicalDeviceCubicWeightsFeaturesQCOM struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	selectableCubicWeights Bool32
}

func (s *_vkPhysicalDeviceCubicWeightsFeaturesQCOM) Goify() *PhysicalDeviceCubicWeightsFeaturesQCOM {
	rval := &PhysicalDeviceCubicWeightsFeaturesQCOM{
		PNext:                  (unsafe.Pointer)(s.pNext),
		SelectableCubicWeights: translatePublic_Bool32(s.selectableCubicWeights), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCubicWeightsFeaturesQCOM) Vulkanize() *_vkPhysicalDeviceCubicWeightsFeaturesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCubicWeightsFeaturesQCOM{
		sType:                  STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                  /*cb*/
		selectableCubicWeights: translateInternal_Bool32(s.SelectableCubicWeights),         /*default*/
	}
	return rval
}

// PhysicalDeviceCudaKernelLaunchFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCudaKernelLaunchFeaturesNV.html
type PhysicalDeviceCudaKernelLaunchFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV
	PNext                    unsafe.Pointer
	CudaKernelLaunchFeatures bool
}

type _vkPhysicalDeviceCudaKernelLaunchFeaturesNV struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	cudaKernelLaunchFeatures Bool32
}

func (s *_vkPhysicalDeviceCudaKernelLaunchFeaturesNV) Goify() *PhysicalDeviceCudaKernelLaunchFeaturesNV {
	rval := &PhysicalDeviceCudaKernelLaunchFeaturesNV{
		PNext:                    (unsafe.Pointer)(s.pNext),
		CudaKernelLaunchFeatures: translatePublic_Bool32(s.cudaKernelLaunchFeatures), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCudaKernelLaunchFeaturesNV) Vulkanize() *_vkPhysicalDeviceCudaKernelLaunchFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCudaKernelLaunchFeaturesNV{
		sType:                    STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                     /*cb*/
		cudaKernelLaunchFeatures: translateInternal_Bool32(s.CudaKernelLaunchFeatures),          /*default*/
	}
	return rval
}

// PhysicalDeviceCudaKernelLaunchPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCudaKernelLaunchPropertiesNV.html
type PhysicalDeviceCudaKernelLaunchPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV
	PNext                  unsafe.Pointer
	ComputeCapabilityMinor uint32
	ComputeCapabilityMajor uint32
}

// WARNING - struct PhysicalDeviceCudaKernelLaunchPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceCudaKernelLaunchPropertiesNV struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	computeCapabilityMinor uint32
	computeCapabilityMajor uint32
}

func (s *_vkPhysicalDeviceCudaKernelLaunchPropertiesNV) Goify() *PhysicalDeviceCudaKernelLaunchPropertiesNV {
	rval := &PhysicalDeviceCudaKernelLaunchPropertiesNV{
		PNext:                  (unsafe.Pointer)(s.pNext),
		ComputeCapabilityMinor: (uint32)(s.computeCapabilityMinor),
		ComputeCapabilityMajor: (uint32)(s.computeCapabilityMajor),
	}
	return rval
}
func (s *PhysicalDeviceCudaKernelLaunchPropertiesNV) Vulkanize() *_vkPhysicalDeviceCudaKernelLaunchPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCudaKernelLaunchPropertiesNV{
		sType:                  STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                       /*cb*/
		computeCapabilityMinor: (uint32)(s.ComputeCapabilityMinor),                              /*cb*/
		computeCapabilityMajor: (uint32)(s.ComputeCapabilityMajor),                              /*cb*/
	}
	return rval
}

// PhysicalDeviceCustomBorderColorFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html
type PhysicalDeviceCustomBorderColorFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT
	PNext                          unsafe.Pointer
	CustomBorderColors             bool
	CustomBorderColorWithoutFormat bool
}

type _vkPhysicalDeviceCustomBorderColorFeaturesEXT struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	customBorderColors             Bool32
	customBorderColorWithoutFormat Bool32
}

func (s *_vkPhysicalDeviceCustomBorderColorFeaturesEXT) Goify() *PhysicalDeviceCustomBorderColorFeaturesEXT {
	rval := &PhysicalDeviceCustomBorderColorFeaturesEXT{
		PNext:                          (unsafe.Pointer)(s.pNext),
		CustomBorderColors:             translatePublic_Bool32(s.customBorderColors),             /*default*/
		CustomBorderColorWithoutFormat: translatePublic_Bool32(s.customBorderColorWithoutFormat), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceCustomBorderColorFeaturesEXT) Vulkanize() *_vkPhysicalDeviceCustomBorderColorFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCustomBorderColorFeaturesEXT{
		sType:                          STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                       /*cb*/
		customBorderColors:             translateInternal_Bool32(s.CustomBorderColors),                  /*default*/
		customBorderColorWithoutFormat: translateInternal_Bool32(s.CustomBorderColorWithoutFormat),      /*default*/
	}
	return rval
}

// PhysicalDeviceCustomBorderColorPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html
type PhysicalDeviceCustomBorderColorPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT
	PNext                        unsafe.Pointer
	MaxCustomBorderColorSamplers uint32
}

// WARNING - struct PhysicalDeviceCustomBorderColorPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceCustomBorderColorPropertiesEXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	maxCustomBorderColorSamplers uint32
}

func (s *_vkPhysicalDeviceCustomBorderColorPropertiesEXT) Goify() *PhysicalDeviceCustomBorderColorPropertiesEXT {
	rval := &PhysicalDeviceCustomBorderColorPropertiesEXT{
		PNext:                        (unsafe.Pointer)(s.pNext),
		MaxCustomBorderColorSamplers: (uint32)(s.maxCustomBorderColorSamplers),
	}
	return rval
}
func (s *PhysicalDeviceCustomBorderColorPropertiesEXT) Vulkanize() *_vkPhysicalDeviceCustomBorderColorPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceCustomBorderColorPropertiesEXT{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                         /*cb*/
		maxCustomBorderColorSamplers: (uint32)(s.MaxCustomBorderColorSamplers),                          /*cb*/
	}
	return rval
}

// PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html
type PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV
	PNext                            unsafe.Pointer
	DedicatedAllocationImageAliasing bool
}

type _vkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	dedicatedAllocationImageAliasing Bool32
}

func (s *_vkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV) Goify() *PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
	rval := &PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV{
		PNext:                            (unsafe.Pointer)(s.pNext),
		DedicatedAllocationImageAliasing: translatePublic_Bool32(s.dedicatedAllocationImageAliasing), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV) Vulkanize() *_vkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                                      /*cb*/
		dedicatedAllocationImageAliasing: translateInternal_Bool32(s.DedicatedAllocationImageAliasing),                   /*default*/
	}
	return rval
}

// PhysicalDeviceDepthBiasControlFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthBiasControlFeaturesEXT.html
type PhysicalDeviceDepthBiasControlFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT
	PNext                                           unsafe.Pointer
	DepthBiasControl                                bool
	LeastRepresentableValueForceUnormRepresentation bool
	FloatRepresentation                             bool
	DepthBiasExact                                  bool
}

type _vkPhysicalDeviceDepthBiasControlFeaturesEXT struct {
	sType                                           StructureType
	pNext                                           unsafe.Pointer
	depthBiasControl                                Bool32
	leastRepresentableValueForceUnormRepresentation Bool32
	floatRepresentation                             Bool32
	depthBiasExact                                  Bool32
}

func (s *_vkPhysicalDeviceDepthBiasControlFeaturesEXT) Goify() *PhysicalDeviceDepthBiasControlFeaturesEXT {
	rval := &PhysicalDeviceDepthBiasControlFeaturesEXT{
		PNext:            (unsafe.Pointer)(s.pNext),
		DepthBiasControl: translatePublic_Bool32(s.depthBiasControl), /*default*/
		LeastRepresentableValueForceUnormRepresentation: translatePublic_Bool32(s.leastRepresentableValueForceUnormRepresentation), /*default*/
		FloatRepresentation:                             translatePublic_Bool32(s.floatRepresentation),                             /*default*/
		DepthBiasExact:                                  translatePublic_Bool32(s.depthBiasExact),                                  /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDepthBiasControlFeaturesEXT) Vulkanize() *_vkPhysicalDeviceDepthBiasControlFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDepthBiasControlFeaturesEXT{
		sType:            STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                      /*cb*/
		depthBiasControl: translateInternal_Bool32(s.DepthBiasControl),                   /*default*/
		leastRepresentableValueForceUnormRepresentation: translateInternal_Bool32(s.LeastRepresentableValueForceUnormRepresentation), /*default*/
		floatRepresentation:                             translateInternal_Bool32(s.FloatRepresentation),                             /*default*/
		depthBiasExact:                                  translateInternal_Bool32(s.DepthBiasExact),                                  /*default*/
	}
	return rval
}

// PhysicalDeviceDepthClampZeroOneFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClampZeroOneFeaturesEXT.html
type PhysicalDeviceDepthClampZeroOneFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT
	PNext             unsafe.Pointer
	DepthClampZeroOne bool
}

type _vkPhysicalDeviceDepthClampZeroOneFeaturesEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	depthClampZeroOne Bool32
}

func (s *_vkPhysicalDeviceDepthClampZeroOneFeaturesEXT) Goify() *PhysicalDeviceDepthClampZeroOneFeaturesEXT {
	rval := &PhysicalDeviceDepthClampZeroOneFeaturesEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		DepthClampZeroOne: translatePublic_Bool32(s.depthClampZeroOne), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDepthClampZeroOneFeaturesEXT) Vulkanize() *_vkPhysicalDeviceDepthClampZeroOneFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDepthClampZeroOneFeaturesEXT{
		sType:             STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                        /*cb*/
		depthClampZeroOne: translateInternal_Bool32(s.DepthClampZeroOne),                    /*default*/
	}
	return rval
}

// PhysicalDeviceDepthClipControlFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipControlFeaturesEXT.html
type PhysicalDeviceDepthClipControlFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT
	PNext            unsafe.Pointer
	DepthClipControl bool
}

type _vkPhysicalDeviceDepthClipControlFeaturesEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	depthClipControl Bool32
}

func (s *_vkPhysicalDeviceDepthClipControlFeaturesEXT) Goify() *PhysicalDeviceDepthClipControlFeaturesEXT {
	rval := &PhysicalDeviceDepthClipControlFeaturesEXT{
		PNext:            (unsafe.Pointer)(s.pNext),
		DepthClipControl: translatePublic_Bool32(s.depthClipControl), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDepthClipControlFeaturesEXT) Vulkanize() *_vkPhysicalDeviceDepthClipControlFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDepthClipControlFeaturesEXT{
		sType:            STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                      /*cb*/
		depthClipControl: translateInternal_Bool32(s.DepthClipControl),                   /*default*/
	}
	return rval
}

// PhysicalDeviceDepthClipEnableFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html
type PhysicalDeviceDepthClipEnableFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT
	PNext           unsafe.Pointer
	DepthClipEnable bool
}

type _vkPhysicalDeviceDepthClipEnableFeaturesEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	depthClipEnable Bool32
}

func (s *_vkPhysicalDeviceDepthClipEnableFeaturesEXT) Goify() *PhysicalDeviceDepthClipEnableFeaturesEXT {
	rval := &PhysicalDeviceDepthClipEnableFeaturesEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		DepthClipEnable: translatePublic_Bool32(s.depthClipEnable), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDepthClipEnableFeaturesEXT) Vulkanize() *_vkPhysicalDeviceDepthClipEnableFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDepthClipEnableFeaturesEXT{
		sType:           STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                     /*cb*/
		depthClipEnable: translateInternal_Bool32(s.DepthClipEnable),                   /*default*/
	}
	return rval
}

// PhysicalDeviceDepthStencilResolveProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html
type PhysicalDeviceDepthStencilResolveProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES
	PNext unsafe.Pointer
	//  supported depth resolve modes;
	SupportedDepthResolveModes ResolveModeFlags
	//  supported stencil resolve modes;
	SupportedStencilResolveModes ResolveModeFlags
	//  depth and stencil resolve modes can be set independently if one of them is none;
	IndependentResolveNone bool
	//  depth and stencil resolve modes can be set independently;
	IndependentResolve bool
}

// WARNING - struct PhysicalDeviceDepthStencilResolveProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceDepthStencilResolveProperties struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	supportedDepthResolveModes   ResolveModeFlags
	supportedStencilResolveModes ResolveModeFlags
	independentResolveNone       Bool32
	independentResolve           Bool32
}

func (s *_vkPhysicalDeviceDepthStencilResolveProperties) Goify() *PhysicalDeviceDepthStencilResolveProperties {
	rval := &PhysicalDeviceDepthStencilResolveProperties{
		PNext:                        (unsafe.Pointer)(s.pNext),
		SupportedDepthResolveModes:   (ResolveModeFlags)(s.supportedDepthResolveModes),
		SupportedStencilResolveModes: (ResolveModeFlags)(s.supportedStencilResolveModes),
		IndependentResolveNone:       translatePublic_Bool32(s.independentResolveNone), /*default*/
		IndependentResolve:           translatePublic_Bool32(s.independentResolve),     /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDepthStencilResolveProperties) Vulkanize() *_vkPhysicalDeviceDepthStencilResolveProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDepthStencilResolveProperties{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                       /*cb*/
		supportedDepthResolveModes:   (ResolveModeFlags)(s.SupportedDepthResolveModes),                /*cb*/
		supportedStencilResolveModes: (ResolveModeFlags)(s.SupportedStencilResolveModes),              /*cb*/
		independentResolveNone:       translateInternal_Bool32(s.IndependentResolveNone),              /*default*/
		independentResolve:           translateInternal_Bool32(s.IndependentResolve),                  /*default*/
	}
	return rval
}

// PhysicalDeviceDepthStencilResolvePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthStencilResolvePropertiesKHR.html
type PhysicalDeviceDepthStencilResolvePropertiesKHR struct {
}

type _vkPhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolvePropertiesKHR

func (s *_vkPhysicalDeviceDepthStencilResolvePropertiesKHR) Goify() *PhysicalDeviceDepthStencilResolvePropertiesKHR {
	rval := (*PhysicalDeviceDepthStencilResolvePropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceDepthStencilResolvePropertiesKHR) Vulkanize() *_vkPhysicalDeviceDepthStencilResolvePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceDepthStencilResolvePropertiesKHR)(s)
	return rval
}

// PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.html
type PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT
	PNext                                        unsafe.Pointer
	CombinedImageSamplerDensityMapDescriptorSize uintptr
}

// WARNING - struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT struct {
	sType                                        StructureType
	pNext                                        unsafe.Pointer
	combinedImageSamplerDensityMapDescriptorSize uintptr
}

func (s *_vkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT) Goify() *PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
	rval := &PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		CombinedImageSamplerDensityMapDescriptorSize: (uintptr)(s.combinedImageSamplerDensityMapDescriptorSize),
	}
	return rval
}
func (s *PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT) Vulkanize() *_vkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                                   /*cb*/
		combinedImageSamplerDensityMapDescriptorSize: (uintptr)(s.CombinedImageSamplerDensityMapDescriptorSize), /*cb*/
	}
	return rval
}

// PhysicalDeviceDescriptorBufferFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorBufferFeaturesEXT.html
type PhysicalDeviceDescriptorBufferFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT
	PNext                              unsafe.Pointer
	DescriptorBuffer                   bool
	DescriptorBufferCaptureReplay      bool
	DescriptorBufferImageLayoutIgnored bool
	DescriptorBufferPushDescriptors    bool
}

type _vkPhysicalDeviceDescriptorBufferFeaturesEXT struct {
	sType                              StructureType
	pNext                              unsafe.Pointer
	descriptorBuffer                   Bool32
	descriptorBufferCaptureReplay      Bool32
	descriptorBufferImageLayoutIgnored Bool32
	descriptorBufferPushDescriptors    Bool32
}

func (s *_vkPhysicalDeviceDescriptorBufferFeaturesEXT) Goify() *PhysicalDeviceDescriptorBufferFeaturesEXT {
	rval := &PhysicalDeviceDescriptorBufferFeaturesEXT{
		PNext:                              (unsafe.Pointer)(s.pNext),
		DescriptorBuffer:                   translatePublic_Bool32(s.descriptorBuffer),                   /*default*/
		DescriptorBufferCaptureReplay:      translatePublic_Bool32(s.descriptorBufferCaptureReplay),      /*default*/
		DescriptorBufferImageLayoutIgnored: translatePublic_Bool32(s.descriptorBufferImageLayoutIgnored), /*default*/
		DescriptorBufferPushDescriptors:    translatePublic_Bool32(s.descriptorBufferPushDescriptors),    /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDescriptorBufferFeaturesEXT) Vulkanize() *_vkPhysicalDeviceDescriptorBufferFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDescriptorBufferFeaturesEXT{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT,  /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                      /*cb*/
		descriptorBuffer:                   translateInternal_Bool32(s.DescriptorBuffer),                   /*default*/
		descriptorBufferCaptureReplay:      translateInternal_Bool32(s.DescriptorBufferCaptureReplay),      /*default*/
		descriptorBufferImageLayoutIgnored: translateInternal_Bool32(s.DescriptorBufferImageLayoutIgnored), /*default*/
		descriptorBufferPushDescriptors:    translateInternal_Bool32(s.DescriptorBufferPushDescriptors),    /*default*/
	}
	return rval
}

// PhysicalDeviceDescriptorBufferPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorBufferPropertiesEXT.html
type PhysicalDeviceDescriptorBufferPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT
	PNext                                                unsafe.Pointer
	CombinedImageSamplerDescriptorSingleArray            bool
	BufferlessPushDescriptors                            bool
	AllowSamplerImageViewPostSubmitCreation              bool
	DescriptorBufferOffsetAlignment                      DeviceSize
	MaxDescriptorBufferBindings                          uint32
	MaxResourceDescriptorBufferBindings                  uint32
	MaxSamplerDescriptorBufferBindings                   uint32
	MaxEmbeddedImmutableSamplerBindings                  uint32
	MaxEmbeddedImmutableSamplers                         uint32
	BufferCaptureReplayDescriptorDataSize                uintptr
	ImageCaptureReplayDescriptorDataSize                 uintptr
	ImageViewCaptureReplayDescriptorDataSize             uintptr
	SamplerCaptureReplayDescriptorDataSize               uintptr
	AccelerationStructureCaptureReplayDescriptorDataSize uintptr
	SamplerDescriptorSize                                uintptr
	CombinedImageSamplerDescriptorSize                   uintptr
	SampledImageDescriptorSize                           uintptr
	StorageImageDescriptorSize                           uintptr
	UniformTexelBufferDescriptorSize                     uintptr
	RobustUniformTexelBufferDescriptorSize               uintptr
	StorageTexelBufferDescriptorSize                     uintptr
	RobustStorageTexelBufferDescriptorSize               uintptr
	UniformBufferDescriptorSize                          uintptr
	RobustUniformBufferDescriptorSize                    uintptr
	StorageBufferDescriptorSize                          uintptr
	RobustStorageBufferDescriptorSize                    uintptr
	InputAttachmentDescriptorSize                        uintptr
	AccelerationStructureDescriptorSize                  uintptr
	MaxSamplerDescriptorBufferRange                      DeviceSize
	MaxResourceDescriptorBufferRange                     DeviceSize
	SamplerDescriptorBufferAddressSpaceSize              DeviceSize
	ResourceDescriptorBufferAddressSpaceSize             DeviceSize
	DescriptorBufferAddressSpaceSize                     DeviceSize
}

// WARNING - struct PhysicalDeviceDescriptorBufferPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceDescriptorBufferPropertiesEXT struct {
	sType                                                StructureType
	pNext                                                unsafe.Pointer
	combinedImageSamplerDescriptorSingleArray            Bool32
	bufferlessPushDescriptors                            Bool32
	allowSamplerImageViewPostSubmitCreation              Bool32
	descriptorBufferOffsetAlignment                      DeviceSize
	maxDescriptorBufferBindings                          uint32
	maxResourceDescriptorBufferBindings                  uint32
	maxSamplerDescriptorBufferBindings                   uint32
	maxEmbeddedImmutableSamplerBindings                  uint32
	maxEmbeddedImmutableSamplers                         uint32
	bufferCaptureReplayDescriptorDataSize                uintptr
	imageCaptureReplayDescriptorDataSize                 uintptr
	imageViewCaptureReplayDescriptorDataSize             uintptr
	samplerCaptureReplayDescriptorDataSize               uintptr
	accelerationStructureCaptureReplayDescriptorDataSize uintptr
	samplerDescriptorSize                                uintptr
	combinedImageSamplerDescriptorSize                   uintptr
	sampledImageDescriptorSize                           uintptr
	storageImageDescriptorSize                           uintptr
	uniformTexelBufferDescriptorSize                     uintptr
	robustUniformTexelBufferDescriptorSize               uintptr
	storageTexelBufferDescriptorSize                     uintptr
	robustStorageTexelBufferDescriptorSize               uintptr
	uniformBufferDescriptorSize                          uintptr
	robustUniformBufferDescriptorSize                    uintptr
	storageBufferDescriptorSize                          uintptr
	robustStorageBufferDescriptorSize                    uintptr
	inputAttachmentDescriptorSize                        uintptr
	accelerationStructureDescriptorSize                  uintptr
	maxSamplerDescriptorBufferRange                      DeviceSize
	maxResourceDescriptorBufferRange                     DeviceSize
	samplerDescriptorBufferAddressSpaceSize              DeviceSize
	resourceDescriptorBufferAddressSpaceSize             DeviceSize
	descriptorBufferAddressSpaceSize                     DeviceSize
}

func (s *_vkPhysicalDeviceDescriptorBufferPropertiesEXT) Goify() *PhysicalDeviceDescriptorBufferPropertiesEXT {
	rval := &PhysicalDeviceDescriptorBufferPropertiesEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		CombinedImageSamplerDescriptorSingleArray:            translatePublic_Bool32(s.combinedImageSamplerDescriptorSingleArray), /*default*/
		BufferlessPushDescriptors:                            translatePublic_Bool32(s.bufferlessPushDescriptors),                 /*default*/
		AllowSamplerImageViewPostSubmitCreation:              translatePublic_Bool32(s.allowSamplerImageViewPostSubmitCreation),   /*default*/
		DescriptorBufferOffsetAlignment:                      (DeviceSize)(s.descriptorBufferOffsetAlignment),
		MaxDescriptorBufferBindings:                          (uint32)(s.maxDescriptorBufferBindings),
		MaxResourceDescriptorBufferBindings:                  (uint32)(s.maxResourceDescriptorBufferBindings),
		MaxSamplerDescriptorBufferBindings:                   (uint32)(s.maxSamplerDescriptorBufferBindings),
		MaxEmbeddedImmutableSamplerBindings:                  (uint32)(s.maxEmbeddedImmutableSamplerBindings),
		MaxEmbeddedImmutableSamplers:                         (uint32)(s.maxEmbeddedImmutableSamplers),
		BufferCaptureReplayDescriptorDataSize:                (uintptr)(s.bufferCaptureReplayDescriptorDataSize),
		ImageCaptureReplayDescriptorDataSize:                 (uintptr)(s.imageCaptureReplayDescriptorDataSize),
		ImageViewCaptureReplayDescriptorDataSize:             (uintptr)(s.imageViewCaptureReplayDescriptorDataSize),
		SamplerCaptureReplayDescriptorDataSize:               (uintptr)(s.samplerCaptureReplayDescriptorDataSize),
		AccelerationStructureCaptureReplayDescriptorDataSize: (uintptr)(s.accelerationStructureCaptureReplayDescriptorDataSize),
		SamplerDescriptorSize:                                (uintptr)(s.samplerDescriptorSize),
		CombinedImageSamplerDescriptorSize:                   (uintptr)(s.combinedImageSamplerDescriptorSize),
		SampledImageDescriptorSize:                           (uintptr)(s.sampledImageDescriptorSize),
		StorageImageDescriptorSize:                           (uintptr)(s.storageImageDescriptorSize),
		UniformTexelBufferDescriptorSize:                     (uintptr)(s.uniformTexelBufferDescriptorSize),
		RobustUniformTexelBufferDescriptorSize:               (uintptr)(s.robustUniformTexelBufferDescriptorSize),
		StorageTexelBufferDescriptorSize:                     (uintptr)(s.storageTexelBufferDescriptorSize),
		RobustStorageTexelBufferDescriptorSize:               (uintptr)(s.robustStorageTexelBufferDescriptorSize),
		UniformBufferDescriptorSize:                          (uintptr)(s.uniformBufferDescriptorSize),
		RobustUniformBufferDescriptorSize:                    (uintptr)(s.robustUniformBufferDescriptorSize),
		StorageBufferDescriptorSize:                          (uintptr)(s.storageBufferDescriptorSize),
		RobustStorageBufferDescriptorSize:                    (uintptr)(s.robustStorageBufferDescriptorSize),
		InputAttachmentDescriptorSize:                        (uintptr)(s.inputAttachmentDescriptorSize),
		AccelerationStructureDescriptorSize:                  (uintptr)(s.accelerationStructureDescriptorSize),
		MaxSamplerDescriptorBufferRange:                      (DeviceSize)(s.maxSamplerDescriptorBufferRange),
		MaxResourceDescriptorBufferRange:                     (DeviceSize)(s.maxResourceDescriptorBufferRange),
		SamplerDescriptorBufferAddressSpaceSize:              (DeviceSize)(s.samplerDescriptorBufferAddressSpaceSize),
		ResourceDescriptorBufferAddressSpaceSize:             (DeviceSize)(s.resourceDescriptorBufferAddressSpaceSize),
		DescriptorBufferAddressSpaceSize:                     (DeviceSize)(s.descriptorBufferAddressSpaceSize),
	}
	return rval
}
func (s *PhysicalDeviceDescriptorBufferPropertiesEXT) Vulkanize() *_vkPhysicalDeviceDescriptorBufferPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDescriptorBufferPropertiesEXT{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                       /*cb*/
		combinedImageSamplerDescriptorSingleArray:            translateInternal_Bool32(s.CombinedImageSamplerDescriptorSingleArray), /*default*/
		bufferlessPushDescriptors:                            translateInternal_Bool32(s.BufferlessPushDescriptors),                 /*default*/
		allowSamplerImageViewPostSubmitCreation:              translateInternal_Bool32(s.AllowSamplerImageViewPostSubmitCreation),   /*default*/
		descriptorBufferOffsetAlignment:                      (DeviceSize)(s.DescriptorBufferOffsetAlignment),                       /*cb*/
		maxDescriptorBufferBindings:                          (uint32)(s.MaxDescriptorBufferBindings),                               /*cb*/
		maxResourceDescriptorBufferBindings:                  (uint32)(s.MaxResourceDescriptorBufferBindings),                       /*cb*/
		maxSamplerDescriptorBufferBindings:                   (uint32)(s.MaxSamplerDescriptorBufferBindings),                        /*cb*/
		maxEmbeddedImmutableSamplerBindings:                  (uint32)(s.MaxEmbeddedImmutableSamplerBindings),                       /*cb*/
		maxEmbeddedImmutableSamplers:                         (uint32)(s.MaxEmbeddedImmutableSamplers),                              /*cb*/
		bufferCaptureReplayDescriptorDataSize:                (uintptr)(s.BufferCaptureReplayDescriptorDataSize),                    /*cb*/
		imageCaptureReplayDescriptorDataSize:                 (uintptr)(s.ImageCaptureReplayDescriptorDataSize),                     /*cb*/
		imageViewCaptureReplayDescriptorDataSize:             (uintptr)(s.ImageViewCaptureReplayDescriptorDataSize),                 /*cb*/
		samplerCaptureReplayDescriptorDataSize:               (uintptr)(s.SamplerCaptureReplayDescriptorDataSize),                   /*cb*/
		accelerationStructureCaptureReplayDescriptorDataSize: (uintptr)(s.AccelerationStructureCaptureReplayDescriptorDataSize),     /*cb*/
		samplerDescriptorSize:                                (uintptr)(s.SamplerDescriptorSize),                                    /*cb*/
		combinedImageSamplerDescriptorSize:                   (uintptr)(s.CombinedImageSamplerDescriptorSize),                       /*cb*/
		sampledImageDescriptorSize:                           (uintptr)(s.SampledImageDescriptorSize),                               /*cb*/
		storageImageDescriptorSize:                           (uintptr)(s.StorageImageDescriptorSize),                               /*cb*/
		uniformTexelBufferDescriptorSize:                     (uintptr)(s.UniformTexelBufferDescriptorSize),                         /*cb*/
		robustUniformTexelBufferDescriptorSize:               (uintptr)(s.RobustUniformTexelBufferDescriptorSize),                   /*cb*/
		storageTexelBufferDescriptorSize:                     (uintptr)(s.StorageTexelBufferDescriptorSize),                         /*cb*/
		robustStorageTexelBufferDescriptorSize:               (uintptr)(s.RobustStorageTexelBufferDescriptorSize),                   /*cb*/
		uniformBufferDescriptorSize:                          (uintptr)(s.UniformBufferDescriptorSize),                              /*cb*/
		robustUniformBufferDescriptorSize:                    (uintptr)(s.RobustUniformBufferDescriptorSize),                        /*cb*/
		storageBufferDescriptorSize:                          (uintptr)(s.StorageBufferDescriptorSize),                              /*cb*/
		robustStorageBufferDescriptorSize:                    (uintptr)(s.RobustStorageBufferDescriptorSize),                        /*cb*/
		inputAttachmentDescriptorSize:                        (uintptr)(s.InputAttachmentDescriptorSize),                            /*cb*/
		accelerationStructureDescriptorSize:                  (uintptr)(s.AccelerationStructureDescriptorSize),                      /*cb*/
		maxSamplerDescriptorBufferRange:                      (DeviceSize)(s.MaxSamplerDescriptorBufferRange),                       /*cb*/
		maxResourceDescriptorBufferRange:                     (DeviceSize)(s.MaxResourceDescriptorBufferRange),                      /*cb*/
		samplerDescriptorBufferAddressSpaceSize:              (DeviceSize)(s.SamplerDescriptorBufferAddressSpaceSize),               /*cb*/
		resourceDescriptorBufferAddressSpaceSize:             (DeviceSize)(s.ResourceDescriptorBufferAddressSpaceSize),              /*cb*/
		descriptorBufferAddressSpaceSize:                     (DeviceSize)(s.DescriptorBufferAddressSpaceSize),                      /*cb*/
	}
	return rval
}

// PhysicalDeviceDescriptorIndexingFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html
type PhysicalDeviceDescriptorIndexingFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES
	PNext                                              unsafe.Pointer
	ShaderInputAttachmentArrayDynamicIndexing          bool
	ShaderUniformTexelBufferArrayDynamicIndexing       bool
	ShaderStorageTexelBufferArrayDynamicIndexing       bool
	ShaderUniformBufferArrayNonUniformIndexing         bool
	ShaderSampledImageArrayNonUniformIndexing          bool
	ShaderStorageBufferArrayNonUniformIndexing         bool
	ShaderStorageImageArrayNonUniformIndexing          bool
	ShaderInputAttachmentArrayNonUniformIndexing       bool
	ShaderUniformTexelBufferArrayNonUniformIndexing    bool
	ShaderStorageTexelBufferArrayNonUniformIndexing    bool
	DescriptorBindingUniformBufferUpdateAfterBind      bool
	DescriptorBindingSampledImageUpdateAfterBind       bool
	DescriptorBindingStorageImageUpdateAfterBind       bool
	DescriptorBindingStorageBufferUpdateAfterBind      bool
	DescriptorBindingUniformTexelBufferUpdateAfterBind bool
	DescriptorBindingStorageTexelBufferUpdateAfterBind bool
	DescriptorBindingUpdateUnusedWhilePending          bool
	DescriptorBindingPartiallyBound                    bool
	DescriptorBindingVariableDescriptorCount           bool
	RuntimeDescriptorArray                             bool
}

type _vkPhysicalDeviceDescriptorIndexingFeatures struct {
	sType                                              StructureType
	pNext                                              unsafe.Pointer
	shaderInputAttachmentArrayDynamicIndexing          Bool32
	shaderUniformTexelBufferArrayDynamicIndexing       Bool32
	shaderStorageTexelBufferArrayDynamicIndexing       Bool32
	shaderUniformBufferArrayNonUniformIndexing         Bool32
	shaderSampledImageArrayNonUniformIndexing          Bool32
	shaderStorageBufferArrayNonUniformIndexing         Bool32
	shaderStorageImageArrayNonUniformIndexing          Bool32
	shaderInputAttachmentArrayNonUniformIndexing       Bool32
	shaderUniformTexelBufferArrayNonUniformIndexing    Bool32
	shaderStorageTexelBufferArrayNonUniformIndexing    Bool32
	descriptorBindingUniformBufferUpdateAfterBind      Bool32
	descriptorBindingSampledImageUpdateAfterBind       Bool32
	descriptorBindingStorageImageUpdateAfterBind       Bool32
	descriptorBindingStorageBufferUpdateAfterBind      Bool32
	descriptorBindingUniformTexelBufferUpdateAfterBind Bool32
	descriptorBindingStorageTexelBufferUpdateAfterBind Bool32
	descriptorBindingUpdateUnusedWhilePending          Bool32
	descriptorBindingPartiallyBound                    Bool32
	descriptorBindingVariableDescriptorCount           Bool32
	runtimeDescriptorArray                             Bool32
}

func (s *_vkPhysicalDeviceDescriptorIndexingFeatures) Goify() *PhysicalDeviceDescriptorIndexingFeatures {
	rval := &PhysicalDeviceDescriptorIndexingFeatures{
		PNext: (unsafe.Pointer)(s.pNext),
		ShaderInputAttachmentArrayDynamicIndexing:          translatePublic_Bool32(s.shaderInputAttachmentArrayDynamicIndexing),          /*default*/
		ShaderUniformTexelBufferArrayDynamicIndexing:       translatePublic_Bool32(s.shaderUniformTexelBufferArrayDynamicIndexing),       /*default*/
		ShaderStorageTexelBufferArrayDynamicIndexing:       translatePublic_Bool32(s.shaderStorageTexelBufferArrayDynamicIndexing),       /*default*/
		ShaderUniformBufferArrayNonUniformIndexing:         translatePublic_Bool32(s.shaderUniformBufferArrayNonUniformIndexing),         /*default*/
		ShaderSampledImageArrayNonUniformIndexing:          translatePublic_Bool32(s.shaderSampledImageArrayNonUniformIndexing),          /*default*/
		ShaderStorageBufferArrayNonUniformIndexing:         translatePublic_Bool32(s.shaderStorageBufferArrayNonUniformIndexing),         /*default*/
		ShaderStorageImageArrayNonUniformIndexing:          translatePublic_Bool32(s.shaderStorageImageArrayNonUniformIndexing),          /*default*/
		ShaderInputAttachmentArrayNonUniformIndexing:       translatePublic_Bool32(s.shaderInputAttachmentArrayNonUniformIndexing),       /*default*/
		ShaderUniformTexelBufferArrayNonUniformIndexing:    translatePublic_Bool32(s.shaderUniformTexelBufferArrayNonUniformIndexing),    /*default*/
		ShaderStorageTexelBufferArrayNonUniformIndexing:    translatePublic_Bool32(s.shaderStorageTexelBufferArrayNonUniformIndexing),    /*default*/
		DescriptorBindingUniformBufferUpdateAfterBind:      translatePublic_Bool32(s.descriptorBindingUniformBufferUpdateAfterBind),      /*default*/
		DescriptorBindingSampledImageUpdateAfterBind:       translatePublic_Bool32(s.descriptorBindingSampledImageUpdateAfterBind),       /*default*/
		DescriptorBindingStorageImageUpdateAfterBind:       translatePublic_Bool32(s.descriptorBindingStorageImageUpdateAfterBind),       /*default*/
		DescriptorBindingStorageBufferUpdateAfterBind:      translatePublic_Bool32(s.descriptorBindingStorageBufferUpdateAfterBind),      /*default*/
		DescriptorBindingUniformTexelBufferUpdateAfterBind: translatePublic_Bool32(s.descriptorBindingUniformTexelBufferUpdateAfterBind), /*default*/
		DescriptorBindingStorageTexelBufferUpdateAfterBind: translatePublic_Bool32(s.descriptorBindingStorageTexelBufferUpdateAfterBind), /*default*/
		DescriptorBindingUpdateUnusedWhilePending:          translatePublic_Bool32(s.descriptorBindingUpdateUnusedWhilePending),          /*default*/
		DescriptorBindingPartiallyBound:                    translatePublic_Bool32(s.descriptorBindingPartiallyBound),                    /*default*/
		DescriptorBindingVariableDescriptorCount:           translatePublic_Bool32(s.descriptorBindingVariableDescriptorCount),           /*default*/
		RuntimeDescriptorArray:                             translatePublic_Bool32(s.runtimeDescriptorArray),                             /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDescriptorIndexingFeatures) Vulkanize() *_vkPhysicalDeviceDescriptorIndexingFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDescriptorIndexingFeatures{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                   /*cb*/
		shaderInputAttachmentArrayDynamicIndexing:          translateInternal_Bool32(s.ShaderInputAttachmentArrayDynamicIndexing),          /*default*/
		shaderUniformTexelBufferArrayDynamicIndexing:       translateInternal_Bool32(s.ShaderUniformTexelBufferArrayDynamicIndexing),       /*default*/
		shaderStorageTexelBufferArrayDynamicIndexing:       translateInternal_Bool32(s.ShaderStorageTexelBufferArrayDynamicIndexing),       /*default*/
		shaderUniformBufferArrayNonUniformIndexing:         translateInternal_Bool32(s.ShaderUniformBufferArrayNonUniformIndexing),         /*default*/
		shaderSampledImageArrayNonUniformIndexing:          translateInternal_Bool32(s.ShaderSampledImageArrayNonUniformIndexing),          /*default*/
		shaderStorageBufferArrayNonUniformIndexing:         translateInternal_Bool32(s.ShaderStorageBufferArrayNonUniformIndexing),         /*default*/
		shaderStorageImageArrayNonUniformIndexing:          translateInternal_Bool32(s.ShaderStorageImageArrayNonUniformIndexing),          /*default*/
		shaderInputAttachmentArrayNonUniformIndexing:       translateInternal_Bool32(s.ShaderInputAttachmentArrayNonUniformIndexing),       /*default*/
		shaderUniformTexelBufferArrayNonUniformIndexing:    translateInternal_Bool32(s.ShaderUniformTexelBufferArrayNonUniformIndexing),    /*default*/
		shaderStorageTexelBufferArrayNonUniformIndexing:    translateInternal_Bool32(s.ShaderStorageTexelBufferArrayNonUniformIndexing),    /*default*/
		descriptorBindingUniformBufferUpdateAfterBind:      translateInternal_Bool32(s.DescriptorBindingUniformBufferUpdateAfterBind),      /*default*/
		descriptorBindingSampledImageUpdateAfterBind:       translateInternal_Bool32(s.DescriptorBindingSampledImageUpdateAfterBind),       /*default*/
		descriptorBindingStorageImageUpdateAfterBind:       translateInternal_Bool32(s.DescriptorBindingStorageImageUpdateAfterBind),       /*default*/
		descriptorBindingStorageBufferUpdateAfterBind:      translateInternal_Bool32(s.DescriptorBindingStorageBufferUpdateAfterBind),      /*default*/
		descriptorBindingUniformTexelBufferUpdateAfterBind: translateInternal_Bool32(s.DescriptorBindingUniformTexelBufferUpdateAfterBind), /*default*/
		descriptorBindingStorageTexelBufferUpdateAfterBind: translateInternal_Bool32(s.DescriptorBindingStorageTexelBufferUpdateAfterBind), /*default*/
		descriptorBindingUpdateUnusedWhilePending:          translateInternal_Bool32(s.DescriptorBindingUpdateUnusedWhilePending),          /*default*/
		descriptorBindingPartiallyBound:                    translateInternal_Bool32(s.DescriptorBindingPartiallyBound),                    /*default*/
		descriptorBindingVariableDescriptorCount:           translateInternal_Bool32(s.DescriptorBindingVariableDescriptorCount),           /*default*/
		runtimeDescriptorArray:                             translateInternal_Bool32(s.RuntimeDescriptorArray),                             /*default*/
	}
	return rval
}

// PhysicalDeviceDescriptorIndexingFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingFeaturesEXT.html
type PhysicalDeviceDescriptorIndexingFeaturesEXT struct {
}

type _vkPhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeaturesEXT

func (s *_vkPhysicalDeviceDescriptorIndexingFeaturesEXT) Goify() *PhysicalDeviceDescriptorIndexingFeaturesEXT {
	rval := (*PhysicalDeviceDescriptorIndexingFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceDescriptorIndexingFeaturesEXT) Vulkanize() *_vkPhysicalDeviceDescriptorIndexingFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceDescriptorIndexingFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceDescriptorIndexingProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html
type PhysicalDeviceDescriptorIndexingProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES
	PNext                                                unsafe.Pointer
	MaxUpdateAfterBindDescriptorsInAllPools              uint32
	ShaderUniformBufferArrayNonUniformIndexingNative     bool
	ShaderSampledImageArrayNonUniformIndexingNative      bool
	ShaderStorageBufferArrayNonUniformIndexingNative     bool
	ShaderStorageImageArrayNonUniformIndexingNative      bool
	ShaderInputAttachmentArrayNonUniformIndexingNative   bool
	RobustBufferAccessUpdateAfterBind                    bool
	QuadDivergentImplicitLod                             bool
	MaxPerStageDescriptorUpdateAfterBindSamplers         uint32
	MaxPerStageDescriptorUpdateAfterBindUniformBuffers   uint32
	MaxPerStageDescriptorUpdateAfterBindStorageBuffers   uint32
	MaxPerStageDescriptorUpdateAfterBindSampledImages    uint32
	MaxPerStageDescriptorUpdateAfterBindStorageImages    uint32
	MaxPerStageDescriptorUpdateAfterBindInputAttachments uint32
	MaxPerStageUpdateAfterBindResources                  uint32
	MaxDescriptorSetUpdateAfterBindSamplers              uint32
	MaxDescriptorSetUpdateAfterBindUniformBuffers        uint32
	MaxDescriptorSetUpdateAfterBindUniformBuffersDynamic uint32
	MaxDescriptorSetUpdateAfterBindStorageBuffers        uint32
	MaxDescriptorSetUpdateAfterBindStorageBuffersDynamic uint32
	MaxDescriptorSetUpdateAfterBindSampledImages         uint32
	MaxDescriptorSetUpdateAfterBindStorageImages         uint32
	MaxDescriptorSetUpdateAfterBindInputAttachments      uint32
}

// WARNING - struct PhysicalDeviceDescriptorIndexingProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceDescriptorIndexingProperties struct {
	sType                                                StructureType
	pNext                                                unsafe.Pointer
	maxUpdateAfterBindDescriptorsInAllPools              uint32
	shaderUniformBufferArrayNonUniformIndexingNative     Bool32
	shaderSampledImageArrayNonUniformIndexingNative      Bool32
	shaderStorageBufferArrayNonUniformIndexingNative     Bool32
	shaderStorageImageArrayNonUniformIndexingNative      Bool32
	shaderInputAttachmentArrayNonUniformIndexingNative   Bool32
	robustBufferAccessUpdateAfterBind                    Bool32
	quadDivergentImplicitLod                             Bool32
	maxPerStageDescriptorUpdateAfterBindSamplers         uint32
	maxPerStageDescriptorUpdateAfterBindUniformBuffers   uint32
	maxPerStageDescriptorUpdateAfterBindStorageBuffers   uint32
	maxPerStageDescriptorUpdateAfterBindSampledImages    uint32
	maxPerStageDescriptorUpdateAfterBindStorageImages    uint32
	maxPerStageDescriptorUpdateAfterBindInputAttachments uint32
	maxPerStageUpdateAfterBindResources                  uint32
	maxDescriptorSetUpdateAfterBindSamplers              uint32
	maxDescriptorSetUpdateAfterBindUniformBuffers        uint32
	maxDescriptorSetUpdateAfterBindUniformBuffersDynamic uint32
	maxDescriptorSetUpdateAfterBindStorageBuffers        uint32
	maxDescriptorSetUpdateAfterBindStorageBuffersDynamic uint32
	maxDescriptorSetUpdateAfterBindSampledImages         uint32
	maxDescriptorSetUpdateAfterBindStorageImages         uint32
	maxDescriptorSetUpdateAfterBindInputAttachments      uint32
}

func (s *_vkPhysicalDeviceDescriptorIndexingProperties) Goify() *PhysicalDeviceDescriptorIndexingProperties {
	rval := &PhysicalDeviceDescriptorIndexingProperties{
		PNext:                                   (unsafe.Pointer)(s.pNext),
		MaxUpdateAfterBindDescriptorsInAllPools: (uint32)(s.maxUpdateAfterBindDescriptorsInAllPools),
		ShaderUniformBufferArrayNonUniformIndexingNative:     translatePublic_Bool32(s.shaderUniformBufferArrayNonUniformIndexingNative),   /*default*/
		ShaderSampledImageArrayNonUniformIndexingNative:      translatePublic_Bool32(s.shaderSampledImageArrayNonUniformIndexingNative),    /*default*/
		ShaderStorageBufferArrayNonUniformIndexingNative:     translatePublic_Bool32(s.shaderStorageBufferArrayNonUniformIndexingNative),   /*default*/
		ShaderStorageImageArrayNonUniformIndexingNative:      translatePublic_Bool32(s.shaderStorageImageArrayNonUniformIndexingNative),    /*default*/
		ShaderInputAttachmentArrayNonUniformIndexingNative:   translatePublic_Bool32(s.shaderInputAttachmentArrayNonUniformIndexingNative), /*default*/
		RobustBufferAccessUpdateAfterBind:                    translatePublic_Bool32(s.robustBufferAccessUpdateAfterBind),                  /*default*/
		QuadDivergentImplicitLod:                             translatePublic_Bool32(s.quadDivergentImplicitLod),                           /*default*/
		MaxPerStageDescriptorUpdateAfterBindSamplers:         (uint32)(s.maxPerStageDescriptorUpdateAfterBindSamplers),
		MaxPerStageDescriptorUpdateAfterBindUniformBuffers:   (uint32)(s.maxPerStageDescriptorUpdateAfterBindUniformBuffers),
		MaxPerStageDescriptorUpdateAfterBindStorageBuffers:   (uint32)(s.maxPerStageDescriptorUpdateAfterBindStorageBuffers),
		MaxPerStageDescriptorUpdateAfterBindSampledImages:    (uint32)(s.maxPerStageDescriptorUpdateAfterBindSampledImages),
		MaxPerStageDescriptorUpdateAfterBindStorageImages:    (uint32)(s.maxPerStageDescriptorUpdateAfterBindStorageImages),
		MaxPerStageDescriptorUpdateAfterBindInputAttachments: (uint32)(s.maxPerStageDescriptorUpdateAfterBindInputAttachments),
		MaxPerStageUpdateAfterBindResources:                  (uint32)(s.maxPerStageUpdateAfterBindResources),
		MaxDescriptorSetUpdateAfterBindSamplers:              (uint32)(s.maxDescriptorSetUpdateAfterBindSamplers),
		MaxDescriptorSetUpdateAfterBindUniformBuffers:        (uint32)(s.maxDescriptorSetUpdateAfterBindUniformBuffers),
		MaxDescriptorSetUpdateAfterBindUniformBuffersDynamic: (uint32)(s.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),
		MaxDescriptorSetUpdateAfterBindStorageBuffers:        (uint32)(s.maxDescriptorSetUpdateAfterBindStorageBuffers),
		MaxDescriptorSetUpdateAfterBindStorageBuffersDynamic: (uint32)(s.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),
		MaxDescriptorSetUpdateAfterBindSampledImages:         (uint32)(s.maxDescriptorSetUpdateAfterBindSampledImages),
		MaxDescriptorSetUpdateAfterBindStorageImages:         (uint32)(s.maxDescriptorSetUpdateAfterBindStorageImages),
		MaxDescriptorSetUpdateAfterBindInputAttachments:      (uint32)(s.maxDescriptorSetUpdateAfterBindInputAttachments),
	}
	return rval
}
func (s *PhysicalDeviceDescriptorIndexingProperties) Vulkanize() *_vkPhysicalDeviceDescriptorIndexingProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDescriptorIndexingProperties{
		sType:                                   STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, /*c1*/
		pNext:                                   (unsafe.Pointer)(s.PNext),                                     /*cb*/
		maxUpdateAfterBindDescriptorsInAllPools: (uint32)(s.MaxUpdateAfterBindDescriptorsInAllPools),           /*cb*/
		shaderUniformBufferArrayNonUniformIndexingNative:     translateInternal_Bool32(s.ShaderUniformBufferArrayNonUniformIndexingNative),   /*default*/
		shaderSampledImageArrayNonUniformIndexingNative:      translateInternal_Bool32(s.ShaderSampledImageArrayNonUniformIndexingNative),    /*default*/
		shaderStorageBufferArrayNonUniformIndexingNative:     translateInternal_Bool32(s.ShaderStorageBufferArrayNonUniformIndexingNative),   /*default*/
		shaderStorageImageArrayNonUniformIndexingNative:      translateInternal_Bool32(s.ShaderStorageImageArrayNonUniformIndexingNative),    /*default*/
		shaderInputAttachmentArrayNonUniformIndexingNative:   translateInternal_Bool32(s.ShaderInputAttachmentArrayNonUniformIndexingNative), /*default*/
		robustBufferAccessUpdateAfterBind:                    translateInternal_Bool32(s.RobustBufferAccessUpdateAfterBind),                  /*default*/
		quadDivergentImplicitLod:                             translateInternal_Bool32(s.QuadDivergentImplicitLod),                           /*default*/
		maxPerStageDescriptorUpdateAfterBindSamplers:         (uint32)(s.MaxPerStageDescriptorUpdateAfterBindSamplers),                       /*cb*/
		maxPerStageDescriptorUpdateAfterBindUniformBuffers:   (uint32)(s.MaxPerStageDescriptorUpdateAfterBindUniformBuffers),                 /*cb*/
		maxPerStageDescriptorUpdateAfterBindStorageBuffers:   (uint32)(s.MaxPerStageDescriptorUpdateAfterBindStorageBuffers),                 /*cb*/
		maxPerStageDescriptorUpdateAfterBindSampledImages:    (uint32)(s.MaxPerStageDescriptorUpdateAfterBindSampledImages),                  /*cb*/
		maxPerStageDescriptorUpdateAfterBindStorageImages:    (uint32)(s.MaxPerStageDescriptorUpdateAfterBindStorageImages),                  /*cb*/
		maxPerStageDescriptorUpdateAfterBindInputAttachments: (uint32)(s.MaxPerStageDescriptorUpdateAfterBindInputAttachments),               /*cb*/
		maxPerStageUpdateAfterBindResources:                  (uint32)(s.MaxPerStageUpdateAfterBindResources),                                /*cb*/
		maxDescriptorSetUpdateAfterBindSamplers:              (uint32)(s.MaxDescriptorSetUpdateAfterBindSamplers),                            /*cb*/
		maxDescriptorSetUpdateAfterBindUniformBuffers:        (uint32)(s.MaxDescriptorSetUpdateAfterBindUniformBuffers),                      /*cb*/
		maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: (uint32)(s.MaxDescriptorSetUpdateAfterBindUniformBuffersDynamic),               /*cb*/
		maxDescriptorSetUpdateAfterBindStorageBuffers:        (uint32)(s.MaxDescriptorSetUpdateAfterBindStorageBuffers),                      /*cb*/
		maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: (uint32)(s.MaxDescriptorSetUpdateAfterBindStorageBuffersDynamic),               /*cb*/
		maxDescriptorSetUpdateAfterBindSampledImages:         (uint32)(s.MaxDescriptorSetUpdateAfterBindSampledImages),                       /*cb*/
		maxDescriptorSetUpdateAfterBindStorageImages:         (uint32)(s.MaxDescriptorSetUpdateAfterBindStorageImages),                       /*cb*/
		maxDescriptorSetUpdateAfterBindInputAttachments:      (uint32)(s.MaxDescriptorSetUpdateAfterBindInputAttachments),                    /*cb*/
	}
	return rval
}

// PhysicalDeviceDescriptorIndexingPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingPropertiesEXT.html
type PhysicalDeviceDescriptorIndexingPropertiesEXT struct {
}

type _vkPhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingPropertiesEXT

func (s *_vkPhysicalDeviceDescriptorIndexingPropertiesEXT) Goify() *PhysicalDeviceDescriptorIndexingPropertiesEXT {
	rval := (*PhysicalDeviceDescriptorIndexingPropertiesEXT)(s)
	return rval
}
func (s *PhysicalDeviceDescriptorIndexingPropertiesEXT) Vulkanize() *_vkPhysicalDeviceDescriptorIndexingPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceDescriptorIndexingPropertiesEXT)(s)
	return rval
}

// PhysicalDeviceDescriptorPoolOverallocationFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.html
type PhysicalDeviceDescriptorPoolOverallocationFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV
	PNext                        unsafe.Pointer
	DescriptorPoolOverallocation bool
}

type _vkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	descriptorPoolOverallocation Bool32
}

func (s *_vkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV) Goify() *PhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
	rval := &PhysicalDeviceDescriptorPoolOverallocationFeaturesNV{
		PNext:                        (unsafe.Pointer)(s.pNext),
		DescriptorPoolOverallocation: translatePublic_Bool32(s.descriptorPoolOverallocation), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDescriptorPoolOverallocationFeaturesNV) Vulkanize() *_vkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                                 /*cb*/
		descriptorPoolOverallocation: translateInternal_Bool32(s.DescriptorPoolOverallocation),                  /*default*/
	}
	return rval
}

// PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.html
type PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE
	PNext                    unsafe.Pointer
	DescriptorSetHostMapping bool
}

type _vkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	descriptorSetHostMapping Bool32
}

func (s *_vkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE) Goify() *PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
	rval := &PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE{
		PNext:                    (unsafe.Pointer)(s.pNext),
		DescriptorSetHostMapping: translatePublic_Bool32(s.descriptorSetHostMapping), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE) Vulkanize() *_vkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE{
		sType:                    STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                                 /*cb*/
		descriptorSetHostMapping: translateInternal_Bool32(s.DescriptorSetHostMapping),                      /*default*/
	}
	return rval
}

// PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.html
type PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV
	PNext                               unsafe.Pointer
	DeviceGeneratedCompute              bool
	DeviceGeneratedComputePipelines     bool
	DeviceGeneratedComputeCaptureReplay bool
}

type _vkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV struct {
	sType                               StructureType
	pNext                               unsafe.Pointer
	deviceGeneratedCompute              Bool32
	deviceGeneratedComputePipelines     Bool32
	deviceGeneratedComputeCaptureReplay Bool32
}

func (s *_vkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV) Goify() *PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
	rval := &PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV{
		PNext:                               (unsafe.Pointer)(s.pNext),
		DeviceGeneratedCompute:              translatePublic_Bool32(s.deviceGeneratedCompute),              /*default*/
		DeviceGeneratedComputePipelines:     translatePublic_Bool32(s.deviceGeneratedComputePipelines),     /*default*/
		DeviceGeneratedComputeCaptureReplay: translatePublic_Bool32(s.deviceGeneratedComputeCaptureReplay), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV) Vulkanize() *_vkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV{
		sType:                               STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, /*c1*/
		pNext:                               (unsafe.Pointer)(s.PNext),                                                    /*cb*/
		deviceGeneratedCompute:              translateInternal_Bool32(s.DeviceGeneratedCompute),                           /*default*/
		deviceGeneratedComputePipelines:     translateInternal_Bool32(s.DeviceGeneratedComputePipelines),                  /*default*/
		deviceGeneratedComputeCaptureReplay: translateInternal_Bool32(s.DeviceGeneratedComputeCaptureReplay),              /*default*/
	}
	return rval
}

// PhysicalDeviceDeviceGeneratedCommandsFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html
type PhysicalDeviceDeviceGeneratedCommandsFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV
	PNext                   unsafe.Pointer
	DeviceGeneratedCommands bool
}

type _vkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	deviceGeneratedCommands Bool32
}

func (s *_vkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV) Goify() *PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
	rval := &PhysicalDeviceDeviceGeneratedCommandsFeaturesNV{
		PNext:                   (unsafe.Pointer)(s.pNext),
		DeviceGeneratedCommands: translatePublic_Bool32(s.deviceGeneratedCommands), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDeviceGeneratedCommandsFeaturesNV) Vulkanize() *_vkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                            /*cb*/
		deviceGeneratedCommands: translateInternal_Bool32(s.DeviceGeneratedCommands),                  /*default*/
	}
	return rval
}

// PhysicalDeviceDeviceGeneratedCommandsPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html
type PhysicalDeviceDeviceGeneratedCommandsPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV
	PNext                                    unsafe.Pointer
	MaxGraphicsShaderGroupCount              uint32
	MaxIndirectSequenceCount                 uint32
	MaxIndirectCommandsTokenCount            uint32
	MaxIndirectCommandsStreamCount           uint32
	MaxIndirectCommandsTokenOffset           uint32
	MaxIndirectCommandsStreamStride          uint32
	MinSequencesCountBufferOffsetAlignment   uint32
	MinSequencesIndexBufferOffsetAlignment   uint32
	MinIndirectCommandsBufferOffsetAlignment uint32
}

// WARNING - struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV struct {
	sType                                    StructureType
	pNext                                    unsafe.Pointer
	maxGraphicsShaderGroupCount              uint32
	maxIndirectSequenceCount                 uint32
	maxIndirectCommandsTokenCount            uint32
	maxIndirectCommandsStreamCount           uint32
	maxIndirectCommandsTokenOffset           uint32
	maxIndirectCommandsStreamStride          uint32
	minSequencesCountBufferOffsetAlignment   uint32
	minSequencesIndexBufferOffsetAlignment   uint32
	minIndirectCommandsBufferOffsetAlignment uint32
}

func (s *_vkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV) Goify() *PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
	rval := &PhysicalDeviceDeviceGeneratedCommandsPropertiesNV{
		PNext:                                    (unsafe.Pointer)(s.pNext),
		MaxGraphicsShaderGroupCount:              (uint32)(s.maxGraphicsShaderGroupCount),
		MaxIndirectSequenceCount:                 (uint32)(s.maxIndirectSequenceCount),
		MaxIndirectCommandsTokenCount:            (uint32)(s.maxIndirectCommandsTokenCount),
		MaxIndirectCommandsStreamCount:           (uint32)(s.maxIndirectCommandsStreamCount),
		MaxIndirectCommandsTokenOffset:           (uint32)(s.maxIndirectCommandsTokenOffset),
		MaxIndirectCommandsStreamStride:          (uint32)(s.maxIndirectCommandsStreamStride),
		MinSequencesCountBufferOffsetAlignment:   (uint32)(s.minSequencesCountBufferOffsetAlignment),
		MinSequencesIndexBufferOffsetAlignment:   (uint32)(s.minSequencesIndexBufferOffsetAlignment),
		MinIndirectCommandsBufferOffsetAlignment: (uint32)(s.minIndirectCommandsBufferOffsetAlignment),
	}
	return rval
}
func (s *PhysicalDeviceDeviceGeneratedCommandsPropertiesNV) Vulkanize() *_vkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV{
		sType:                                    STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV, /*c1*/
		pNext:                                    (unsafe.Pointer)(s.PNext),                                              /*cb*/
		maxGraphicsShaderGroupCount:              (uint32)(s.MaxGraphicsShaderGroupCount),                                /*cb*/
		maxIndirectSequenceCount:                 (uint32)(s.MaxIndirectSequenceCount),                                   /*cb*/
		maxIndirectCommandsTokenCount:            (uint32)(s.MaxIndirectCommandsTokenCount),                              /*cb*/
		maxIndirectCommandsStreamCount:           (uint32)(s.MaxIndirectCommandsStreamCount),                             /*cb*/
		maxIndirectCommandsTokenOffset:           (uint32)(s.MaxIndirectCommandsTokenOffset),                             /*cb*/
		maxIndirectCommandsStreamStride:          (uint32)(s.MaxIndirectCommandsStreamStride),                            /*cb*/
		minSequencesCountBufferOffsetAlignment:   (uint32)(s.MinSequencesCountBufferOffsetAlignment),                     /*cb*/
		minSequencesIndexBufferOffsetAlignment:   (uint32)(s.MinSequencesIndexBufferOffsetAlignment),                     /*cb*/
		minIndirectCommandsBufferOffsetAlignment: (uint32)(s.MinIndirectCommandsBufferOffsetAlignment),                   /*cb*/
	}
	return rval
}

// PhysicalDeviceDeviceMemoryReportFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html
type PhysicalDeviceDeviceMemoryReportFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT
	PNext              unsafe.Pointer
	DeviceMemoryReport bool
}

type _vkPhysicalDeviceDeviceMemoryReportFeaturesEXT struct {
	sType              StructureType
	pNext              unsafe.Pointer
	deviceMemoryReport Bool32
}

func (s *_vkPhysicalDeviceDeviceMemoryReportFeaturesEXT) Goify() *PhysicalDeviceDeviceMemoryReportFeaturesEXT {
	rval := &PhysicalDeviceDeviceMemoryReportFeaturesEXT{
		PNext:              (unsafe.Pointer)(s.pNext),
		DeviceMemoryReport: translatePublic_Bool32(s.deviceMemoryReport), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDeviceMemoryReportFeaturesEXT) Vulkanize() *_vkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDeviceMemoryReportFeaturesEXT{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                        /*cb*/
		deviceMemoryReport: translateInternal_Bool32(s.DeviceMemoryReport),                   /*default*/
	}
	return rval
}

// PhysicalDeviceDiagnosticsConfigFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html
type PhysicalDeviceDiagnosticsConfigFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV
	PNext             unsafe.Pointer
	DiagnosticsConfig bool
}

type _vkPhysicalDeviceDiagnosticsConfigFeaturesNV struct {
	sType             StructureType
	pNext             unsafe.Pointer
	diagnosticsConfig Bool32
}

func (s *_vkPhysicalDeviceDiagnosticsConfigFeaturesNV) Goify() *PhysicalDeviceDiagnosticsConfigFeaturesNV {
	rval := &PhysicalDeviceDiagnosticsConfigFeaturesNV{
		PNext:             (unsafe.Pointer)(s.pNext),
		DiagnosticsConfig: translatePublic_Bool32(s.diagnosticsConfig), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDiagnosticsConfigFeaturesNV) Vulkanize() *_vkPhysicalDeviceDiagnosticsConfigFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDiagnosticsConfigFeaturesNV{
		sType:             STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                     /*cb*/
		diagnosticsConfig: translateInternal_Bool32(s.DiagnosticsConfig),                 /*default*/
	}
	return rval
}

// PhysicalDeviceDiscardRectanglePropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html
type PhysicalDeviceDiscardRectanglePropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT
	PNext unsafe.Pointer
	//  max number of active discard rectangles;
	MaxDiscardRectangles uint32
}

// WARNING - struct PhysicalDeviceDiscardRectanglePropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceDiscardRectanglePropertiesEXT struct {
	sType                StructureType
	pNext                unsafe.Pointer
	maxDiscardRectangles uint32
}

func (s *_vkPhysicalDeviceDiscardRectanglePropertiesEXT) Goify() *PhysicalDeviceDiscardRectanglePropertiesEXT {
	rval := &PhysicalDeviceDiscardRectanglePropertiesEXT{
		PNext:                (unsafe.Pointer)(s.pNext),
		MaxDiscardRectangles: (uint32)(s.maxDiscardRectangles),
	}
	return rval
}
func (s *PhysicalDeviceDiscardRectanglePropertiesEXT) Vulkanize() *_vkPhysicalDeviceDiscardRectanglePropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDiscardRectanglePropertiesEXT{
		sType:                STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                       /*cb*/
		maxDiscardRectangles: (uint32)(s.MaxDiscardRectangles),                                /*cb*/
	}
	return rval
}

// PhysicalDeviceDriverProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDriverProperties.html
type PhysicalDeviceDriverProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES
	PNext              unsafe.Pointer
	DriverID           DriverId
	DriverName         string
	DriverInfo         string
	ConformanceVersion ConformanceVersion
}

// WARNING - struct PhysicalDeviceDriverProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceDriverProperties struct {
	sType              StructureType
	pNext              unsafe.Pointer
	driverID           DriverId
	driverName         [MAX_DRIVER_NAME_SIZE]byte
	driverInfo         [MAX_DRIVER_INFO_SIZE]byte
	conformanceVersion _vkConformanceVersion
}

func (s *_vkPhysicalDeviceDriverProperties) Goify() *PhysicalDeviceDriverProperties {
	rval := &PhysicalDeviceDriverProperties{
		PNext:              (unsafe.Pointer)(s.pNext),
		DriverID:           (DriverId)(s.driverID),
		DriverName:         nullTermBytesToString(s.driverName[:]), /*c arr*/
		DriverInfo:         nullTermBytesToString(s.driverInfo[:]), /*c arr*/
		ConformanceVersion: (ConformanceVersion)(s.conformanceVersion),
	}
	return rval
}
func (s *PhysicalDeviceDriverProperties) Vulkanize() *_vkPhysicalDeviceDriverProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDriverProperties{
		sType:    STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                        /*cb*/
		driverID: (DriverId)(s.DriverID),                           /*cb*/
		// driverName : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		// driverInfo : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		conformanceVersion: (_vkConformanceVersion)(s.ConformanceVersion), /*cb*/
	}
	return rval
}

// PhysicalDeviceDriverPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDriverPropertiesKHR.html
type PhysicalDeviceDriverPropertiesKHR struct {
}

type _vkPhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverPropertiesKHR

func (s *_vkPhysicalDeviceDriverPropertiesKHR) Goify() *PhysicalDeviceDriverPropertiesKHR {
	rval := (*PhysicalDeviceDriverPropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceDriverPropertiesKHR) Vulkanize() *_vkPhysicalDeviceDriverPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceDriverPropertiesKHR)(s)
	return rval
}

// PhysicalDeviceDrmPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html
type PhysicalDeviceDrmPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT
	PNext        unsafe.Pointer
	HasPrimary   bool
	HasRender    bool
	PrimaryMajor int64
	PrimaryMinor int64
	RenderMajor  int64
	RenderMinor  int64
}

// WARNING - struct PhysicalDeviceDrmPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceDrmPropertiesEXT struct {
	sType        StructureType
	pNext        unsafe.Pointer
	hasPrimary   Bool32
	hasRender    Bool32
	primaryMajor int64
	primaryMinor int64
	renderMajor  int64
	renderMinor  int64
}

func (s *_vkPhysicalDeviceDrmPropertiesEXT) Goify() *PhysicalDeviceDrmPropertiesEXT {
	rval := &PhysicalDeviceDrmPropertiesEXT{
		PNext:        (unsafe.Pointer)(s.pNext),
		HasPrimary:   translatePublic_Bool32(s.hasPrimary), /*default*/
		HasRender:    translatePublic_Bool32(s.hasRender),  /*default*/
		PrimaryMajor: (int64)(s.primaryMajor),
		PrimaryMinor: (int64)(s.primaryMinor),
		RenderMajor:  (int64)(s.renderMajor),
		RenderMinor:  (int64)(s.renderMinor),
	}
	return rval
}
func (s *PhysicalDeviceDrmPropertiesEXT) Vulkanize() *_vkPhysicalDeviceDrmPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDrmPropertiesEXT{
		sType:        STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                         /*cb*/
		hasPrimary:   translateInternal_Bool32(s.HasPrimary),            /*default*/
		hasRender:    translateInternal_Bool32(s.HasRender),             /*default*/
		primaryMajor: (int64)(s.PrimaryMajor),                           /*cb*/
		primaryMinor: (int64)(s.PrimaryMinor),                           /*cb*/
		renderMajor:  (int64)(s.RenderMajor),                            /*cb*/
		renderMinor:  (int64)(s.RenderMinor),                            /*cb*/
	}
	return rval
}

// PhysicalDeviceDynamicRenderingFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDynamicRenderingFeaturesKHR.html
type PhysicalDeviceDynamicRenderingFeaturesKHR struct {
}

type _vkPhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeaturesKHR

func (s *_vkPhysicalDeviceDynamicRenderingFeaturesKHR) Goify() *PhysicalDeviceDynamicRenderingFeaturesKHR {
	rval := (*PhysicalDeviceDynamicRenderingFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceDynamicRenderingFeaturesKHR) Vulkanize() *_vkPhysicalDeviceDynamicRenderingFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceDynamicRenderingFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.html
type PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT
	PNext                             unsafe.Pointer
	DynamicRenderingUnusedAttachments bool
}

type _vkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT struct {
	sType                             StructureType
	pNext                             unsafe.Pointer
	dynamicRenderingUnusedAttachments Bool32
}

func (s *_vkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT) Goify() *PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
	rval := &PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT{
		PNext:                             (unsafe.Pointer)(s.pNext),
		DynamicRenderingUnusedAttachments: translatePublic_Bool32(s.dynamicRenderingUnusedAttachments), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT) Vulkanize() *_vkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT{
		sType:                             STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, /*c1*/
		pNext:                             (unsafe.Pointer)(s.PNext),                                                        /*cb*/
		dynamicRenderingUnusedAttachments: translateInternal_Bool32(s.DynamicRenderingUnusedAttachments),                    /*default*/
	}
	return rval
}

// PhysicalDeviceExclusiveScissorFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html
type PhysicalDeviceExclusiveScissorFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV
	PNext            unsafe.Pointer
	ExclusiveScissor bool
}

type _vkPhysicalDeviceExclusiveScissorFeaturesNV struct {
	sType            StructureType
	pNext            unsafe.Pointer
	exclusiveScissor Bool32
}

func (s *_vkPhysicalDeviceExclusiveScissorFeaturesNV) Goify() *PhysicalDeviceExclusiveScissorFeaturesNV {
	rval := &PhysicalDeviceExclusiveScissorFeaturesNV{
		PNext:            (unsafe.Pointer)(s.pNext),
		ExclusiveScissor: translatePublic_Bool32(s.exclusiveScissor), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceExclusiveScissorFeaturesNV) Vulkanize() *_vkPhysicalDeviceExclusiveScissorFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExclusiveScissorFeaturesNV{
		sType:            STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                    /*cb*/
		exclusiveScissor: translateInternal_Bool32(s.ExclusiveScissor),                 /*default*/
	}
	return rval
}

// PhysicalDeviceExtendedDynamicState2FeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html
type PhysicalDeviceExtendedDynamicState2FeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT
	PNext                                   unsafe.Pointer
	ExtendedDynamicState2                   bool
	ExtendedDynamicState2LogicOp            bool
	ExtendedDynamicState2PatchControlPoints bool
}

type _vkPhysicalDeviceExtendedDynamicState2FeaturesEXT struct {
	sType                                   StructureType
	pNext                                   unsafe.Pointer
	extendedDynamicState2                   Bool32
	extendedDynamicState2LogicOp            Bool32
	extendedDynamicState2PatchControlPoints Bool32
}

func (s *_vkPhysicalDeviceExtendedDynamicState2FeaturesEXT) Goify() *PhysicalDeviceExtendedDynamicState2FeaturesEXT {
	rval := &PhysicalDeviceExtendedDynamicState2FeaturesEXT{
		PNext:                                   (unsafe.Pointer)(s.pNext),
		ExtendedDynamicState2:                   translatePublic_Bool32(s.extendedDynamicState2),                   /*default*/
		ExtendedDynamicState2LogicOp:            translatePublic_Bool32(s.extendedDynamicState2LogicOp),            /*default*/
		ExtendedDynamicState2PatchControlPoints: translatePublic_Bool32(s.extendedDynamicState2PatchControlPoints), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceExtendedDynamicState2FeaturesEXT) Vulkanize() *_vkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExtendedDynamicState2FeaturesEXT{
		sType:                                   STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, /*c1*/
		pNext:                                   (unsafe.Pointer)(s.PNext),                                            /*cb*/
		extendedDynamicState2:                   translateInternal_Bool32(s.ExtendedDynamicState2),                    /*default*/
		extendedDynamicState2LogicOp:            translateInternal_Bool32(s.ExtendedDynamicState2LogicOp),             /*default*/
		extendedDynamicState2PatchControlPoints: translateInternal_Bool32(s.ExtendedDynamicState2PatchControlPoints),  /*default*/
	}
	return rval
}

// PhysicalDeviceExtendedDynamicState3FeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.html
type PhysicalDeviceExtendedDynamicState3FeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT
	PNext                                                 unsafe.Pointer
	ExtendedDynamicState3TessellationDomainOrigin         bool
	ExtendedDynamicState3DepthClampEnable                 bool
	ExtendedDynamicState3PolygonMode                      bool
	ExtendedDynamicState3RasterizationSamples             bool
	ExtendedDynamicState3SampleMask                       bool
	ExtendedDynamicState3AlphaToCoverageEnable            bool
	ExtendedDynamicState3AlphaToOneEnable                 bool
	ExtendedDynamicState3LogicOpEnable                    bool
	ExtendedDynamicState3ColorBlendEnable                 bool
	ExtendedDynamicState3ColorBlendEquation               bool
	ExtendedDynamicState3ColorWriteMask                   bool
	ExtendedDynamicState3RasterizationStream              bool
	ExtendedDynamicState3ConservativeRasterizationMode    bool
	ExtendedDynamicState3ExtraPrimitiveOverestimationSize bool
	ExtendedDynamicState3DepthClipEnable                  bool
	ExtendedDynamicState3SampleLocationsEnable            bool
	ExtendedDynamicState3ColorBlendAdvanced               bool
	ExtendedDynamicState3ProvokingVertexMode              bool
	ExtendedDynamicState3LineRasterizationMode            bool
	ExtendedDynamicState3LineStippleEnable                bool
	ExtendedDynamicState3DepthClipNegativeOneToOne        bool
	ExtendedDynamicState3ViewportWScalingEnable           bool
	ExtendedDynamicState3ViewportSwizzle                  bool
	ExtendedDynamicState3CoverageToColorEnable            bool
	ExtendedDynamicState3CoverageToColorLocation          bool
	ExtendedDynamicState3CoverageModulationMode           bool
	ExtendedDynamicState3CoverageModulationTableEnable    bool
	ExtendedDynamicState3CoverageModulationTable          bool
	ExtendedDynamicState3CoverageReductionMode            bool
	ExtendedDynamicState3RepresentativeFragmentTestEnable bool
	ExtendedDynamicState3ShadingRateImageEnable           bool
}

type _vkPhysicalDeviceExtendedDynamicState3FeaturesEXT struct {
	sType                                                 StructureType
	pNext                                                 unsafe.Pointer
	extendedDynamicState3TessellationDomainOrigin         Bool32
	extendedDynamicState3DepthClampEnable                 Bool32
	extendedDynamicState3PolygonMode                      Bool32
	extendedDynamicState3RasterizationSamples             Bool32
	extendedDynamicState3SampleMask                       Bool32
	extendedDynamicState3AlphaToCoverageEnable            Bool32
	extendedDynamicState3AlphaToOneEnable                 Bool32
	extendedDynamicState3LogicOpEnable                    Bool32
	extendedDynamicState3ColorBlendEnable                 Bool32
	extendedDynamicState3ColorBlendEquation               Bool32
	extendedDynamicState3ColorWriteMask                   Bool32
	extendedDynamicState3RasterizationStream              Bool32
	extendedDynamicState3ConservativeRasterizationMode    Bool32
	extendedDynamicState3ExtraPrimitiveOverestimationSize Bool32
	extendedDynamicState3DepthClipEnable                  Bool32
	extendedDynamicState3SampleLocationsEnable            Bool32
	extendedDynamicState3ColorBlendAdvanced               Bool32
	extendedDynamicState3ProvokingVertexMode              Bool32
	extendedDynamicState3LineRasterizationMode            Bool32
	extendedDynamicState3LineStippleEnable                Bool32
	extendedDynamicState3DepthClipNegativeOneToOne        Bool32
	extendedDynamicState3ViewportWScalingEnable           Bool32
	extendedDynamicState3ViewportSwizzle                  Bool32
	extendedDynamicState3CoverageToColorEnable            Bool32
	extendedDynamicState3CoverageToColorLocation          Bool32
	extendedDynamicState3CoverageModulationMode           Bool32
	extendedDynamicState3CoverageModulationTableEnable    Bool32
	extendedDynamicState3CoverageModulationTable          Bool32
	extendedDynamicState3CoverageReductionMode            Bool32
	extendedDynamicState3RepresentativeFragmentTestEnable Bool32
	extendedDynamicState3ShadingRateImageEnable           Bool32
}

func (s *_vkPhysicalDeviceExtendedDynamicState3FeaturesEXT) Goify() *PhysicalDeviceExtendedDynamicState3FeaturesEXT {
	rval := &PhysicalDeviceExtendedDynamicState3FeaturesEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		ExtendedDynamicState3TessellationDomainOrigin:         translatePublic_Bool32(s.extendedDynamicState3TessellationDomainOrigin),         /*default*/
		ExtendedDynamicState3DepthClampEnable:                 translatePublic_Bool32(s.extendedDynamicState3DepthClampEnable),                 /*default*/
		ExtendedDynamicState3PolygonMode:                      translatePublic_Bool32(s.extendedDynamicState3PolygonMode),                      /*default*/
		ExtendedDynamicState3RasterizationSamples:             translatePublic_Bool32(s.extendedDynamicState3RasterizationSamples),             /*default*/
		ExtendedDynamicState3SampleMask:                       translatePublic_Bool32(s.extendedDynamicState3SampleMask),                       /*default*/
		ExtendedDynamicState3AlphaToCoverageEnable:            translatePublic_Bool32(s.extendedDynamicState3AlphaToCoverageEnable),            /*default*/
		ExtendedDynamicState3AlphaToOneEnable:                 translatePublic_Bool32(s.extendedDynamicState3AlphaToOneEnable),                 /*default*/
		ExtendedDynamicState3LogicOpEnable:                    translatePublic_Bool32(s.extendedDynamicState3LogicOpEnable),                    /*default*/
		ExtendedDynamicState3ColorBlendEnable:                 translatePublic_Bool32(s.extendedDynamicState3ColorBlendEnable),                 /*default*/
		ExtendedDynamicState3ColorBlendEquation:               translatePublic_Bool32(s.extendedDynamicState3ColorBlendEquation),               /*default*/
		ExtendedDynamicState3ColorWriteMask:                   translatePublic_Bool32(s.extendedDynamicState3ColorWriteMask),                   /*default*/
		ExtendedDynamicState3RasterizationStream:              translatePublic_Bool32(s.extendedDynamicState3RasterizationStream),              /*default*/
		ExtendedDynamicState3ConservativeRasterizationMode:    translatePublic_Bool32(s.extendedDynamicState3ConservativeRasterizationMode),    /*default*/
		ExtendedDynamicState3ExtraPrimitiveOverestimationSize: translatePublic_Bool32(s.extendedDynamicState3ExtraPrimitiveOverestimationSize), /*default*/
		ExtendedDynamicState3DepthClipEnable:                  translatePublic_Bool32(s.extendedDynamicState3DepthClipEnable),                  /*default*/
		ExtendedDynamicState3SampleLocationsEnable:            translatePublic_Bool32(s.extendedDynamicState3SampleLocationsEnable),            /*default*/
		ExtendedDynamicState3ColorBlendAdvanced:               translatePublic_Bool32(s.extendedDynamicState3ColorBlendAdvanced),               /*default*/
		ExtendedDynamicState3ProvokingVertexMode:              translatePublic_Bool32(s.extendedDynamicState3ProvokingVertexMode),              /*default*/
		ExtendedDynamicState3LineRasterizationMode:            translatePublic_Bool32(s.extendedDynamicState3LineRasterizationMode),            /*default*/
		ExtendedDynamicState3LineStippleEnable:                translatePublic_Bool32(s.extendedDynamicState3LineStippleEnable),                /*default*/
		ExtendedDynamicState3DepthClipNegativeOneToOne:        translatePublic_Bool32(s.extendedDynamicState3DepthClipNegativeOneToOne),        /*default*/
		ExtendedDynamicState3ViewportWScalingEnable:           translatePublic_Bool32(s.extendedDynamicState3ViewportWScalingEnable),           /*default*/
		ExtendedDynamicState3ViewportSwizzle:                  translatePublic_Bool32(s.extendedDynamicState3ViewportSwizzle),                  /*default*/
		ExtendedDynamicState3CoverageToColorEnable:            translatePublic_Bool32(s.extendedDynamicState3CoverageToColorEnable),            /*default*/
		ExtendedDynamicState3CoverageToColorLocation:          translatePublic_Bool32(s.extendedDynamicState3CoverageToColorLocation),          /*default*/
		ExtendedDynamicState3CoverageModulationMode:           translatePublic_Bool32(s.extendedDynamicState3CoverageModulationMode),           /*default*/
		ExtendedDynamicState3CoverageModulationTableEnable:    translatePublic_Bool32(s.extendedDynamicState3CoverageModulationTableEnable),    /*default*/
		ExtendedDynamicState3CoverageModulationTable:          translatePublic_Bool32(s.extendedDynamicState3CoverageModulationTable),          /*default*/
		ExtendedDynamicState3CoverageReductionMode:            translatePublic_Bool32(s.extendedDynamicState3CoverageReductionMode),            /*default*/
		ExtendedDynamicState3RepresentativeFragmentTestEnable: translatePublic_Bool32(s.extendedDynamicState3RepresentativeFragmentTestEnable), /*default*/
		ExtendedDynamicState3ShadingRateImageEnable:           translatePublic_Bool32(s.extendedDynamicState3ShadingRateImageEnable),           /*default*/
	}
	return rval
}
func (s *PhysicalDeviceExtendedDynamicState3FeaturesEXT) Vulkanize() *_vkPhysicalDeviceExtendedDynamicState3FeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExtendedDynamicState3FeaturesEXT{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                            /*cb*/
		extendedDynamicState3TessellationDomainOrigin:         translateInternal_Bool32(s.ExtendedDynamicState3TessellationDomainOrigin),         /*default*/
		extendedDynamicState3DepthClampEnable:                 translateInternal_Bool32(s.ExtendedDynamicState3DepthClampEnable),                 /*default*/
		extendedDynamicState3PolygonMode:                      translateInternal_Bool32(s.ExtendedDynamicState3PolygonMode),                      /*default*/
		extendedDynamicState3RasterizationSamples:             translateInternal_Bool32(s.ExtendedDynamicState3RasterizationSamples),             /*default*/
		extendedDynamicState3SampleMask:                       translateInternal_Bool32(s.ExtendedDynamicState3SampleMask),                       /*default*/
		extendedDynamicState3AlphaToCoverageEnable:            translateInternal_Bool32(s.ExtendedDynamicState3AlphaToCoverageEnable),            /*default*/
		extendedDynamicState3AlphaToOneEnable:                 translateInternal_Bool32(s.ExtendedDynamicState3AlphaToOneEnable),                 /*default*/
		extendedDynamicState3LogicOpEnable:                    translateInternal_Bool32(s.ExtendedDynamicState3LogicOpEnable),                    /*default*/
		extendedDynamicState3ColorBlendEnable:                 translateInternal_Bool32(s.ExtendedDynamicState3ColorBlendEnable),                 /*default*/
		extendedDynamicState3ColorBlendEquation:               translateInternal_Bool32(s.ExtendedDynamicState3ColorBlendEquation),               /*default*/
		extendedDynamicState3ColorWriteMask:                   translateInternal_Bool32(s.ExtendedDynamicState3ColorWriteMask),                   /*default*/
		extendedDynamicState3RasterizationStream:              translateInternal_Bool32(s.ExtendedDynamicState3RasterizationStream),              /*default*/
		extendedDynamicState3ConservativeRasterizationMode:    translateInternal_Bool32(s.ExtendedDynamicState3ConservativeRasterizationMode),    /*default*/
		extendedDynamicState3ExtraPrimitiveOverestimationSize: translateInternal_Bool32(s.ExtendedDynamicState3ExtraPrimitiveOverestimationSize), /*default*/
		extendedDynamicState3DepthClipEnable:                  translateInternal_Bool32(s.ExtendedDynamicState3DepthClipEnable),                  /*default*/
		extendedDynamicState3SampleLocationsEnable:            translateInternal_Bool32(s.ExtendedDynamicState3SampleLocationsEnable),            /*default*/
		extendedDynamicState3ColorBlendAdvanced:               translateInternal_Bool32(s.ExtendedDynamicState3ColorBlendAdvanced),               /*default*/
		extendedDynamicState3ProvokingVertexMode:              translateInternal_Bool32(s.ExtendedDynamicState3ProvokingVertexMode),              /*default*/
		extendedDynamicState3LineRasterizationMode:            translateInternal_Bool32(s.ExtendedDynamicState3LineRasterizationMode),            /*default*/
		extendedDynamicState3LineStippleEnable:                translateInternal_Bool32(s.ExtendedDynamicState3LineStippleEnable),                /*default*/
		extendedDynamicState3DepthClipNegativeOneToOne:        translateInternal_Bool32(s.ExtendedDynamicState3DepthClipNegativeOneToOne),        /*default*/
		extendedDynamicState3ViewportWScalingEnable:           translateInternal_Bool32(s.ExtendedDynamicState3ViewportWScalingEnable),           /*default*/
		extendedDynamicState3ViewportSwizzle:                  translateInternal_Bool32(s.ExtendedDynamicState3ViewportSwizzle),                  /*default*/
		extendedDynamicState3CoverageToColorEnable:            translateInternal_Bool32(s.ExtendedDynamicState3CoverageToColorEnable),            /*default*/
		extendedDynamicState3CoverageToColorLocation:          translateInternal_Bool32(s.ExtendedDynamicState3CoverageToColorLocation),          /*default*/
		extendedDynamicState3CoverageModulationMode:           translateInternal_Bool32(s.ExtendedDynamicState3CoverageModulationMode),           /*default*/
		extendedDynamicState3CoverageModulationTableEnable:    translateInternal_Bool32(s.ExtendedDynamicState3CoverageModulationTableEnable),    /*default*/
		extendedDynamicState3CoverageModulationTable:          translateInternal_Bool32(s.ExtendedDynamicState3CoverageModulationTable),          /*default*/
		extendedDynamicState3CoverageReductionMode:            translateInternal_Bool32(s.ExtendedDynamicState3CoverageReductionMode),            /*default*/
		extendedDynamicState3RepresentativeFragmentTestEnable: translateInternal_Bool32(s.ExtendedDynamicState3RepresentativeFragmentTestEnable), /*default*/
		extendedDynamicState3ShadingRateImageEnable:           translateInternal_Bool32(s.ExtendedDynamicState3ShadingRateImageEnable),           /*default*/
	}
	return rval
}

// PhysicalDeviceExtendedDynamicState3PropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.html
type PhysicalDeviceExtendedDynamicState3PropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT
	PNext                                unsafe.Pointer
	DynamicPrimitiveTopologyUnrestricted bool
}

type _vkPhysicalDeviceExtendedDynamicState3PropertiesEXT struct {
	sType                                StructureType
	pNext                                unsafe.Pointer
	dynamicPrimitiveTopologyUnrestricted Bool32
}

func (s *_vkPhysicalDeviceExtendedDynamicState3PropertiesEXT) Goify() *PhysicalDeviceExtendedDynamicState3PropertiesEXT {
	rval := &PhysicalDeviceExtendedDynamicState3PropertiesEXT{
		PNext:                                (unsafe.Pointer)(s.pNext),
		DynamicPrimitiveTopologyUnrestricted: translatePublic_Bool32(s.dynamicPrimitiveTopologyUnrestricted), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceExtendedDynamicState3PropertiesEXT) Vulkanize() *_vkPhysicalDeviceExtendedDynamicState3PropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExtendedDynamicState3PropertiesEXT{
		sType:                                STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT, /*c1*/
		pNext:                                (unsafe.Pointer)(s.PNext),                                              /*cb*/
		dynamicPrimitiveTopologyUnrestricted: translateInternal_Bool32(s.DynamicPrimitiveTopologyUnrestricted),       /*default*/
	}
	return rval
}

// PhysicalDeviceExtendedDynamicStateFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html
type PhysicalDeviceExtendedDynamicStateFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT
	PNext                unsafe.Pointer
	ExtendedDynamicState bool
}

type _vkPhysicalDeviceExtendedDynamicStateFeaturesEXT struct {
	sType                StructureType
	pNext                unsafe.Pointer
	extendedDynamicState Bool32
}

func (s *_vkPhysicalDeviceExtendedDynamicStateFeaturesEXT) Goify() *PhysicalDeviceExtendedDynamicStateFeaturesEXT {
	rval := &PhysicalDeviceExtendedDynamicStateFeaturesEXT{
		PNext:                (unsafe.Pointer)(s.pNext),
		ExtendedDynamicState: translatePublic_Bool32(s.extendedDynamicState), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceExtendedDynamicStateFeaturesEXT) Vulkanize() *_vkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExtendedDynamicStateFeaturesEXT{
		sType:                STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                          /*cb*/
		extendedDynamicState: translateInternal_Bool32(s.ExtendedDynamicState),                   /*default*/
	}
	return rval
}

// PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.html
type PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV
	PNext                      unsafe.Pointer
	ExtendedSparseAddressSpace bool
}

type _vkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	extendedSparseAddressSpace Bool32
}

func (s *_vkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV) Goify() *PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
	rval := &PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV{
		PNext:                      (unsafe.Pointer)(s.pNext),
		ExtendedSparseAddressSpace: translatePublic_Bool32(s.extendedSparseAddressSpace), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV) Vulkanize() *_vkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV{
		sType:                      STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                                /*cb*/
		extendedSparseAddressSpace: translateInternal_Bool32(s.ExtendedSparseAddressSpace),                   /*default*/
	}
	return rval
}

// PhysicalDeviceExtendedSparseAddressSpacePropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV.html
type PhysicalDeviceExtendedSparseAddressSpacePropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV
	PNext unsafe.Pointer
	//  Total address space available for extended sparse allocations (bytes);
	ExtendedSparseAddressSpaceSize DeviceSize
	//  Bitfield of which image usages are supported for extended sparse allocations;
	ExtendedSparseImageUsageFlags ImageUsageFlags
	//  Bitfield of which buffer usages are supported for extended sparse allocations;
	ExtendedSparseBufferUsageFlags BufferUsageFlags
}

// WARNING - struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	extendedSparseAddressSpaceSize DeviceSize
	extendedSparseImageUsageFlags  ImageUsageFlags
	extendedSparseBufferUsageFlags BufferUsageFlags
}

func (s *_vkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV) Goify() *PhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
	rval := &PhysicalDeviceExtendedSparseAddressSpacePropertiesNV{
		PNext:                          (unsafe.Pointer)(s.pNext),
		ExtendedSparseAddressSpaceSize: (DeviceSize)(s.extendedSparseAddressSpaceSize),
		ExtendedSparseImageUsageFlags:  (ImageUsageFlags)(s.extendedSparseImageUsageFlags),
		ExtendedSparseBufferUsageFlags: (BufferUsageFlags)(s.extendedSparseBufferUsageFlags),
	}
	return rval
}
func (s *PhysicalDeviceExtendedSparseAddressSpacePropertiesNV) Vulkanize() *_vkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV{
		sType:                          STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV, /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                                  /*cb*/
		extendedSparseAddressSpaceSize: (DeviceSize)(s.ExtendedSparseAddressSpaceSize),                             /*cb*/
		extendedSparseImageUsageFlags:  (ImageUsageFlags)(s.ExtendedSparseImageUsageFlags),                         /*cb*/
		extendedSparseBufferUsageFlags: (BufferUsageFlags)(s.ExtendedSparseBufferUsageFlags),                       /*cb*/
	}
	return rval
}

// PhysicalDeviceExternalBufferInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalBufferInfo.html
type PhysicalDeviceExternalBufferInfo struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO
	PNext      unsafe.Pointer
	Flags      BufferCreateFlags
	Usage      BufferUsageFlags
	HandleType ExternalMemoryHandleTypeFlagBits
}

type _vkPhysicalDeviceExternalBufferInfo struct {
	sType      StructureType
	pNext      unsafe.Pointer
	flags      BufferCreateFlags
	usage      BufferUsageFlags
	handleType ExternalMemoryHandleTypeFlagBits
}

func (s *_vkPhysicalDeviceExternalBufferInfo) Goify() *PhysicalDeviceExternalBufferInfo {
	rval := &PhysicalDeviceExternalBufferInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		Flags:      (BufferCreateFlags)(s.flags),
		Usage:      (BufferUsageFlags)(s.usage),
		HandleType: (ExternalMemoryHandleTypeFlagBits)(s.handleType),
	}
	return rval
}
func (s *PhysicalDeviceExternalBufferInfo) Vulkanize() *_vkPhysicalDeviceExternalBufferInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExternalBufferInfo{
		sType:      STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                           /*cb*/
		flags:      (BufferCreateFlags)(s.Flags),                        /*cb*/
		usage:      (BufferUsageFlags)(s.Usage),                         /*cb*/
		handleType: (ExternalMemoryHandleTypeFlagBits)(s.HandleType),    /*cb*/
	}
	return rval
}

// PhysicalDeviceExternalBufferInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalBufferInfoKHR.html
type PhysicalDeviceExternalBufferInfoKHR struct {
}

type _vkPhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfoKHR

func (s *_vkPhysicalDeviceExternalBufferInfoKHR) Goify() *PhysicalDeviceExternalBufferInfoKHR {
	rval := (*PhysicalDeviceExternalBufferInfoKHR)(s)
	return rval
}
func (s *PhysicalDeviceExternalBufferInfoKHR) Vulkanize() *_vkPhysicalDeviceExternalBufferInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceExternalBufferInfoKHR)(s)
	return rval
}

// PhysicalDeviceExternalFenceInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalFenceInfo.html
type PhysicalDeviceExternalFenceInfo struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO
	PNext      unsafe.Pointer
	HandleType ExternalFenceHandleTypeFlagBits
}

type _vkPhysicalDeviceExternalFenceInfo struct {
	sType      StructureType
	pNext      unsafe.Pointer
	handleType ExternalFenceHandleTypeFlagBits
}

func (s *_vkPhysicalDeviceExternalFenceInfo) Goify() *PhysicalDeviceExternalFenceInfo {
	rval := &PhysicalDeviceExternalFenceInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		HandleType: (ExternalFenceHandleTypeFlagBits)(s.handleType),
	}
	return rval
}
func (s *PhysicalDeviceExternalFenceInfo) Vulkanize() *_vkPhysicalDeviceExternalFenceInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExternalFenceInfo{
		sType:      STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                          /*cb*/
		handleType: (ExternalFenceHandleTypeFlagBits)(s.HandleType),    /*cb*/
	}
	return rval
}

// PhysicalDeviceExternalFenceInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalFenceInfoKHR.html
type PhysicalDeviceExternalFenceInfoKHR struct {
}

type _vkPhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfoKHR

func (s *_vkPhysicalDeviceExternalFenceInfoKHR) Goify() *PhysicalDeviceExternalFenceInfoKHR {
	rval := (*PhysicalDeviceExternalFenceInfoKHR)(s)
	return rval
}
func (s *PhysicalDeviceExternalFenceInfoKHR) Vulkanize() *_vkPhysicalDeviceExternalFenceInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceExternalFenceInfoKHR)(s)
	return rval
}

// PhysicalDeviceExternalImageFormatInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalImageFormatInfo.html
type PhysicalDeviceExternalImageFormatInfo struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO
	PNext      unsafe.Pointer
	HandleType ExternalMemoryHandleTypeFlagBits
}

type _vkPhysicalDeviceExternalImageFormatInfo struct {
	sType      StructureType
	pNext      unsafe.Pointer
	handleType ExternalMemoryHandleTypeFlagBits
}

func (s *_vkPhysicalDeviceExternalImageFormatInfo) Goify() *PhysicalDeviceExternalImageFormatInfo {
	rval := &PhysicalDeviceExternalImageFormatInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		HandleType: (ExternalMemoryHandleTypeFlagBits)(s.handleType),
	}
	return rval
}
func (s *PhysicalDeviceExternalImageFormatInfo) Vulkanize() *_vkPhysicalDeviceExternalImageFormatInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExternalImageFormatInfo{
		sType:      STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                                 /*cb*/
		handleType: (ExternalMemoryHandleTypeFlagBits)(s.HandleType),          /*cb*/
	}
	return rval
}

// PhysicalDeviceExternalImageFormatInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalImageFormatInfoKHR.html
type PhysicalDeviceExternalImageFormatInfoKHR struct {
}

type _vkPhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfoKHR

func (s *_vkPhysicalDeviceExternalImageFormatInfoKHR) Goify() *PhysicalDeviceExternalImageFormatInfoKHR {
	rval := (*PhysicalDeviceExternalImageFormatInfoKHR)(s)
	return rval
}
func (s *PhysicalDeviceExternalImageFormatInfoKHR) Vulkanize() *_vkPhysicalDeviceExternalImageFormatInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceExternalImageFormatInfoKHR)(s)
	return rval
}

// PhysicalDeviceExternalMemoryHostPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html
type PhysicalDeviceExternalMemoryHostPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT
	PNext                           unsafe.Pointer
	MinImportedHostPointerAlignment DeviceSize
}

// WARNING - struct PhysicalDeviceExternalMemoryHostPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceExternalMemoryHostPropertiesEXT struct {
	sType                           StructureType
	pNext                           unsafe.Pointer
	minImportedHostPointerAlignment DeviceSize
}

func (s *_vkPhysicalDeviceExternalMemoryHostPropertiesEXT) Goify() *PhysicalDeviceExternalMemoryHostPropertiesEXT {
	rval := &PhysicalDeviceExternalMemoryHostPropertiesEXT{
		PNext:                           (unsafe.Pointer)(s.pNext),
		MinImportedHostPointerAlignment: (DeviceSize)(s.minImportedHostPointerAlignment),
	}
	return rval
}
func (s *PhysicalDeviceExternalMemoryHostPropertiesEXT) Vulkanize() *_vkPhysicalDeviceExternalMemoryHostPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExternalMemoryHostPropertiesEXT{
		sType:                           STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, /*c1*/
		pNext:                           (unsafe.Pointer)(s.PNext),                                          /*cb*/
		minImportedHostPointerAlignment: (DeviceSize)(s.MinImportedHostPointerAlignment),                    /*cb*/
	}
	return rval
}

// PhysicalDeviceExternalMemoryRDMAFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html
type PhysicalDeviceExternalMemoryRDMAFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV
	PNext              unsafe.Pointer
	ExternalMemoryRDMA bool
}

type _vkPhysicalDeviceExternalMemoryRDMAFeaturesNV struct {
	sType              StructureType
	pNext              unsafe.Pointer
	externalMemoryRDMA Bool32
}

func (s *_vkPhysicalDeviceExternalMemoryRDMAFeaturesNV) Goify() *PhysicalDeviceExternalMemoryRDMAFeaturesNV {
	rval := &PhysicalDeviceExternalMemoryRDMAFeaturesNV{
		PNext:              (unsafe.Pointer)(s.pNext),
		ExternalMemoryRDMA: translatePublic_Bool32(s.externalMemoryRDMA), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceExternalMemoryRDMAFeaturesNV) Vulkanize() *_vkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExternalMemoryRDMAFeaturesNV{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                       /*cb*/
		externalMemoryRDMA: translateInternal_Bool32(s.ExternalMemoryRDMA),                  /*default*/
	}
	return rval
}

// PhysicalDeviceExternalSemaphoreInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html
type PhysicalDeviceExternalSemaphoreInfo struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO
	PNext      unsafe.Pointer
	HandleType ExternalSemaphoreHandleTypeFlagBits
}

type _vkPhysicalDeviceExternalSemaphoreInfo struct {
	sType      StructureType
	pNext      unsafe.Pointer
	handleType ExternalSemaphoreHandleTypeFlagBits
}

func (s *_vkPhysicalDeviceExternalSemaphoreInfo) Goify() *PhysicalDeviceExternalSemaphoreInfo {
	rval := &PhysicalDeviceExternalSemaphoreInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		HandleType: (ExternalSemaphoreHandleTypeFlagBits)(s.handleType),
	}
	return rval
}
func (s *PhysicalDeviceExternalSemaphoreInfo) Vulkanize() *_vkPhysicalDeviceExternalSemaphoreInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceExternalSemaphoreInfo{
		sType:      STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                              /*cb*/
		handleType: (ExternalSemaphoreHandleTypeFlagBits)(s.HandleType),    /*cb*/
	}
	return rval
}

// PhysicalDeviceExternalSemaphoreInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalSemaphoreInfoKHR.html
type PhysicalDeviceExternalSemaphoreInfoKHR struct {
}

type _vkPhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfoKHR

func (s *_vkPhysicalDeviceExternalSemaphoreInfoKHR) Goify() *PhysicalDeviceExternalSemaphoreInfoKHR {
	rval := (*PhysicalDeviceExternalSemaphoreInfoKHR)(s)
	return rval
}
func (s *PhysicalDeviceExternalSemaphoreInfoKHR) Vulkanize() *_vkPhysicalDeviceExternalSemaphoreInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceExternalSemaphoreInfoKHR)(s)
	return rval
}

// PhysicalDeviceFaultFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFaultFeaturesEXT.html
type PhysicalDeviceFaultFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT
	PNext                   unsafe.Pointer
	DeviceFault             bool
	DeviceFaultVendorBinary bool
}

type _vkPhysicalDeviceFaultFeaturesEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	deviceFault             Bool32
	deviceFaultVendorBinary Bool32
}

func (s *_vkPhysicalDeviceFaultFeaturesEXT) Goify() *PhysicalDeviceFaultFeaturesEXT {
	rval := &PhysicalDeviceFaultFeaturesEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		DeviceFault:             translatePublic_Bool32(s.deviceFault),             /*default*/
		DeviceFaultVendorBinary: translatePublic_Bool32(s.deviceFaultVendorBinary), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFaultFeaturesEXT) Vulkanize() *_vkPhysicalDeviceFaultFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFaultFeaturesEXT{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT,   /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                           /*cb*/
		deviceFault:             translateInternal_Bool32(s.DeviceFault),             /*default*/
		deviceFaultVendorBinary: translateInternal_Bool32(s.DeviceFaultVendorBinary), /*default*/
	}
	return rval
}

// PhysicalDeviceFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures.html
type PhysicalDeviceFeatures struct {
	//  out of bounds buffer accesses are well defined;
	RobustBufferAccess bool
	//  full 32-bit range of indices for indexed draw calls;
	FullDrawIndexUint32 bool
	//  image views which are arrays of cube maps;
	ImageCubeArray bool
	//  blending operations are controlled per-attachment;
	IndependentBlend bool
	//  geometry stage;
	GeometryShader bool
	//  tessellation control and evaluation stage;
	TessellationShader bool
	//  per-sample shading and interpolation;
	SampleRateShading bool
	//  blend operations which take two sources;
	DualSrcBlend bool
	//  logic operations;
	LogicOp bool
	//  multi draw indirect;
	MultiDrawIndirect bool
	//  indirect drawing can use non-zero firstInstance;
	DrawIndirectFirstInstance bool
	//  depth clamping;
	DepthClamp bool
	//  depth bias clamping;
	DepthBiasClamp bool
	//  point and wireframe fill modes;
	FillModeNonSolid bool
	//  depth bounds test;
	DepthBounds bool
	//  lines with width greater than 1;
	WideLines bool
	//  points with size greater than 1;
	LargePoints bool
	//  the fragment alpha component can be forced to maximum representable alpha value;
	AlphaToOne bool
	//  viewport arrays;
	MultiViewport bool
	//  anisotropic sampler filtering;
	SamplerAnisotropy bool
	//  ETC texture compression formats;
	TextureCompressionETC2 bool
	//  ASTC LDR texture compression formats;
	TextureCompressionASTC_LDR bool
	//  BC1-7 texture compressed formats;
	TextureCompressionBC bool
	//  precise occlusion queries returning actual sample counts;
	OcclusionQueryPrecise bool
	//  pipeline statistics query;
	PipelineStatisticsQuery bool
	//  stores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages;
	VertexPipelineStoresAndAtomics bool
	//  stores and atomic ops on storage buffers and images are supported in the fragment stage;
	FragmentStoresAndAtomics bool
	//  tessellation and geometry stages can export point size;
	ShaderTessellationAndGeometryPointSize bool
	//  image gather with run-time values and independent offsets;
	ShaderImageGatherExtended bool
	//  the extended set of formats can be used for storage images;
	ShaderStorageImageExtendedFormats bool
	//  multisample images can be used for storage images;
	ShaderStorageImageMultisample bool
	//  read from storage image does not require format qualifier;
	ShaderStorageImageReadWithoutFormat bool
	//  write to storage image does not require format qualifier;
	ShaderStorageImageWriteWithoutFormat bool
	//  arrays of uniform buffers can be accessed with dynamically uniform indices;
	ShaderUniformBufferArrayDynamicIndexing bool
	//  arrays of sampled images can be accessed with dynamically uniform indices;
	ShaderSampledImageArrayDynamicIndexing bool
	//  arrays of storage buffers can be accessed with dynamically uniform indices;
	ShaderStorageBufferArrayDynamicIndexing bool
	//  arrays of storage images can be accessed with dynamically uniform indices;
	ShaderStorageImageArrayDynamicIndexing bool
	//  clip distance in shaders;
	ShaderClipDistance bool
	//  cull distance in shaders;
	ShaderCullDistance bool
	//  64-bit floats (doubles) in shaders;
	ShaderFloat64 bool
	//  64-bit integers in shaders;
	ShaderInt64 bool
	//  16-bit integers in shaders;
	ShaderInt16 bool
	//  shader can use texture operations that return resource residency information (requires sparseNonResident support);
	ShaderResourceResidency bool
	//  shader can use texture operations that specify minimum resource LOD;
	ShaderResourceMinLod bool
	//  Sparse resources support: Resource memory can be managed at opaque page level rather than object level;
	SparseBinding bool
	//  Sparse resources support: GPU can access partially resident buffers ;
	SparseResidencyBuffer bool
	//  Sparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images ;
	SparseResidencyImage2D bool
	//  Sparse resources support: GPU can access partially resident 3D images ;
	SparseResidencyImage3D bool
	//  Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples;
	SparseResidency2Samples bool
	//  Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples;
	SparseResidency4Samples bool
	//  Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples;
	SparseResidency8Samples bool
	//  Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples;
	SparseResidency16Samples bool
	//  Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in);
	SparseResidencyAliased bool
	//  multisample rate must be the same for all pipelines in a subpass;
	VariableMultisampleRate bool
	//  Queries may be inherited from primary to secondary command buffers;
	InheritedQueries bool
}

type _vkPhysicalDeviceFeatures struct {
	robustBufferAccess                      Bool32
	fullDrawIndexUint32                     Bool32
	imageCubeArray                          Bool32
	independentBlend                        Bool32
	geometryShader                          Bool32
	tessellationShader                      Bool32
	sampleRateShading                       Bool32
	dualSrcBlend                            Bool32
	logicOp                                 Bool32
	multiDrawIndirect                       Bool32
	drawIndirectFirstInstance               Bool32
	depthClamp                              Bool32
	depthBiasClamp                          Bool32
	fillModeNonSolid                        Bool32
	depthBounds                             Bool32
	wideLines                               Bool32
	largePoints                             Bool32
	alphaToOne                              Bool32
	multiViewport                           Bool32
	samplerAnisotropy                       Bool32
	textureCompressionETC2                  Bool32
	textureCompressionASTC_LDR              Bool32
	textureCompressionBC                    Bool32
	occlusionQueryPrecise                   Bool32
	pipelineStatisticsQuery                 Bool32
	vertexPipelineStoresAndAtomics          Bool32
	fragmentStoresAndAtomics                Bool32
	shaderTessellationAndGeometryPointSize  Bool32
	shaderImageGatherExtended               Bool32
	shaderStorageImageExtendedFormats       Bool32
	shaderStorageImageMultisample           Bool32
	shaderStorageImageReadWithoutFormat     Bool32
	shaderStorageImageWriteWithoutFormat    Bool32
	shaderUniformBufferArrayDynamicIndexing Bool32
	shaderSampledImageArrayDynamicIndexing  Bool32
	shaderStorageBufferArrayDynamicIndexing Bool32
	shaderStorageImageArrayDynamicIndexing  Bool32
	shaderClipDistance                      Bool32
	shaderCullDistance                      Bool32
	shaderFloat64                           Bool32
	shaderInt64                             Bool32
	shaderInt16                             Bool32
	shaderResourceResidency                 Bool32
	shaderResourceMinLod                    Bool32
	sparseBinding                           Bool32
	sparseResidencyBuffer                   Bool32
	sparseResidencyImage2D                  Bool32
	sparseResidencyImage3D                  Bool32
	sparseResidency2Samples                 Bool32
	sparseResidency4Samples                 Bool32
	sparseResidency8Samples                 Bool32
	sparseResidency16Samples                Bool32
	sparseResidencyAliased                  Bool32
	variableMultisampleRate                 Bool32
	inheritedQueries                        Bool32
}

func (s *_vkPhysicalDeviceFeatures) Goify() *PhysicalDeviceFeatures {
	rval := &PhysicalDeviceFeatures{
		RobustBufferAccess:                      translatePublic_Bool32(s.robustBufferAccess),                      /*default*/
		FullDrawIndexUint32:                     translatePublic_Bool32(s.fullDrawIndexUint32),                     /*default*/
		ImageCubeArray:                          translatePublic_Bool32(s.imageCubeArray),                          /*default*/
		IndependentBlend:                        translatePublic_Bool32(s.independentBlend),                        /*default*/
		GeometryShader:                          translatePublic_Bool32(s.geometryShader),                          /*default*/
		TessellationShader:                      translatePublic_Bool32(s.tessellationShader),                      /*default*/
		SampleRateShading:                       translatePublic_Bool32(s.sampleRateShading),                       /*default*/
		DualSrcBlend:                            translatePublic_Bool32(s.dualSrcBlend),                            /*default*/
		LogicOp:                                 translatePublic_Bool32(s.logicOp),                                 /*default*/
		MultiDrawIndirect:                       translatePublic_Bool32(s.multiDrawIndirect),                       /*default*/
		DrawIndirectFirstInstance:               translatePublic_Bool32(s.drawIndirectFirstInstance),               /*default*/
		DepthClamp:                              translatePublic_Bool32(s.depthClamp),                              /*default*/
		DepthBiasClamp:                          translatePublic_Bool32(s.depthBiasClamp),                          /*default*/
		FillModeNonSolid:                        translatePublic_Bool32(s.fillModeNonSolid),                        /*default*/
		DepthBounds:                             translatePublic_Bool32(s.depthBounds),                             /*default*/
		WideLines:                               translatePublic_Bool32(s.wideLines),                               /*default*/
		LargePoints:                             translatePublic_Bool32(s.largePoints),                             /*default*/
		AlphaToOne:                              translatePublic_Bool32(s.alphaToOne),                              /*default*/
		MultiViewport:                           translatePublic_Bool32(s.multiViewport),                           /*default*/
		SamplerAnisotropy:                       translatePublic_Bool32(s.samplerAnisotropy),                       /*default*/
		TextureCompressionETC2:                  translatePublic_Bool32(s.textureCompressionETC2),                  /*default*/
		TextureCompressionASTC_LDR:              translatePublic_Bool32(s.textureCompressionASTC_LDR),              /*default*/
		TextureCompressionBC:                    translatePublic_Bool32(s.textureCompressionBC),                    /*default*/
		OcclusionQueryPrecise:                   translatePublic_Bool32(s.occlusionQueryPrecise),                   /*default*/
		PipelineStatisticsQuery:                 translatePublic_Bool32(s.pipelineStatisticsQuery),                 /*default*/
		VertexPipelineStoresAndAtomics:          translatePublic_Bool32(s.vertexPipelineStoresAndAtomics),          /*default*/
		FragmentStoresAndAtomics:                translatePublic_Bool32(s.fragmentStoresAndAtomics),                /*default*/
		ShaderTessellationAndGeometryPointSize:  translatePublic_Bool32(s.shaderTessellationAndGeometryPointSize),  /*default*/
		ShaderImageGatherExtended:               translatePublic_Bool32(s.shaderImageGatherExtended),               /*default*/
		ShaderStorageImageExtendedFormats:       translatePublic_Bool32(s.shaderStorageImageExtendedFormats),       /*default*/
		ShaderStorageImageMultisample:           translatePublic_Bool32(s.shaderStorageImageMultisample),           /*default*/
		ShaderStorageImageReadWithoutFormat:     translatePublic_Bool32(s.shaderStorageImageReadWithoutFormat),     /*default*/
		ShaderStorageImageWriteWithoutFormat:    translatePublic_Bool32(s.shaderStorageImageWriteWithoutFormat),    /*default*/
		ShaderUniformBufferArrayDynamicIndexing: translatePublic_Bool32(s.shaderUniformBufferArrayDynamicIndexing), /*default*/
		ShaderSampledImageArrayDynamicIndexing:  translatePublic_Bool32(s.shaderSampledImageArrayDynamicIndexing),  /*default*/
		ShaderStorageBufferArrayDynamicIndexing: translatePublic_Bool32(s.shaderStorageBufferArrayDynamicIndexing), /*default*/
		ShaderStorageImageArrayDynamicIndexing:  translatePublic_Bool32(s.shaderStorageImageArrayDynamicIndexing),  /*default*/
		ShaderClipDistance:                      translatePublic_Bool32(s.shaderClipDistance),                      /*default*/
		ShaderCullDistance:                      translatePublic_Bool32(s.shaderCullDistance),                      /*default*/
		ShaderFloat64:                           translatePublic_Bool32(s.shaderFloat64),                           /*default*/
		ShaderInt64:                             translatePublic_Bool32(s.shaderInt64),                             /*default*/
		ShaderInt16:                             translatePublic_Bool32(s.shaderInt16),                             /*default*/
		ShaderResourceResidency:                 translatePublic_Bool32(s.shaderResourceResidency),                 /*default*/
		ShaderResourceMinLod:                    translatePublic_Bool32(s.shaderResourceMinLod),                    /*default*/
		SparseBinding:                           translatePublic_Bool32(s.sparseBinding),                           /*default*/
		SparseResidencyBuffer:                   translatePublic_Bool32(s.sparseResidencyBuffer),                   /*default*/
		SparseResidencyImage2D:                  translatePublic_Bool32(s.sparseResidencyImage2D),                  /*default*/
		SparseResidencyImage3D:                  translatePublic_Bool32(s.sparseResidencyImage3D),                  /*default*/
		SparseResidency2Samples:                 translatePublic_Bool32(s.sparseResidency2Samples),                 /*default*/
		SparseResidency4Samples:                 translatePublic_Bool32(s.sparseResidency4Samples),                 /*default*/
		SparseResidency8Samples:                 translatePublic_Bool32(s.sparseResidency8Samples),                 /*default*/
		SparseResidency16Samples:                translatePublic_Bool32(s.sparseResidency16Samples),                /*default*/
		SparseResidencyAliased:                  translatePublic_Bool32(s.sparseResidencyAliased),                  /*default*/
		VariableMultisampleRate:                 translatePublic_Bool32(s.variableMultisampleRate),                 /*default*/
		InheritedQueries:                        translatePublic_Bool32(s.inheritedQueries),                        /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFeatures) Vulkanize() *_vkPhysicalDeviceFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFeatures{
		robustBufferAccess:                      translateInternal_Bool32(s.RobustBufferAccess),                      /*default*/
		fullDrawIndexUint32:                     translateInternal_Bool32(s.FullDrawIndexUint32),                     /*default*/
		imageCubeArray:                          translateInternal_Bool32(s.ImageCubeArray),                          /*default*/
		independentBlend:                        translateInternal_Bool32(s.IndependentBlend),                        /*default*/
		geometryShader:                          translateInternal_Bool32(s.GeometryShader),                          /*default*/
		tessellationShader:                      translateInternal_Bool32(s.TessellationShader),                      /*default*/
		sampleRateShading:                       translateInternal_Bool32(s.SampleRateShading),                       /*default*/
		dualSrcBlend:                            translateInternal_Bool32(s.DualSrcBlend),                            /*default*/
		logicOp:                                 translateInternal_Bool32(s.LogicOp),                                 /*default*/
		multiDrawIndirect:                       translateInternal_Bool32(s.MultiDrawIndirect),                       /*default*/
		drawIndirectFirstInstance:               translateInternal_Bool32(s.DrawIndirectFirstInstance),               /*default*/
		depthClamp:                              translateInternal_Bool32(s.DepthClamp),                              /*default*/
		depthBiasClamp:                          translateInternal_Bool32(s.DepthBiasClamp),                          /*default*/
		fillModeNonSolid:                        translateInternal_Bool32(s.FillModeNonSolid),                        /*default*/
		depthBounds:                             translateInternal_Bool32(s.DepthBounds),                             /*default*/
		wideLines:                               translateInternal_Bool32(s.WideLines),                               /*default*/
		largePoints:                             translateInternal_Bool32(s.LargePoints),                             /*default*/
		alphaToOne:                              translateInternal_Bool32(s.AlphaToOne),                              /*default*/
		multiViewport:                           translateInternal_Bool32(s.MultiViewport),                           /*default*/
		samplerAnisotropy:                       translateInternal_Bool32(s.SamplerAnisotropy),                       /*default*/
		textureCompressionETC2:                  translateInternal_Bool32(s.TextureCompressionETC2),                  /*default*/
		textureCompressionASTC_LDR:              translateInternal_Bool32(s.TextureCompressionASTC_LDR),              /*default*/
		textureCompressionBC:                    translateInternal_Bool32(s.TextureCompressionBC),                    /*default*/
		occlusionQueryPrecise:                   translateInternal_Bool32(s.OcclusionQueryPrecise),                   /*default*/
		pipelineStatisticsQuery:                 translateInternal_Bool32(s.PipelineStatisticsQuery),                 /*default*/
		vertexPipelineStoresAndAtomics:          translateInternal_Bool32(s.VertexPipelineStoresAndAtomics),          /*default*/
		fragmentStoresAndAtomics:                translateInternal_Bool32(s.FragmentStoresAndAtomics),                /*default*/
		shaderTessellationAndGeometryPointSize:  translateInternal_Bool32(s.ShaderTessellationAndGeometryPointSize),  /*default*/
		shaderImageGatherExtended:               translateInternal_Bool32(s.ShaderImageGatherExtended),               /*default*/
		shaderStorageImageExtendedFormats:       translateInternal_Bool32(s.ShaderStorageImageExtendedFormats),       /*default*/
		shaderStorageImageMultisample:           translateInternal_Bool32(s.ShaderStorageImageMultisample),           /*default*/
		shaderStorageImageReadWithoutFormat:     translateInternal_Bool32(s.ShaderStorageImageReadWithoutFormat),     /*default*/
		shaderStorageImageWriteWithoutFormat:    translateInternal_Bool32(s.ShaderStorageImageWriteWithoutFormat),    /*default*/
		shaderUniformBufferArrayDynamicIndexing: translateInternal_Bool32(s.ShaderUniformBufferArrayDynamicIndexing), /*default*/
		shaderSampledImageArrayDynamicIndexing:  translateInternal_Bool32(s.ShaderSampledImageArrayDynamicIndexing),  /*default*/
		shaderStorageBufferArrayDynamicIndexing: translateInternal_Bool32(s.ShaderStorageBufferArrayDynamicIndexing), /*default*/
		shaderStorageImageArrayDynamicIndexing:  translateInternal_Bool32(s.ShaderStorageImageArrayDynamicIndexing),  /*default*/
		shaderClipDistance:                      translateInternal_Bool32(s.ShaderClipDistance),                      /*default*/
		shaderCullDistance:                      translateInternal_Bool32(s.ShaderCullDistance),                      /*default*/
		shaderFloat64:                           translateInternal_Bool32(s.ShaderFloat64),                           /*default*/
		shaderInt64:                             translateInternal_Bool32(s.ShaderInt64),                             /*default*/
		shaderInt16:                             translateInternal_Bool32(s.ShaderInt16),                             /*default*/
		shaderResourceResidency:                 translateInternal_Bool32(s.ShaderResourceResidency),                 /*default*/
		shaderResourceMinLod:                    translateInternal_Bool32(s.ShaderResourceMinLod),                    /*default*/
		sparseBinding:                           translateInternal_Bool32(s.SparseBinding),                           /*default*/
		sparseResidencyBuffer:                   translateInternal_Bool32(s.SparseResidencyBuffer),                   /*default*/
		sparseResidencyImage2D:                  translateInternal_Bool32(s.SparseResidencyImage2D),                  /*default*/
		sparseResidencyImage3D:                  translateInternal_Bool32(s.SparseResidencyImage3D),                  /*default*/
		sparseResidency2Samples:                 translateInternal_Bool32(s.SparseResidency2Samples),                 /*default*/
		sparseResidency4Samples:                 translateInternal_Bool32(s.SparseResidency4Samples),                 /*default*/
		sparseResidency8Samples:                 translateInternal_Bool32(s.SparseResidency8Samples),                 /*default*/
		sparseResidency16Samples:                translateInternal_Bool32(s.SparseResidency16Samples),                /*default*/
		sparseResidencyAliased:                  translateInternal_Bool32(s.SparseResidencyAliased),                  /*default*/
		variableMultisampleRate:                 translateInternal_Bool32(s.VariableMultisampleRate),                 /*default*/
		inheritedQueries:                        translateInternal_Bool32(s.InheritedQueries),                        /*default*/
	}
	return rval
}

// PhysicalDeviceFeatures2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures2.html
type PhysicalDeviceFeatures2 struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2
	PNext    unsafe.Pointer
	Features PhysicalDeviceFeatures
}

type _vkPhysicalDeviceFeatures2 struct {
	sType    StructureType
	pNext    unsafe.Pointer
	features _vkPhysicalDeviceFeatures
}

func (s *_vkPhysicalDeviceFeatures2) Goify() *PhysicalDeviceFeatures2 {
	rval := &PhysicalDeviceFeatures2{
		PNext:    (unsafe.Pointer)(s.pNext),
		Features: *(s.features.Goify()),
	}
	return rval
}
func (s *PhysicalDeviceFeatures2) Vulkanize() *_vkPhysicalDeviceFeatures2 {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFeatures2{
		sType:    STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                 /*cb*/
		features: *(s.Features.Vulkanize()),                 /*c3*/
	}
	return rval
}

// PhysicalDeviceFeatures2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures2KHR.html
type PhysicalDeviceFeatures2KHR struct {
}

type _vkPhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2KHR

func (s *_vkPhysicalDeviceFeatures2KHR) Goify() *PhysicalDeviceFeatures2KHR {
	rval := (*PhysicalDeviceFeatures2KHR)(s)
	return rval
}
func (s *PhysicalDeviceFeatures2KHR) Vulkanize() *_vkPhysicalDeviceFeatures2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceFeatures2KHR)(s)
	return rval
}

// PhysicalDeviceFloat16Int8FeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFloat16Int8FeaturesKHR.html
type PhysicalDeviceFloat16Int8FeaturesKHR struct {
}

type _vkPhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceFloat16Int8FeaturesKHR

func (s *_vkPhysicalDeviceFloat16Int8FeaturesKHR) Goify() *PhysicalDeviceFloat16Int8FeaturesKHR {
	rval := (*PhysicalDeviceFloat16Int8FeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceFloat16Int8FeaturesKHR) Vulkanize() *_vkPhysicalDeviceFloat16Int8FeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceFloat16Int8FeaturesKHR)(s)
	return rval
}

// PhysicalDeviceFloatControlsProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFloatControlsProperties.html
type PhysicalDeviceFloatControlsProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES
	PNext                      unsafe.Pointer
	DenormBehaviorIndependence ShaderFloatControlsIndependence
	RoundingModeIndependence   ShaderFloatControlsIndependence
	//  An implementation can preserve signed zero, nan, inf;
	ShaderSignedZeroInfNanPreserveFloat16 bool
	//  An implementation can preserve signed zero, nan, inf;
	ShaderSignedZeroInfNanPreserveFloat32 bool
	//  An implementation can preserve signed zero, nan, inf;
	ShaderSignedZeroInfNanPreserveFloat64 bool
	//  An implementation can preserve  denormals;
	ShaderDenormPreserveFloat16 bool
	//  An implementation can preserve  denormals;
	ShaderDenormPreserveFloat32 bool
	//  An implementation can preserve  denormals;
	ShaderDenormPreserveFloat64 bool
	//  An implementation can flush to zero  denormals;
	ShaderDenormFlushToZeroFloat16 bool
	//  An implementation can flush to zero  denormals;
	ShaderDenormFlushToZeroFloat32 bool
	//  An implementation can flush to zero  denormals;
	ShaderDenormFlushToZeroFloat64 bool
	//  An implementation can support RTE;
	ShaderRoundingModeRTEFloat16 bool
	//  An implementation can support RTE;
	ShaderRoundingModeRTEFloat32 bool
	//  An implementation can support RTE;
	ShaderRoundingModeRTEFloat64 bool
	//  An implementation can support RTZ;
	ShaderRoundingModeRTZFloat16 bool
	//  An implementation can support RTZ;
	ShaderRoundingModeRTZFloat32 bool
	//  An implementation can support RTZ;
	ShaderRoundingModeRTZFloat64 bool
}

// WARNING - struct PhysicalDeviceFloatControlsProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceFloatControlsProperties struct {
	sType                                 StructureType
	pNext                                 unsafe.Pointer
	denormBehaviorIndependence            ShaderFloatControlsIndependence
	roundingModeIndependence              ShaderFloatControlsIndependence
	shaderSignedZeroInfNanPreserveFloat16 Bool32
	shaderSignedZeroInfNanPreserveFloat32 Bool32
	shaderSignedZeroInfNanPreserveFloat64 Bool32
	shaderDenormPreserveFloat16           Bool32
	shaderDenormPreserveFloat32           Bool32
	shaderDenormPreserveFloat64           Bool32
	shaderDenormFlushToZeroFloat16        Bool32
	shaderDenormFlushToZeroFloat32        Bool32
	shaderDenormFlushToZeroFloat64        Bool32
	shaderRoundingModeRTEFloat16          Bool32
	shaderRoundingModeRTEFloat32          Bool32
	shaderRoundingModeRTEFloat64          Bool32
	shaderRoundingModeRTZFloat16          Bool32
	shaderRoundingModeRTZFloat32          Bool32
	shaderRoundingModeRTZFloat64          Bool32
}

func (s *_vkPhysicalDeviceFloatControlsProperties) Goify() *PhysicalDeviceFloatControlsProperties {
	rval := &PhysicalDeviceFloatControlsProperties{
		PNext:                                 (unsafe.Pointer)(s.pNext),
		DenormBehaviorIndependence:            (ShaderFloatControlsIndependence)(s.denormBehaviorIndependence),
		RoundingModeIndependence:              (ShaderFloatControlsIndependence)(s.roundingModeIndependence),
		ShaderSignedZeroInfNanPreserveFloat16: translatePublic_Bool32(s.shaderSignedZeroInfNanPreserveFloat16), /*default*/
		ShaderSignedZeroInfNanPreserveFloat32: translatePublic_Bool32(s.shaderSignedZeroInfNanPreserveFloat32), /*default*/
		ShaderSignedZeroInfNanPreserveFloat64: translatePublic_Bool32(s.shaderSignedZeroInfNanPreserveFloat64), /*default*/
		ShaderDenormPreserveFloat16:           translatePublic_Bool32(s.shaderDenormPreserveFloat16),           /*default*/
		ShaderDenormPreserveFloat32:           translatePublic_Bool32(s.shaderDenormPreserveFloat32),           /*default*/
		ShaderDenormPreserveFloat64:           translatePublic_Bool32(s.shaderDenormPreserveFloat64),           /*default*/
		ShaderDenormFlushToZeroFloat16:        translatePublic_Bool32(s.shaderDenormFlushToZeroFloat16),        /*default*/
		ShaderDenormFlushToZeroFloat32:        translatePublic_Bool32(s.shaderDenormFlushToZeroFloat32),        /*default*/
		ShaderDenormFlushToZeroFloat64:        translatePublic_Bool32(s.shaderDenormFlushToZeroFloat64),        /*default*/
		ShaderRoundingModeRTEFloat16:          translatePublic_Bool32(s.shaderRoundingModeRTEFloat16),          /*default*/
		ShaderRoundingModeRTEFloat32:          translatePublic_Bool32(s.shaderRoundingModeRTEFloat32),          /*default*/
		ShaderRoundingModeRTEFloat64:          translatePublic_Bool32(s.shaderRoundingModeRTEFloat64),          /*default*/
		ShaderRoundingModeRTZFloat16:          translatePublic_Bool32(s.shaderRoundingModeRTZFloat16),          /*default*/
		ShaderRoundingModeRTZFloat32:          translatePublic_Bool32(s.shaderRoundingModeRTZFloat32),          /*default*/
		ShaderRoundingModeRTZFloat64:          translatePublic_Bool32(s.shaderRoundingModeRTZFloat64),          /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFloatControlsProperties) Vulkanize() *_vkPhysicalDeviceFloatControlsProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFloatControlsProperties{
		sType:                                 STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,          /*c1*/
		pNext:                                 (unsafe.Pointer)(s.PNext),                                         /*cb*/
		denormBehaviorIndependence:            (ShaderFloatControlsIndependence)(s.DenormBehaviorIndependence),   /*cb*/
		roundingModeIndependence:              (ShaderFloatControlsIndependence)(s.RoundingModeIndependence),     /*cb*/
		shaderSignedZeroInfNanPreserveFloat16: translateInternal_Bool32(s.ShaderSignedZeroInfNanPreserveFloat16), /*default*/
		shaderSignedZeroInfNanPreserveFloat32: translateInternal_Bool32(s.ShaderSignedZeroInfNanPreserveFloat32), /*default*/
		shaderSignedZeroInfNanPreserveFloat64: translateInternal_Bool32(s.ShaderSignedZeroInfNanPreserveFloat64), /*default*/
		shaderDenormPreserveFloat16:           translateInternal_Bool32(s.ShaderDenormPreserveFloat16),           /*default*/
		shaderDenormPreserveFloat32:           translateInternal_Bool32(s.ShaderDenormPreserveFloat32),           /*default*/
		shaderDenormPreserveFloat64:           translateInternal_Bool32(s.ShaderDenormPreserveFloat64),           /*default*/
		shaderDenormFlushToZeroFloat16:        translateInternal_Bool32(s.ShaderDenormFlushToZeroFloat16),        /*default*/
		shaderDenormFlushToZeroFloat32:        translateInternal_Bool32(s.ShaderDenormFlushToZeroFloat32),        /*default*/
		shaderDenormFlushToZeroFloat64:        translateInternal_Bool32(s.ShaderDenormFlushToZeroFloat64),        /*default*/
		shaderRoundingModeRTEFloat16:          translateInternal_Bool32(s.ShaderRoundingModeRTEFloat16),          /*default*/
		shaderRoundingModeRTEFloat32:          translateInternal_Bool32(s.ShaderRoundingModeRTEFloat32),          /*default*/
		shaderRoundingModeRTEFloat64:          translateInternal_Bool32(s.ShaderRoundingModeRTEFloat64),          /*default*/
		shaderRoundingModeRTZFloat16:          translateInternal_Bool32(s.ShaderRoundingModeRTZFloat16),          /*default*/
		shaderRoundingModeRTZFloat32:          translateInternal_Bool32(s.ShaderRoundingModeRTZFloat32),          /*default*/
		shaderRoundingModeRTZFloat64:          translateInternal_Bool32(s.ShaderRoundingModeRTZFloat64),          /*default*/
	}
	return rval
}

// PhysicalDeviceFloatControlsPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFloatControlsPropertiesKHR.html
type PhysicalDeviceFloatControlsPropertiesKHR struct {
}

type _vkPhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsPropertiesKHR

func (s *_vkPhysicalDeviceFloatControlsPropertiesKHR) Goify() *PhysicalDeviceFloatControlsPropertiesKHR {
	rval := (*PhysicalDeviceFloatControlsPropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceFloatControlsPropertiesKHR) Vulkanize() *_vkPhysicalDeviceFloatControlsPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceFloatControlsPropertiesKHR)(s)
	return rval
}

// PhysicalDeviceFragmentDensityMap2FeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html
type PhysicalDeviceFragmentDensityMap2FeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT
	PNext                      unsafe.Pointer
	FragmentDensityMapDeferred bool
}

type _vkPhysicalDeviceFragmentDensityMap2FeaturesEXT struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	fragmentDensityMapDeferred Bool32
}

func (s *_vkPhysicalDeviceFragmentDensityMap2FeaturesEXT) Goify() *PhysicalDeviceFragmentDensityMap2FeaturesEXT {
	rval := &PhysicalDeviceFragmentDensityMap2FeaturesEXT{
		PNext:                      (unsafe.Pointer)(s.pNext),
		FragmentDensityMapDeferred: translatePublic_Bool32(s.fragmentDensityMapDeferred), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentDensityMap2FeaturesEXT) Vulkanize() *_vkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentDensityMap2FeaturesEXT{
		sType:                      STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                          /*cb*/
		fragmentDensityMapDeferred: translateInternal_Bool32(s.FragmentDensityMapDeferred),             /*default*/
	}
	return rval
}

// PhysicalDeviceFragmentDensityMap2PropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html
type PhysicalDeviceFragmentDensityMap2PropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT
	PNext                                     unsafe.Pointer
	SubsampledLoads                           bool
	SubsampledCoarseReconstructionEarlyAccess bool
	MaxSubsampledArrayLayers                  uint32
	MaxDescriptorSetSubsampledSamplers        uint32
}

// WARNING - struct PhysicalDeviceFragmentDensityMap2PropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceFragmentDensityMap2PropertiesEXT struct {
	sType                                     StructureType
	pNext                                     unsafe.Pointer
	subsampledLoads                           Bool32
	subsampledCoarseReconstructionEarlyAccess Bool32
	maxSubsampledArrayLayers                  uint32
	maxDescriptorSetSubsampledSamplers        uint32
}

func (s *_vkPhysicalDeviceFragmentDensityMap2PropertiesEXT) Goify() *PhysicalDeviceFragmentDensityMap2PropertiesEXT {
	rval := &PhysicalDeviceFragmentDensityMap2PropertiesEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		SubsampledLoads: translatePublic_Bool32(s.subsampledLoads), /*default*/
		SubsampledCoarseReconstructionEarlyAccess: translatePublic_Bool32(s.subsampledCoarseReconstructionEarlyAccess), /*default*/
		MaxSubsampledArrayLayers:                  (uint32)(s.maxSubsampledArrayLayers),
		MaxDescriptorSetSubsampledSamplers:        (uint32)(s.maxDescriptorSetSubsampledSamplers),
	}
	return rval
}
func (s *PhysicalDeviceFragmentDensityMap2PropertiesEXT) Vulkanize() *_vkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentDensityMap2PropertiesEXT{
		sType:           STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                            /*cb*/
		subsampledLoads: translateInternal_Bool32(s.SubsampledLoads),                          /*default*/
		subsampledCoarseReconstructionEarlyAccess: translateInternal_Bool32(s.SubsampledCoarseReconstructionEarlyAccess), /*default*/
		maxSubsampledArrayLayers:                  (uint32)(s.MaxSubsampledArrayLayers),                                  /*cb*/
		maxDescriptorSetSubsampledSamplers:        (uint32)(s.MaxDescriptorSetSubsampledSamplers),                        /*cb*/
	}
	return rval
}

// PhysicalDeviceFragmentDensityMapFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html
type PhysicalDeviceFragmentDensityMapFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT
	PNext                                 unsafe.Pointer
	FragmentDensityMap                    bool
	FragmentDensityMapDynamic             bool
	FragmentDensityMapNonSubsampledImages bool
}

type _vkPhysicalDeviceFragmentDensityMapFeaturesEXT struct {
	sType                                 StructureType
	pNext                                 unsafe.Pointer
	fragmentDensityMap                    Bool32
	fragmentDensityMapDynamic             Bool32
	fragmentDensityMapNonSubsampledImages Bool32
}

func (s *_vkPhysicalDeviceFragmentDensityMapFeaturesEXT) Goify() *PhysicalDeviceFragmentDensityMapFeaturesEXT {
	rval := &PhysicalDeviceFragmentDensityMapFeaturesEXT{
		PNext:                                 (unsafe.Pointer)(s.pNext),
		FragmentDensityMap:                    translatePublic_Bool32(s.fragmentDensityMap),                    /*default*/
		FragmentDensityMapDynamic:             translatePublic_Bool32(s.fragmentDensityMapDynamic),             /*default*/
		FragmentDensityMapNonSubsampledImages: translatePublic_Bool32(s.fragmentDensityMapNonSubsampledImages), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentDensityMapFeaturesEXT) Vulkanize() *_vkPhysicalDeviceFragmentDensityMapFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentDensityMapFeaturesEXT{
		sType:                                 STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,  /*c1*/
		pNext:                                 (unsafe.Pointer)(s.PNext),                                         /*cb*/
		fragmentDensityMap:                    translateInternal_Bool32(s.FragmentDensityMap),                    /*default*/
		fragmentDensityMapDynamic:             translateInternal_Bool32(s.FragmentDensityMapDynamic),             /*default*/
		fragmentDensityMapNonSubsampledImages: translateInternal_Bool32(s.FragmentDensityMapNonSubsampledImages), /*default*/
	}
	return rval
}

// PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.html
type PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM
	PNext                    unsafe.Pointer
	FragmentDensityMapOffset bool
}

type _vkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	fragmentDensityMapOffset Bool32
}

func (s *_vkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM) Goify() *PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
	rval := &PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM{
		PNext:                    (unsafe.Pointer)(s.pNext),
		FragmentDensityMapOffset: translatePublic_Bool32(s.fragmentDensityMapOffset), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM) Vulkanize() *_vkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM{
		sType:                    STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                                /*cb*/
		fragmentDensityMapOffset: translateInternal_Bool32(s.FragmentDensityMapOffset),                     /*default*/
	}
	return rval
}

// PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM.html
type PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM
	PNext                            unsafe.Pointer
	FragmentDensityOffsetGranularity Extent2D
}

// WARNING - struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	fragmentDensityOffsetGranularity _vkExtent2D
}

func (s *_vkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM) Goify() *PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
	rval := &PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM{
		PNext:                            (unsafe.Pointer)(s.pNext),
		FragmentDensityOffsetGranularity: (Extent2D)(s.fragmentDensityOffsetGranularity),
	}
	return rval
}
func (s *PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM) Vulkanize() *_vkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                                  /*cb*/
		fragmentDensityOffsetGranularity: (_vkExtent2D)(s.FragmentDensityOffsetGranularity),                          /*cb*/
	}
	return rval
}

// PhysicalDeviceFragmentDensityMapPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html
type PhysicalDeviceFragmentDensityMapPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT
	PNext                       unsafe.Pointer
	MinFragmentDensityTexelSize Extent2D
	MaxFragmentDensityTexelSize Extent2D
	FragmentDensityInvocations  bool
}

// WARNING - struct PhysicalDeviceFragmentDensityMapPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceFragmentDensityMapPropertiesEXT struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	minFragmentDensityTexelSize _vkExtent2D
	maxFragmentDensityTexelSize _vkExtent2D
	fragmentDensityInvocations  Bool32
}

func (s *_vkPhysicalDeviceFragmentDensityMapPropertiesEXT) Goify() *PhysicalDeviceFragmentDensityMapPropertiesEXT {
	rval := &PhysicalDeviceFragmentDensityMapPropertiesEXT{
		PNext:                       (unsafe.Pointer)(s.pNext),
		MinFragmentDensityTexelSize: (Extent2D)(s.minFragmentDensityTexelSize),
		MaxFragmentDensityTexelSize: (Extent2D)(s.maxFragmentDensityTexelSize),
		FragmentDensityInvocations:  translatePublic_Bool32(s.fragmentDensityInvocations), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentDensityMapPropertiesEXT) Vulkanize() *_vkPhysicalDeviceFragmentDensityMapPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentDensityMapPropertiesEXT{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                          /*cb*/
		minFragmentDensityTexelSize: (_vkExtent2D)(s.MinFragmentDensityTexelSize),                       /*cb*/
		maxFragmentDensityTexelSize: (_vkExtent2D)(s.MaxFragmentDensityTexelSize),                       /*cb*/
		fragmentDensityInvocations:  translateInternal_Bool32(s.FragmentDensityInvocations),             /*default*/
	}
	return rval
}

// PhysicalDeviceFragmentShaderBarycentricFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.html
type PhysicalDeviceFragmentShaderBarycentricFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR
	PNext                     unsafe.Pointer
	FragmentShaderBarycentric bool
}

type _vkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	fragmentShaderBarycentric Bool32
}

func (s *_vkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR) Goify() *PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
	rval := &PhysicalDeviceFragmentShaderBarycentricFeaturesKHR{
		PNext:                     (unsafe.Pointer)(s.pNext),
		FragmentShaderBarycentric: translatePublic_Bool32(s.fragmentShaderBarycentric), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentShaderBarycentricFeaturesKHR) Vulkanize() *_vkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR{
		sType:                     STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                                               /*cb*/
		fragmentShaderBarycentric: translateInternal_Bool32(s.FragmentShaderBarycentric),                   /*default*/
	}
	return rval
}

// PhysicalDeviceFragmentShaderBarycentricFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.html
type PhysicalDeviceFragmentShaderBarycentricFeaturesNV struct {
}

type _vkPhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesNV

func (s *_vkPhysicalDeviceFragmentShaderBarycentricFeaturesNV) Goify() *PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
	rval := (*PhysicalDeviceFragmentShaderBarycentricFeaturesNV)(s)
	return rval
}
func (s *PhysicalDeviceFragmentShaderBarycentricFeaturesNV) Vulkanize() *_vkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)(s)
	return rval
}

// PhysicalDeviceFragmentShaderBarycentricPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.html
type PhysicalDeviceFragmentShaderBarycentricPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR
	PNext                                           unsafe.Pointer
	TriStripVertexOrderIndependentOfProvokingVertex bool
}

// WARNING - struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR struct {
	sType                                           StructureType
	pNext                                           unsafe.Pointer
	triStripVertexOrderIndependentOfProvokingVertex Bool32
}

func (s *_vkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR) Goify() *PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
	rval := &PhysicalDeviceFragmentShaderBarycentricPropertiesKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		TriStripVertexOrderIndependentOfProvokingVertex: translatePublic_Bool32(s.triStripVertexOrderIndependentOfProvokingVertex), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentShaderBarycentricPropertiesKHR) Vulkanize() *_vkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                                 /*cb*/
		triStripVertexOrderIndependentOfProvokingVertex: translateInternal_Bool32(s.TriStripVertexOrderIndependentOfProvokingVertex), /*default*/
	}
	return rval
}

// PhysicalDeviceFragmentShaderInterlockFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html
type PhysicalDeviceFragmentShaderInterlockFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT
	//  Pointer to next structure;
	PNext                              unsafe.Pointer
	FragmentShaderSampleInterlock      bool
	FragmentShaderPixelInterlock       bool
	FragmentShaderShadingRateInterlock bool
}

type _vkPhysicalDeviceFragmentShaderInterlockFeaturesEXT struct {
	sType                              StructureType
	pNext                              unsafe.Pointer
	fragmentShaderSampleInterlock      Bool32
	fragmentShaderPixelInterlock       Bool32
	fragmentShaderShadingRateInterlock Bool32
}

func (s *_vkPhysicalDeviceFragmentShaderInterlockFeaturesEXT) Goify() *PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
	rval := &PhysicalDeviceFragmentShaderInterlockFeaturesEXT{
		PNext:                              (unsafe.Pointer)(s.pNext),
		FragmentShaderSampleInterlock:      translatePublic_Bool32(s.fragmentShaderSampleInterlock),      /*default*/
		FragmentShaderPixelInterlock:       translatePublic_Bool32(s.fragmentShaderPixelInterlock),       /*default*/
		FragmentShaderShadingRateInterlock: translatePublic_Bool32(s.fragmentShaderShadingRateInterlock), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentShaderInterlockFeaturesEXT) Vulkanize() *_vkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentShaderInterlockFeaturesEXT{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                             /*cb*/
		fragmentShaderSampleInterlock:      translateInternal_Bool32(s.FragmentShaderSampleInterlock),             /*default*/
		fragmentShaderPixelInterlock:       translateInternal_Bool32(s.FragmentShaderPixelInterlock),              /*default*/
		fragmentShaderShadingRateInterlock: translateInternal_Bool32(s.FragmentShaderShadingRateInterlock),        /*default*/
	}
	return rval
}

// PhysicalDeviceFragmentShadingRateEnumsFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html
type PhysicalDeviceFragmentShadingRateEnumsFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV
	PNext                            unsafe.Pointer
	FragmentShadingRateEnums         bool
	SupersampleFragmentShadingRates  bool
	NoInvocationFragmentShadingRates bool
}

type _vkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	fragmentShadingRateEnums         Bool32
	supersampleFragmentShadingRates  Bool32
	noInvocationFragmentShadingRates Bool32
}

func (s *_vkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV) Goify() *PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
	rval := &PhysicalDeviceFragmentShadingRateEnumsFeaturesNV{
		PNext:                            (unsafe.Pointer)(s.pNext),
		FragmentShadingRateEnums:         translatePublic_Bool32(s.fragmentShadingRateEnums),         /*default*/
		SupersampleFragmentShadingRates:  translatePublic_Bool32(s.supersampleFragmentShadingRates),  /*default*/
		NoInvocationFragmentShadingRates: translatePublic_Bool32(s.noInvocationFragmentShadingRates), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentShadingRateEnumsFeaturesNV) Vulkanize() *_vkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                              /*cb*/
		fragmentShadingRateEnums:         translateInternal_Bool32(s.FragmentShadingRateEnums),                   /*default*/
		supersampleFragmentShadingRates:  translateInternal_Bool32(s.SupersampleFragmentShadingRates),            /*default*/
		noInvocationFragmentShadingRates: translateInternal_Bool32(s.NoInvocationFragmentShadingRates),           /*default*/
	}
	return rval
}

// PhysicalDeviceFragmentShadingRateEnumsPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html
type PhysicalDeviceFragmentShadingRateEnumsPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV
	PNext                                 unsafe.Pointer
	MaxFragmentShadingRateInvocationCount SampleCountFlagBits
}

type _vkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV struct {
	sType                                 StructureType
	pNext                                 unsafe.Pointer
	maxFragmentShadingRateInvocationCount SampleCountFlagBits
}

func (s *_vkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV) Goify() *PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
	rval := &PhysicalDeviceFragmentShadingRateEnumsPropertiesNV{
		PNext:                                 (unsafe.Pointer)(s.pNext),
		MaxFragmentShadingRateInvocationCount: (SampleCountFlagBits)(s.maxFragmentShadingRateInvocationCount),
	}
	return rval
}
func (s *PhysicalDeviceFragmentShadingRateEnumsPropertiesNV) Vulkanize() *_vkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV{
		sType:                                 STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV, /*c1*/
		pNext:                                 (unsafe.Pointer)(s.PNext),                                                /*cb*/
		maxFragmentShadingRateInvocationCount: (SampleCountFlagBits)(s.MaxFragmentShadingRateInvocationCount),           /*cb*/
	}
	return rval
}

// PhysicalDeviceFragmentShadingRateFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html
type PhysicalDeviceFragmentShadingRateFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR
	PNext                         unsafe.Pointer
	PipelineFragmentShadingRate   bool
	PrimitiveFragmentShadingRate  bool
	AttachmentFragmentShadingRate bool
}

type _vkPhysicalDeviceFragmentShadingRateFeaturesKHR struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	pipelineFragmentShadingRate   Bool32
	primitiveFragmentShadingRate  Bool32
	attachmentFragmentShadingRate Bool32
}

func (s *_vkPhysicalDeviceFragmentShadingRateFeaturesKHR) Goify() *PhysicalDeviceFragmentShadingRateFeaturesKHR {
	rval := &PhysicalDeviceFragmentShadingRateFeaturesKHR{
		PNext:                         (unsafe.Pointer)(s.pNext),
		PipelineFragmentShadingRate:   translatePublic_Bool32(s.pipelineFragmentShadingRate),   /*default*/
		PrimitiveFragmentShadingRate:  translatePublic_Bool32(s.primitiveFragmentShadingRate),  /*default*/
		AttachmentFragmentShadingRate: translatePublic_Bool32(s.attachmentFragmentShadingRate), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentShadingRateFeaturesKHR) Vulkanize() *_vkPhysicalDeviceFragmentShadingRateFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentShadingRateFeaturesKHR{
		sType:                         STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                         /*cb*/
		pipelineFragmentShadingRate:   translateInternal_Bool32(s.PipelineFragmentShadingRate),           /*default*/
		primitiveFragmentShadingRate:  translateInternal_Bool32(s.PrimitiveFragmentShadingRate),          /*default*/
		attachmentFragmentShadingRate: translateInternal_Bool32(s.AttachmentFragmentShadingRate),         /*default*/
	}
	return rval
}

// PhysicalDeviceFragmentShadingRateKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html
type PhysicalDeviceFragmentShadingRateKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR
	PNext        unsafe.Pointer
	SampleCounts SampleCountFlags
	FragmentSize Extent2D
}

// WARNING - struct PhysicalDeviceFragmentShadingRateKHR is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceFragmentShadingRateKHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	sampleCounts SampleCountFlags
	fragmentSize _vkExtent2D
}

func (s *_vkPhysicalDeviceFragmentShadingRateKHR) Goify() *PhysicalDeviceFragmentShadingRateKHR {
	rval := &PhysicalDeviceFragmentShadingRateKHR{
		PNext:        (unsafe.Pointer)(s.pNext),
		SampleCounts: (SampleCountFlags)(s.sampleCounts),
		FragmentSize: (Extent2D)(s.fragmentSize),
	}
	return rval
}
func (s *PhysicalDeviceFragmentShadingRateKHR) Vulkanize() *_vkPhysicalDeviceFragmentShadingRateKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentShadingRateKHR{
		sType:        STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                                /*cb*/
		sampleCounts: (SampleCountFlags)(s.SampleCounts),                       /*cb*/
		fragmentSize: (_vkExtent2D)(s.FragmentSize),                            /*cb*/
	}
	return rval
}

// PhysicalDeviceFragmentShadingRatePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html
type PhysicalDeviceFragmentShadingRatePropertiesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR
	PNext                                                unsafe.Pointer
	MinFragmentShadingRateAttachmentTexelSize            Extent2D
	MaxFragmentShadingRateAttachmentTexelSize            Extent2D
	MaxFragmentShadingRateAttachmentTexelSizeAspectRatio uint32
	PrimitiveFragmentShadingRateWithMultipleViewports    bool
	LayeredShadingRateAttachments                        bool
	FragmentShadingRateNonTrivialCombinerOps             bool
	MaxFragmentSize                                      Extent2D
	MaxFragmentSizeAspectRatio                           uint32
	MaxFragmentShadingRateCoverageSamples                uint32
	MaxFragmentShadingRateRasterizationSamples           SampleCountFlagBits
	FragmentShadingRateWithShaderDepthStencilWrites      bool
	FragmentShadingRateWithSampleMask                    bool
	FragmentShadingRateWithShaderSampleMask              bool
	FragmentShadingRateWithConservativeRasterization     bool
	FragmentShadingRateWithFragmentShaderInterlock       bool
	FragmentShadingRateWithCustomSampleLocations         bool
	FragmentShadingRateStrictMultiplyCombiner            bool
}

// WARNING - struct PhysicalDeviceFragmentShadingRatePropertiesKHR is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceFragmentShadingRatePropertiesKHR struct {
	sType                                                StructureType
	pNext                                                unsafe.Pointer
	minFragmentShadingRateAttachmentTexelSize            _vkExtent2D
	maxFragmentShadingRateAttachmentTexelSize            _vkExtent2D
	maxFragmentShadingRateAttachmentTexelSizeAspectRatio uint32
	primitiveFragmentShadingRateWithMultipleViewports    Bool32
	layeredShadingRateAttachments                        Bool32
	fragmentShadingRateNonTrivialCombinerOps             Bool32
	maxFragmentSize                                      _vkExtent2D
	maxFragmentSizeAspectRatio                           uint32
	maxFragmentShadingRateCoverageSamples                uint32
	maxFragmentShadingRateRasterizationSamples           SampleCountFlagBits
	fragmentShadingRateWithShaderDepthStencilWrites      Bool32
	fragmentShadingRateWithSampleMask                    Bool32
	fragmentShadingRateWithShaderSampleMask              Bool32
	fragmentShadingRateWithConservativeRasterization     Bool32
	fragmentShadingRateWithFragmentShaderInterlock       Bool32
	fragmentShadingRateWithCustomSampleLocations         Bool32
	fragmentShadingRateStrictMultiplyCombiner            Bool32
}

func (s *_vkPhysicalDeviceFragmentShadingRatePropertiesKHR) Goify() *PhysicalDeviceFragmentShadingRatePropertiesKHR {
	rval := &PhysicalDeviceFragmentShadingRatePropertiesKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		MinFragmentShadingRateAttachmentTexelSize:            (Extent2D)(s.minFragmentShadingRateAttachmentTexelSize),
		MaxFragmentShadingRateAttachmentTexelSize:            (Extent2D)(s.maxFragmentShadingRateAttachmentTexelSize),
		MaxFragmentShadingRateAttachmentTexelSizeAspectRatio: (uint32)(s.maxFragmentShadingRateAttachmentTexelSizeAspectRatio),
		PrimitiveFragmentShadingRateWithMultipleViewports:    translatePublic_Bool32(s.primitiveFragmentShadingRateWithMultipleViewports), /*default*/
		LayeredShadingRateAttachments:                        translatePublic_Bool32(s.layeredShadingRateAttachments),                     /*default*/
		FragmentShadingRateNonTrivialCombinerOps:             translatePublic_Bool32(s.fragmentShadingRateNonTrivialCombinerOps),          /*default*/
		MaxFragmentSize:                                      (Extent2D)(s.maxFragmentSize),
		MaxFragmentSizeAspectRatio:                           (uint32)(s.maxFragmentSizeAspectRatio),
		MaxFragmentShadingRateCoverageSamples:                (uint32)(s.maxFragmentShadingRateCoverageSamples),
		MaxFragmentShadingRateRasterizationSamples:           (SampleCountFlagBits)(s.maxFragmentShadingRateRasterizationSamples),
		FragmentShadingRateWithShaderDepthStencilWrites:      translatePublic_Bool32(s.fragmentShadingRateWithShaderDepthStencilWrites),  /*default*/
		FragmentShadingRateWithSampleMask:                    translatePublic_Bool32(s.fragmentShadingRateWithSampleMask),                /*default*/
		FragmentShadingRateWithShaderSampleMask:              translatePublic_Bool32(s.fragmentShadingRateWithShaderSampleMask),          /*default*/
		FragmentShadingRateWithConservativeRasterization:     translatePublic_Bool32(s.fragmentShadingRateWithConservativeRasterization), /*default*/
		FragmentShadingRateWithFragmentShaderInterlock:       translatePublic_Bool32(s.fragmentShadingRateWithFragmentShaderInterlock),   /*default*/
		FragmentShadingRateWithCustomSampleLocations:         translatePublic_Bool32(s.fragmentShadingRateWithCustomSampleLocations),     /*default*/
		FragmentShadingRateStrictMultiplyCombiner:            translatePublic_Bool32(s.fragmentShadingRateStrictMultiplyCombiner),        /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFragmentShadingRatePropertiesKHR) Vulkanize() *_vkPhysicalDeviceFragmentShadingRatePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFragmentShadingRatePropertiesKHR{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                           /*cb*/
		minFragmentShadingRateAttachmentTexelSize:            (_vkExtent2D)(s.MinFragmentShadingRateAttachmentTexelSize),                    /*cb*/
		maxFragmentShadingRateAttachmentTexelSize:            (_vkExtent2D)(s.MaxFragmentShadingRateAttachmentTexelSize),                    /*cb*/
		maxFragmentShadingRateAttachmentTexelSizeAspectRatio: (uint32)(s.MaxFragmentShadingRateAttachmentTexelSizeAspectRatio),              /*cb*/
		primitiveFragmentShadingRateWithMultipleViewports:    translateInternal_Bool32(s.PrimitiveFragmentShadingRateWithMultipleViewports), /*default*/
		layeredShadingRateAttachments:                        translateInternal_Bool32(s.LayeredShadingRateAttachments),                     /*default*/
		fragmentShadingRateNonTrivialCombinerOps:             translateInternal_Bool32(s.FragmentShadingRateNonTrivialCombinerOps),          /*default*/
		maxFragmentSize:                                      (_vkExtent2D)(s.MaxFragmentSize),                                              /*cb*/
		maxFragmentSizeAspectRatio:                           (uint32)(s.MaxFragmentSizeAspectRatio),                                        /*cb*/
		maxFragmentShadingRateCoverageSamples:                (uint32)(s.MaxFragmentShadingRateCoverageSamples),                             /*cb*/
		maxFragmentShadingRateRasterizationSamples:           (SampleCountFlagBits)(s.MaxFragmentShadingRateRasterizationSamples),           /*cb*/
		fragmentShadingRateWithShaderDepthStencilWrites:      translateInternal_Bool32(s.FragmentShadingRateWithShaderDepthStencilWrites),   /*default*/
		fragmentShadingRateWithSampleMask:                    translateInternal_Bool32(s.FragmentShadingRateWithSampleMask),                 /*default*/
		fragmentShadingRateWithShaderSampleMask:              translateInternal_Bool32(s.FragmentShadingRateWithShaderSampleMask),           /*default*/
		fragmentShadingRateWithConservativeRasterization:     translateInternal_Bool32(s.FragmentShadingRateWithConservativeRasterization),  /*default*/
		fragmentShadingRateWithFragmentShaderInterlock:       translateInternal_Bool32(s.FragmentShadingRateWithFragmentShaderInterlock),    /*default*/
		fragmentShadingRateWithCustomSampleLocations:         translateInternal_Bool32(s.FragmentShadingRateWithCustomSampleLocations),      /*default*/
		fragmentShadingRateStrictMultiplyCombiner:            translateInternal_Bool32(s.FragmentShadingRateStrictMultiplyCombiner),         /*default*/
	}
	return rval
}

// PhysicalDeviceFrameBoundaryFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFrameBoundaryFeaturesEXT.html
type PhysicalDeviceFrameBoundaryFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT
	PNext         unsafe.Pointer
	FrameBoundary bool
}

type _vkPhysicalDeviceFrameBoundaryFeaturesEXT struct {
	sType         StructureType
	pNext         unsafe.Pointer
	frameBoundary Bool32
}

func (s *_vkPhysicalDeviceFrameBoundaryFeaturesEXT) Goify() *PhysicalDeviceFrameBoundaryFeaturesEXT {
	rval := &PhysicalDeviceFrameBoundaryFeaturesEXT{
		PNext:         (unsafe.Pointer)(s.pNext),
		FrameBoundary: translatePublic_Bool32(s.frameBoundary), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceFrameBoundaryFeaturesEXT) Vulkanize() *_vkPhysicalDeviceFrameBoundaryFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceFrameBoundaryFeaturesEXT{
		sType:         STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                  /*cb*/
		frameBoundary: translateInternal_Bool32(s.FrameBoundary),                  /*default*/
	}
	return rval
}

// PhysicalDeviceGlobalPriorityQueryFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT.html
type PhysicalDeviceGlobalPriorityQueryFeaturesEXT struct {
}

type _vkPhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeaturesEXT

func (s *_vkPhysicalDeviceGlobalPriorityQueryFeaturesEXT) Goify() *PhysicalDeviceGlobalPriorityQueryFeaturesEXT {
	rval := (*PhysicalDeviceGlobalPriorityQueryFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceGlobalPriorityQueryFeaturesEXT) Vulkanize() *_vkPhysicalDeviceGlobalPriorityQueryFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceGlobalPriorityQueryFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.html
type PhysicalDeviceGlobalPriorityQueryFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR
	PNext               unsafe.Pointer
	GlobalPriorityQuery bool
}

type _vkPhysicalDeviceGlobalPriorityQueryFeaturesKHR struct {
	sType               StructureType
	pNext               unsafe.Pointer
	globalPriorityQuery Bool32
}

func (s *_vkPhysicalDeviceGlobalPriorityQueryFeaturesKHR) Goify() *PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
	rval := &PhysicalDeviceGlobalPriorityQueryFeaturesKHR{
		PNext:               (unsafe.Pointer)(s.pNext),
		GlobalPriorityQuery: translatePublic_Bool32(s.globalPriorityQuery), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceGlobalPriorityQueryFeaturesKHR) Vulkanize() *_vkPhysicalDeviceGlobalPriorityQueryFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceGlobalPriorityQueryFeaturesKHR{
		sType:               STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                         /*cb*/
		globalPriorityQuery: translateInternal_Bool32(s.GlobalPriorityQuery),                   /*default*/
	}
	return rval
}

// PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.html
type PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT
	PNext                   unsafe.Pointer
	GraphicsPipelineLibrary bool
}

type _vkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	graphicsPipelineLibrary Bool32
}

func (s *_vkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT) Goify() *PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
	rval := &PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		GraphicsPipelineLibrary: translatePublic_Bool32(s.graphicsPipelineLibrary), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT) Vulkanize() *_vkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                             /*cb*/
		graphicsPipelineLibrary: translateInternal_Bool32(s.GraphicsPipelineLibrary),                   /*default*/
	}
	return rval
}

// PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.html
type PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT
	PNext                                                     unsafe.Pointer
	GraphicsPipelineLibraryFastLinking                        bool
	GraphicsPipelineLibraryIndependentInterpolationDecoration bool
}

type _vkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT struct {
	sType                                                     StructureType
	pNext                                                     unsafe.Pointer
	graphicsPipelineLibraryFastLinking                        Bool32
	graphicsPipelineLibraryIndependentInterpolationDecoration Bool32
}

func (s *_vkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT) Goify() *PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
	rval := &PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT{
		PNext:                              (unsafe.Pointer)(s.pNext),
		GraphicsPipelineLibraryFastLinking: translatePublic_Bool32(s.graphicsPipelineLibraryFastLinking), /*default*/
		GraphicsPipelineLibraryIndependentInterpolationDecoration: translatePublic_Bool32(s.graphicsPipelineLibraryIndependentInterpolationDecoration), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT) Vulkanize() *_vkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT, /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                               /*cb*/
		graphicsPipelineLibraryFastLinking: translateInternal_Bool32(s.GraphicsPipelineLibraryFastLinking),          /*default*/
		graphicsPipelineLibraryIndependentInterpolationDecoration: translateInternal_Bool32(s.GraphicsPipelineLibraryIndependentInterpolationDecoration), /*default*/
	}
	return rval
}

// PhysicalDeviceGroupProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGroupProperties.html
type PhysicalDeviceGroupProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES
	PNext               unsafe.Pointer
	PhysicalDeviceCount uint32
	PhysicalDevices     [MAX_DEVICE_GROUP_SIZE]PhysicalDevice
	SubsetAllocation    bool
}

// WARNING - struct PhysicalDeviceGroupProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceGroupProperties struct {
	sType               StructureType
	pNext               unsafe.Pointer
	physicalDeviceCount uint32
	physicalDevices     [MAX_DEVICE_GROUP_SIZE]PhysicalDevice
	subsetAllocation    Bool32
}

func (s *_vkPhysicalDeviceGroupProperties) Goify() *PhysicalDeviceGroupProperties {
	rval := &PhysicalDeviceGroupProperties{
		PNext:               (unsafe.Pointer)(s.pNext),
		PhysicalDeviceCount: (uint32)(s.physicalDeviceCount),
		PhysicalDevices:     ([MAX_DEVICE_GROUP_SIZE]PhysicalDevice)(s.physicalDevices),
		SubsetAllocation:    translatePublic_Bool32(s.subsetAllocation), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceGroupProperties) Vulkanize() *_vkPhysicalDeviceGroupProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceGroupProperties{
		sType:               STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,            /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                  /*cb*/
		physicalDeviceCount: (uint32)(s.PhysicalDeviceCount),                            /*cb*/
		physicalDevices:     ([MAX_DEVICE_GROUP_SIZE]PhysicalDevice)(s.PhysicalDevices), /*cb*/
		subsetAllocation:    translateInternal_Bool32(s.SubsetAllocation),               /*default*/
	}
	return rval
}

// PhysicalDeviceGroupPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGroupPropertiesKHR.html
type PhysicalDeviceGroupPropertiesKHR struct {
}

type _vkPhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupPropertiesKHR

func (s *_vkPhysicalDeviceGroupPropertiesKHR) Goify() *PhysicalDeviceGroupPropertiesKHR {
	rval := (*PhysicalDeviceGroupPropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceGroupPropertiesKHR) Vulkanize() *_vkPhysicalDeviceGroupPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceGroupPropertiesKHR)(s)
	return rval
}

// PhysicalDeviceHostImageCopyFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceHostImageCopyFeaturesEXT.html
type PhysicalDeviceHostImageCopyFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT
	PNext         unsafe.Pointer
	HostImageCopy bool
}

type _vkPhysicalDeviceHostImageCopyFeaturesEXT struct {
	sType         StructureType
	pNext         unsafe.Pointer
	hostImageCopy Bool32
}

func (s *_vkPhysicalDeviceHostImageCopyFeaturesEXT) Goify() *PhysicalDeviceHostImageCopyFeaturesEXT {
	rval := &PhysicalDeviceHostImageCopyFeaturesEXT{
		PNext:         (unsafe.Pointer)(s.pNext),
		HostImageCopy: translatePublic_Bool32(s.hostImageCopy), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceHostImageCopyFeaturesEXT) Vulkanize() *_vkPhysicalDeviceHostImageCopyFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceHostImageCopyFeaturesEXT{
		sType:         STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                   /*cb*/
		hostImageCopy: translateInternal_Bool32(s.HostImageCopy),                   /*default*/
	}
	return rval
}

// PhysicalDeviceHostImageCopyPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceHostImageCopyPropertiesEXT.html
type PhysicalDeviceHostImageCopyPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT
	PNext unsafe.Pointer
	// copySrcLayoutCount
	PCopySrcLayouts []ImageLayout
	// copyDstLayoutCount
	PCopyDstLayouts                 []ImageLayout
	OptimalTilingLayoutUUID         [UUID_SIZE]uint8
	IdenticalMemoryTypeRequirements bool
}

type _vkPhysicalDeviceHostImageCopyPropertiesEXT struct {
	sType                           StructureType
	pNext                           unsafe.Pointer
	copySrcLayoutCount              uint32
	pCopySrcLayouts                 *ImageLayout
	copyDstLayoutCount              uint32
	pCopyDstLayouts                 *ImageLayout
	optimalTilingLayoutUUID         [UUID_SIZE]uint8
	identicalMemoryTypeRequirements Bool32
}

func (s *_vkPhysicalDeviceHostImageCopyPropertiesEXT) Goify() *PhysicalDeviceHostImageCopyPropertiesEXT {
	rval := &PhysicalDeviceHostImageCopyPropertiesEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCopySrcLayouts in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCopyDstLayouts in returned struct
		OptimalTilingLayoutUUID:         ([UUID_SIZE]uint8)(s.optimalTilingLayoutUUID),
		IdenticalMemoryTypeRequirements: translatePublic_Bool32(s.identicalMemoryTypeRequirements), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceHostImageCopyPropertiesEXT) Vulkanize() *_vkPhysicalDeviceHostImageCopyPropertiesEXT {
	if s == nil {
		return nil
	}

	var psl_pCopySrcLayouts *ImageLayout
	if len(s.PCopySrcLayouts) > 0 {
		psl_pCopySrcLayouts = &s.PCopySrcLayouts[0]
	}

	var psl_pCopyDstLayouts *ImageLayout
	if len(s.PCopyDstLayouts) > 0 {
		psl_pCopyDstLayouts = &s.PCopyDstLayouts[0]
	}
	rval := &_vkPhysicalDeviceHostImageCopyPropertiesEXT{
		sType:                           STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT, /*c1*/
		pNext:                           (unsafe.Pointer)(s.PNext),                                     /*cb*/
		copySrcLayoutCount:              uint32(len(s.PCopySrcLayouts)),                                /*c6-a*/
		pCopySrcLayouts:                 psl_pCopySrcLayouts,                                           /*c rem*/
		copyDstLayoutCount:              uint32(len(s.PCopyDstLayouts)),                                /*c6-a*/
		pCopyDstLayouts:                 psl_pCopyDstLayouts,                                           /*c rem*/
		optimalTilingLayoutUUID:         ([UUID_SIZE]uint8)(s.OptimalTilingLayoutUUID),                 /*cb*/
		identicalMemoryTypeRequirements: translateInternal_Bool32(s.IdenticalMemoryTypeRequirements),   /*default*/
	}
	return rval
}

// PhysicalDeviceHostQueryResetFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceHostQueryResetFeatures.html
type PhysicalDeviceHostQueryResetFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES
	PNext          unsafe.Pointer
	HostQueryReset bool
}

type _vkPhysicalDeviceHostQueryResetFeatures struct {
	sType          StructureType
	pNext          unsafe.Pointer
	hostQueryReset Bool32
}

func (s *_vkPhysicalDeviceHostQueryResetFeatures) Goify() *PhysicalDeviceHostQueryResetFeatures {
	rval := &PhysicalDeviceHostQueryResetFeatures{
		PNext:          (unsafe.Pointer)(s.pNext),
		HostQueryReset: translatePublic_Bool32(s.hostQueryReset), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceHostQueryResetFeatures) Vulkanize() *_vkPhysicalDeviceHostQueryResetFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceHostQueryResetFeatures{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                /*cb*/
		hostQueryReset: translateInternal_Bool32(s.HostQueryReset),               /*default*/
	}
	return rval
}

// PhysicalDeviceHostQueryResetFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceHostQueryResetFeaturesEXT.html
type PhysicalDeviceHostQueryResetFeaturesEXT struct {
}

type _vkPhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeaturesEXT

func (s *_vkPhysicalDeviceHostQueryResetFeaturesEXT) Goify() *PhysicalDeviceHostQueryResetFeaturesEXT {
	rval := (*PhysicalDeviceHostQueryResetFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceHostQueryResetFeaturesEXT) Vulkanize() *_vkPhysicalDeviceHostQueryResetFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceHostQueryResetFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceIDProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIDProperties.html
type PhysicalDeviceIDProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES
	PNext           unsafe.Pointer
	DeviceUUID      [UUID_SIZE]uint8
	DriverUUID      [UUID_SIZE]uint8
	DeviceLUID      [LUID_SIZE]uint8
	DeviceNodeMask  uint32
	DeviceLUIDValid bool
}

// WARNING - struct PhysicalDeviceIDProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceIDProperties struct {
	sType           StructureType
	pNext           unsafe.Pointer
	deviceUUID      [UUID_SIZE]uint8
	driverUUID      [UUID_SIZE]uint8
	deviceLUID      [LUID_SIZE]uint8
	deviceNodeMask  uint32
	deviceLUIDValid Bool32
}

func (s *_vkPhysicalDeviceIDProperties) Goify() *PhysicalDeviceIDProperties {
	rval := &PhysicalDeviceIDProperties{
		PNext:           (unsafe.Pointer)(s.pNext),
		DeviceUUID:      ([UUID_SIZE]uint8)(s.deviceUUID),
		DriverUUID:      ([UUID_SIZE]uint8)(s.driverUUID),
		DeviceLUID:      ([LUID_SIZE]uint8)(s.deviceLUID),
		DeviceNodeMask:  (uint32)(s.deviceNodeMask),
		DeviceLUIDValid: translatePublic_Bool32(s.deviceLUIDValid), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceIDProperties) Vulkanize() *_vkPhysicalDeviceIDProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceIDProperties{
		sType:           STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                    /*cb*/
		deviceUUID:      ([UUID_SIZE]uint8)(s.DeviceUUID),             /*cb*/
		driverUUID:      ([UUID_SIZE]uint8)(s.DriverUUID),             /*cb*/
		deviceLUID:      ([LUID_SIZE]uint8)(s.DeviceLUID),             /*cb*/
		deviceNodeMask:  (uint32)(s.DeviceNodeMask),                   /*cb*/
		deviceLUIDValid: translateInternal_Bool32(s.DeviceLUIDValid),  /*default*/
	}
	return rval
}

// PhysicalDeviceIDPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIDPropertiesKHR.html
type PhysicalDeviceIDPropertiesKHR struct {
}

type _vkPhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDPropertiesKHR

func (s *_vkPhysicalDeviceIDPropertiesKHR) Goify() *PhysicalDeviceIDPropertiesKHR {
	rval := (*PhysicalDeviceIDPropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceIDPropertiesKHR) Vulkanize() *_vkPhysicalDeviceIDPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceIDPropertiesKHR)(s)
	return rval
}

// PhysicalDeviceImage2DViewOf3DFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.html
type PhysicalDeviceImage2DViewOf3DFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT
	PNext             unsafe.Pointer
	Image2DViewOf3D   bool
	Sampler2DViewOf3D bool
}

type _vkPhysicalDeviceImage2DViewOf3DFeaturesEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	image2DViewOf3D   Bool32
	sampler2DViewOf3D Bool32
}

func (s *_vkPhysicalDeviceImage2DViewOf3DFeaturesEXT) Goify() *PhysicalDeviceImage2DViewOf3DFeaturesEXT {
	rval := &PhysicalDeviceImage2DViewOf3DFeaturesEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		Image2DViewOf3D:   translatePublic_Bool32(s.image2DViewOf3D),   /*default*/
		Sampler2DViewOf3D: translatePublic_Bool32(s.sampler2DViewOf3D), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceImage2DViewOf3DFeaturesEXT) Vulkanize() *_vkPhysicalDeviceImage2DViewOf3DFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImage2DViewOf3DFeaturesEXT{
		sType:             STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                       /*cb*/
		image2DViewOf3D:   translateInternal_Bool32(s.Image2DViewOf3D),                     /*default*/
		sampler2DViewOf3D: translateInternal_Bool32(s.Sampler2DViewOf3D),                   /*default*/
	}
	return rval
}

// PhysicalDeviceImageCompressionControlFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageCompressionControlFeaturesEXT.html
type PhysicalDeviceImageCompressionControlFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT
	PNext                   unsafe.Pointer
	ImageCompressionControl bool
}

type _vkPhysicalDeviceImageCompressionControlFeaturesEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	imageCompressionControl Bool32
}

func (s *_vkPhysicalDeviceImageCompressionControlFeaturesEXT) Goify() *PhysicalDeviceImageCompressionControlFeaturesEXT {
	rval := &PhysicalDeviceImageCompressionControlFeaturesEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		ImageCompressionControl: translatePublic_Bool32(s.imageCompressionControl), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceImageCompressionControlFeaturesEXT) Vulkanize() *_vkPhysicalDeviceImageCompressionControlFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageCompressionControlFeaturesEXT{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                             /*cb*/
		imageCompressionControl: translateInternal_Bool32(s.ImageCompressionControl),                   /*default*/
	}
	return rval
}

// PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.html
type PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT
	PNext                            unsafe.Pointer
	ImageCompressionControlSwapchain bool
}

type _vkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	imageCompressionControlSwapchain Bool32
}

func (s *_vkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT) Goify() *PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
	rval := &PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT{
		PNext:                            (unsafe.Pointer)(s.pNext),
		ImageCompressionControlSwapchain: translatePublic_Bool32(s.imageCompressionControlSwapchain), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT) Vulkanize() *_vkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                                       /*cb*/
		imageCompressionControlSwapchain: translateInternal_Bool32(s.ImageCompressionControlSwapchain),                    /*default*/
	}
	return rval
}

// PhysicalDeviceImageDrmFormatModifierInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html
type PhysicalDeviceImageDrmFormatModifierInfoEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT
	PNext             unsafe.Pointer
	DrmFormatModifier uint64
	SharingMode       SharingMode
	// queueFamilyIndexCount
	PQueueFamilyIndices []uint32
}

type _vkPhysicalDeviceImageDrmFormatModifierInfoEXT struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	drmFormatModifier     uint64
	sharingMode           SharingMode
	queueFamilyIndexCount uint32
	pQueueFamilyIndices   *uint32
}

func (s *_vkPhysicalDeviceImageDrmFormatModifierInfoEXT) Goify() *PhysicalDeviceImageDrmFormatModifierInfoEXT {
	rval := &PhysicalDeviceImageDrmFormatModifierInfoEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		DrmFormatModifier: (uint64)(s.drmFormatModifier),
		SharingMode:       (SharingMode)(s.sharingMode),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pQueueFamilyIndices in returned struct
	}
	return rval
}
func (s *PhysicalDeviceImageDrmFormatModifierInfoEXT) Vulkanize() *_vkPhysicalDeviceImageDrmFormatModifierInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pQueueFamilyIndices *uint32
	if len(s.PQueueFamilyIndices) > 0 {
		psl_pQueueFamilyIndices = &s.PQueueFamilyIndices[0]
	}
	rval := &_vkPhysicalDeviceImageDrmFormatModifierInfoEXT{
		sType:                 STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                         /*cb*/
		drmFormatModifier:     (uint64)(s.DrmFormatModifier),                                     /*cb*/
		sharingMode:           (SharingMode)(s.SharingMode),                                      /*cb*/
		queueFamilyIndexCount: uint32(len(s.PQueueFamilyIndices)),                                /*c6-a*/
		pQueueFamilyIndices:   psl_pQueueFamilyIndices,                                           /*c rem*/
	}
	return rval
}

// PhysicalDeviceImageFormatInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageFormatInfo2.html
type PhysicalDeviceImageFormatInfo2 struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2
	PNext  unsafe.Pointer
	Format Format
	Typ    ImageType
	Tiling ImageTiling
	Usage  ImageUsageFlags
	Flags  ImageCreateFlags
}

type _vkPhysicalDeviceImageFormatInfo2 struct {
	sType  StructureType
	pNext  unsafe.Pointer
	format Format
	typ    ImageType
	tiling ImageTiling
	usage  ImageUsageFlags
	flags  ImageCreateFlags
}

func (s *_vkPhysicalDeviceImageFormatInfo2) Goify() *PhysicalDeviceImageFormatInfo2 {
	rval := &PhysicalDeviceImageFormatInfo2{
		PNext:  (unsafe.Pointer)(s.pNext),
		Format: (Format)(s.format),
		Typ:    (ImageType)(s.typ),
		Tiling: (ImageTiling)(s.tiling),
		Usage:  (ImageUsageFlags)(s.usage),
		Flags:  (ImageCreateFlags)(s.flags),
	}
	return rval
}
func (s *PhysicalDeviceImageFormatInfo2) Vulkanize() *_vkPhysicalDeviceImageFormatInfo2 {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageFormatInfo2{
		sType:  STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                          /*cb*/
		format: (Format)(s.Format),                                 /*cb*/
		typ:    (ImageType)(s.Typ),                                 /*cb*/
		tiling: (ImageTiling)(s.Tiling),                            /*cb*/
		usage:  (ImageUsageFlags)(s.Usage),                         /*cb*/
		flags:  (ImageCreateFlags)(s.Flags),                        /*cb*/
	}
	return rval
}

// PhysicalDeviceImageFormatInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageFormatInfo2KHR.html
type PhysicalDeviceImageFormatInfo2KHR struct {
}

type _vkPhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2KHR

func (s *_vkPhysicalDeviceImageFormatInfo2KHR) Goify() *PhysicalDeviceImageFormatInfo2KHR {
	rval := (*PhysicalDeviceImageFormatInfo2KHR)(s)
	return rval
}
func (s *PhysicalDeviceImageFormatInfo2KHR) Vulkanize() *_vkPhysicalDeviceImageFormatInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceImageFormatInfo2KHR)(s)
	return rval
}

// PhysicalDeviceImageProcessing2FeaturesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageProcessing2FeaturesQCOM.html
type PhysicalDeviceImageProcessing2FeaturesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM
	PNext              unsafe.Pointer
	TextureBlockMatch2 bool
}

type _vkPhysicalDeviceImageProcessing2FeaturesQCOM struct {
	sType              StructureType
	pNext              unsafe.Pointer
	textureBlockMatch2 Bool32
}

func (s *_vkPhysicalDeviceImageProcessing2FeaturesQCOM) Goify() *PhysicalDeviceImageProcessing2FeaturesQCOM {
	rval := &PhysicalDeviceImageProcessing2FeaturesQCOM{
		PNext:              (unsafe.Pointer)(s.pNext),
		TextureBlockMatch2: translatePublic_Bool32(s.textureBlockMatch2), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceImageProcessing2FeaturesQCOM) Vulkanize() *_vkPhysicalDeviceImageProcessing2FeaturesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageProcessing2FeaturesQCOM{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                       /*cb*/
		textureBlockMatch2: translateInternal_Bool32(s.TextureBlockMatch2),                  /*default*/
	}
	return rval
}

// PhysicalDeviceImageProcessing2PropertiesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageProcessing2PropertiesQCOM.html
type PhysicalDeviceImageProcessing2PropertiesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM
	PNext               unsafe.Pointer
	MaxBlockMatchWindow Extent2D
}

// WARNING - struct PhysicalDeviceImageProcessing2PropertiesQCOM is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceImageProcessing2PropertiesQCOM struct {
	sType               StructureType
	pNext               unsafe.Pointer
	maxBlockMatchWindow _vkExtent2D
}

func (s *_vkPhysicalDeviceImageProcessing2PropertiesQCOM) Goify() *PhysicalDeviceImageProcessing2PropertiesQCOM {
	rval := &PhysicalDeviceImageProcessing2PropertiesQCOM{
		PNext:               (unsafe.Pointer)(s.pNext),
		MaxBlockMatchWindow: (Extent2D)(s.maxBlockMatchWindow),
	}
	return rval
}
func (s *PhysicalDeviceImageProcessing2PropertiesQCOM) Vulkanize() *_vkPhysicalDeviceImageProcessing2PropertiesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageProcessing2PropertiesQCOM{
		sType:               STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                         /*cb*/
		maxBlockMatchWindow: (_vkExtent2D)(s.MaxBlockMatchWindow),                              /*cb*/
	}
	return rval
}

// PhysicalDeviceImageProcessingFeaturesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageProcessingFeaturesQCOM.html
type PhysicalDeviceImageProcessingFeaturesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM
	PNext                 unsafe.Pointer
	TextureSampleWeighted bool
	TextureBoxFilter      bool
	TextureBlockMatch     bool
}

type _vkPhysicalDeviceImageProcessingFeaturesQCOM struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	textureSampleWeighted Bool32
	textureBoxFilter      Bool32
	textureBlockMatch     Bool32
}

func (s *_vkPhysicalDeviceImageProcessingFeaturesQCOM) Goify() *PhysicalDeviceImageProcessingFeaturesQCOM {
	rval := &PhysicalDeviceImageProcessingFeaturesQCOM{
		PNext:                 (unsafe.Pointer)(s.pNext),
		TextureSampleWeighted: translatePublic_Bool32(s.textureSampleWeighted), /*default*/
		TextureBoxFilter:      translatePublic_Bool32(s.textureBoxFilter),      /*default*/
		TextureBlockMatch:     translatePublic_Bool32(s.textureBlockMatch),     /*default*/
	}
	return rval
}
func (s *PhysicalDeviceImageProcessingFeaturesQCOM) Vulkanize() *_vkPhysicalDeviceImageProcessingFeaturesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageProcessingFeaturesQCOM{
		sType:                 STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                     /*cb*/
		textureSampleWeighted: translateInternal_Bool32(s.TextureSampleWeighted),             /*default*/
		textureBoxFilter:      translateInternal_Bool32(s.TextureBoxFilter),                  /*default*/
		textureBlockMatch:     translateInternal_Bool32(s.TextureBlockMatch),                 /*default*/
	}
	return rval
}

// PhysicalDeviceImageProcessingPropertiesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageProcessingPropertiesQCOM.html
type PhysicalDeviceImageProcessingPropertiesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM
	PNext                    unsafe.Pointer
	MaxWeightFilterPhases    uint32
	MaxWeightFilterDimension Extent2D
	MaxBlockMatchRegion      Extent2D
	MaxBoxFilterBlockSize    Extent2D
}

// WARNING - struct PhysicalDeviceImageProcessingPropertiesQCOM is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceImageProcessingPropertiesQCOM struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	maxWeightFilterPhases    uint32
	maxWeightFilterDimension _vkExtent2D
	maxBlockMatchRegion      _vkExtent2D
	maxBoxFilterBlockSize    _vkExtent2D
}

func (s *_vkPhysicalDeviceImageProcessingPropertiesQCOM) Goify() *PhysicalDeviceImageProcessingPropertiesQCOM {
	rval := &PhysicalDeviceImageProcessingPropertiesQCOM{
		PNext:                    (unsafe.Pointer)(s.pNext),
		MaxWeightFilterPhases:    (uint32)(s.maxWeightFilterPhases),
		MaxWeightFilterDimension: (Extent2D)(s.maxWeightFilterDimension),
		MaxBlockMatchRegion:      (Extent2D)(s.maxBlockMatchRegion),
		MaxBoxFilterBlockSize:    (Extent2D)(s.maxBoxFilterBlockSize),
	}
	return rval
}
func (s *PhysicalDeviceImageProcessingPropertiesQCOM) Vulkanize() *_vkPhysicalDeviceImageProcessingPropertiesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageProcessingPropertiesQCOM{
		sType:                    STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                       /*cb*/
		maxWeightFilterPhases:    (uint32)(s.MaxWeightFilterPhases),                               /*cb*/
		maxWeightFilterDimension: (_vkExtent2D)(s.MaxWeightFilterDimension),                       /*cb*/
		maxBlockMatchRegion:      (_vkExtent2D)(s.MaxBlockMatchRegion),                            /*cb*/
		maxBoxFilterBlockSize:    (_vkExtent2D)(s.MaxBoxFilterBlockSize),                          /*cb*/
	}
	return rval
}

// PhysicalDeviceImageRobustnessFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageRobustnessFeaturesEXT.html
type PhysicalDeviceImageRobustnessFeaturesEXT struct {
}

type _vkPhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeaturesEXT

func (s *_vkPhysicalDeviceImageRobustnessFeaturesEXT) Goify() *PhysicalDeviceImageRobustnessFeaturesEXT {
	rval := (*PhysicalDeviceImageRobustnessFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceImageRobustnessFeaturesEXT) Vulkanize() *_vkPhysicalDeviceImageRobustnessFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceImageRobustnessFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceImageSlicedViewOf3DFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.html
type PhysicalDeviceImageSlicedViewOf3DFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT
	PNext               unsafe.Pointer
	ImageSlicedViewOf3D bool
}

type _vkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT struct {
	sType               StructureType
	pNext               unsafe.Pointer
	imageSlicedViewOf3D Bool32
}

func (s *_vkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT) Goify() *PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
	rval := &PhysicalDeviceImageSlicedViewOf3DFeaturesEXT{
		PNext:               (unsafe.Pointer)(s.pNext),
		ImageSlicedViewOf3D: translatePublic_Bool32(s.imageSlicedViewOf3D), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceImageSlicedViewOf3DFeaturesEXT) Vulkanize() *_vkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT{
		sType:               STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                           /*cb*/
		imageSlicedViewOf3D: translateInternal_Bool32(s.ImageSlicedViewOf3D),                     /*default*/
	}
	return rval
}

// PhysicalDeviceImageViewImageFormatInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html
type PhysicalDeviceImageViewImageFormatInfoEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT
	PNext         unsafe.Pointer
	ImageViewType ImageViewType
}

type _vkPhysicalDeviceImageViewImageFormatInfoEXT struct {
	sType         StructureType
	pNext         unsafe.Pointer
	imageViewType ImageViewType
}

func (s *_vkPhysicalDeviceImageViewImageFormatInfoEXT) Goify() *PhysicalDeviceImageViewImageFormatInfoEXT {
	rval := &PhysicalDeviceImageViewImageFormatInfoEXT{
		PNext:         (unsafe.Pointer)(s.pNext),
		ImageViewType: (ImageViewType)(s.imageViewType),
	}
	return rval
}
func (s *PhysicalDeviceImageViewImageFormatInfoEXT) Vulkanize() *_vkPhysicalDeviceImageViewImageFormatInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageViewImageFormatInfoEXT{
		sType:         STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                       /*cb*/
		imageViewType: (ImageViewType)(s.ImageViewType),                                /*cb*/
	}
	return rval
}

// PhysicalDeviceImageViewMinLodFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewMinLodFeaturesEXT.html
type PhysicalDeviceImageViewMinLodFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT
	PNext  unsafe.Pointer
	MinLod bool
}

type _vkPhysicalDeviceImageViewMinLodFeaturesEXT struct {
	sType  StructureType
	pNext  unsafe.Pointer
	minLod Bool32
}

func (s *_vkPhysicalDeviceImageViewMinLodFeaturesEXT) Goify() *PhysicalDeviceImageViewMinLodFeaturesEXT {
	rval := &PhysicalDeviceImageViewMinLodFeaturesEXT{
		PNext:  (unsafe.Pointer)(s.pNext),
		MinLod: translatePublic_Bool32(s.minLod), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceImageViewMinLodFeaturesEXT) Vulkanize() *_vkPhysicalDeviceImageViewMinLodFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImageViewMinLodFeaturesEXT{
		sType:  STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                                      /*cb*/
		minLod: translateInternal_Bool32(s.MinLod),                             /*default*/
	}
	return rval
}

// PhysicalDeviceImagelessFramebufferFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html
type PhysicalDeviceImagelessFramebufferFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES
	PNext                unsafe.Pointer
	ImagelessFramebuffer bool
}

type _vkPhysicalDeviceImagelessFramebufferFeatures struct {
	sType                StructureType
	pNext                unsafe.Pointer
	imagelessFramebuffer Bool32
}

func (s *_vkPhysicalDeviceImagelessFramebufferFeatures) Goify() *PhysicalDeviceImagelessFramebufferFeatures {
	rval := &PhysicalDeviceImagelessFramebufferFeatures{
		PNext:                (unsafe.Pointer)(s.pNext),
		ImagelessFramebuffer: translatePublic_Bool32(s.imagelessFramebuffer), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceImagelessFramebufferFeatures) Vulkanize() *_vkPhysicalDeviceImagelessFramebufferFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceImagelessFramebufferFeatures{
		sType:                STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                     /*cb*/
		imagelessFramebuffer: translateInternal_Bool32(s.ImagelessFramebuffer),              /*default*/
	}
	return rval
}

// PhysicalDeviceImagelessFramebufferFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImagelessFramebufferFeaturesKHR.html
type PhysicalDeviceImagelessFramebufferFeaturesKHR struct {
}

type _vkPhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeaturesKHR

func (s *_vkPhysicalDeviceImagelessFramebufferFeaturesKHR) Goify() *PhysicalDeviceImagelessFramebufferFeaturesKHR {
	rval := (*PhysicalDeviceImagelessFramebufferFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceImagelessFramebufferFeaturesKHR) Vulkanize() *_vkPhysicalDeviceImagelessFramebufferFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceImagelessFramebufferFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceIndexTypeUint8FeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html
type PhysicalDeviceIndexTypeUint8FeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT
	PNext          unsafe.Pointer
	IndexTypeUint8 bool
}

type _vkPhysicalDeviceIndexTypeUint8FeaturesEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	indexTypeUint8 Bool32
}

func (s *_vkPhysicalDeviceIndexTypeUint8FeaturesEXT) Goify() *PhysicalDeviceIndexTypeUint8FeaturesEXT {
	rval := &PhysicalDeviceIndexTypeUint8FeaturesEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		IndexTypeUint8: translatePublic_Bool32(s.indexTypeUint8), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceIndexTypeUint8FeaturesEXT) Vulkanize() *_vkPhysicalDeviceIndexTypeUint8FeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceIndexTypeUint8FeaturesEXT{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                    /*cb*/
		indexTypeUint8: translateInternal_Bool32(s.IndexTypeUint8),                   /*default*/
	}
	return rval
}

// PhysicalDeviceInheritedViewportScissorFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html
type PhysicalDeviceInheritedViewportScissorFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV
	PNext                      unsafe.Pointer
	InheritedViewportScissor2D bool
}

type _vkPhysicalDeviceInheritedViewportScissorFeaturesNV struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	inheritedViewportScissor2D Bool32
}

func (s *_vkPhysicalDeviceInheritedViewportScissorFeaturesNV) Goify() *PhysicalDeviceInheritedViewportScissorFeaturesNV {
	rval := &PhysicalDeviceInheritedViewportScissorFeaturesNV{
		PNext:                      (unsafe.Pointer)(s.pNext),
		InheritedViewportScissor2D: translatePublic_Bool32(s.inheritedViewportScissor2D), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceInheritedViewportScissorFeaturesNV) Vulkanize() *_vkPhysicalDeviceInheritedViewportScissorFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceInheritedViewportScissorFeaturesNV{
		sType:                      STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                             /*cb*/
		inheritedViewportScissor2D: translateInternal_Bool32(s.InheritedViewportScissor2D),                /*default*/
	}
	return rval
}

// PhysicalDeviceInlineUniformBlockFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeaturesEXT.html
type PhysicalDeviceInlineUniformBlockFeaturesEXT struct {
}

type _vkPhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeaturesEXT

func (s *_vkPhysicalDeviceInlineUniformBlockFeaturesEXT) Goify() *PhysicalDeviceInlineUniformBlockFeaturesEXT {
	rval := (*PhysicalDeviceInlineUniformBlockFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceInlineUniformBlockFeaturesEXT) Vulkanize() *_vkPhysicalDeviceInlineUniformBlockFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceInlineUniformBlockFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceInlineUniformBlockPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html
type PhysicalDeviceInlineUniformBlockPropertiesEXT struct {
}

type _vkPhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockPropertiesEXT

func (s *_vkPhysicalDeviceInlineUniformBlockPropertiesEXT) Goify() *PhysicalDeviceInlineUniformBlockPropertiesEXT {
	rval := (*PhysicalDeviceInlineUniformBlockPropertiesEXT)(s)
	return rval
}
func (s *PhysicalDeviceInlineUniformBlockPropertiesEXT) Vulkanize() *_vkPhysicalDeviceInlineUniformBlockPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceInlineUniformBlockPropertiesEXT)(s)
	return rval
}

// PhysicalDeviceInvocationMaskFeaturesHUAWEI: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html
type PhysicalDeviceInvocationMaskFeaturesHUAWEI struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI
	PNext          unsafe.Pointer
	InvocationMask bool
}

type _vkPhysicalDeviceInvocationMaskFeaturesHUAWEI struct {
	sType          StructureType
	pNext          unsafe.Pointer
	invocationMask Bool32
}

func (s *_vkPhysicalDeviceInvocationMaskFeaturesHUAWEI) Goify() *PhysicalDeviceInvocationMaskFeaturesHUAWEI {
	rval := &PhysicalDeviceInvocationMaskFeaturesHUAWEI{
		PNext:          (unsafe.Pointer)(s.pNext),
		InvocationMask: translatePublic_Bool32(s.invocationMask), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceInvocationMaskFeaturesHUAWEI) Vulkanize() *_vkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceInvocationMaskFeaturesHUAWEI{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                      /*cb*/
		invocationMask: translateInternal_Bool32(s.InvocationMask),                     /*default*/
	}
	return rval
}

// PhysicalDeviceLayeredDriverPropertiesMSFT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLayeredDriverPropertiesMSFT.html
type PhysicalDeviceLayeredDriverPropertiesMSFT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT
	PNext         unsafe.Pointer
	UnderlyingAPI LayeredDriverUnderlyingApiMSFT
}

// WARNING - struct PhysicalDeviceLayeredDriverPropertiesMSFT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceLayeredDriverPropertiesMSFT struct {
	sType         StructureType
	pNext         unsafe.Pointer
	underlyingAPI LayeredDriverUnderlyingApiMSFT
}

func (s *_vkPhysicalDeviceLayeredDriverPropertiesMSFT) Goify() *PhysicalDeviceLayeredDriverPropertiesMSFT {
	rval := &PhysicalDeviceLayeredDriverPropertiesMSFT{
		PNext:         (unsafe.Pointer)(s.pNext),
		UnderlyingAPI: (LayeredDriverUnderlyingApiMSFT)(s.underlyingAPI),
	}
	return rval
}
func (s *PhysicalDeviceLayeredDriverPropertiesMSFT) Vulkanize() *_vkPhysicalDeviceLayeredDriverPropertiesMSFT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceLayeredDriverPropertiesMSFT{
		sType:         STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                     /*cb*/
		underlyingAPI: (LayeredDriverUnderlyingApiMSFT)(s.UnderlyingAPI),             /*cb*/
	}
	return rval
}

// PhysicalDeviceLegacyDitheringFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLegacyDitheringFeaturesEXT.html
type PhysicalDeviceLegacyDitheringFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT
	PNext           unsafe.Pointer
	LegacyDithering bool
}

type _vkPhysicalDeviceLegacyDitheringFeaturesEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	legacyDithering Bool32
}

func (s *_vkPhysicalDeviceLegacyDitheringFeaturesEXT) Goify() *PhysicalDeviceLegacyDitheringFeaturesEXT {
	rval := &PhysicalDeviceLegacyDitheringFeaturesEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		LegacyDithering: translatePublic_Bool32(s.legacyDithering), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceLegacyDitheringFeaturesEXT) Vulkanize() *_vkPhysicalDeviceLegacyDitheringFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceLegacyDitheringFeaturesEXT{
		sType:           STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                    /*cb*/
		legacyDithering: translateInternal_Bool32(s.LegacyDithering),                  /*default*/
	}
	return rval
}

// PhysicalDeviceLimits: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLimits.html
type PhysicalDeviceLimits struct {
	//  max 1D image dimension;
	MaxImageDimension1D uint32
	//  max 2D image dimension;
	MaxImageDimension2D uint32
	//  max 3D image dimension;
	MaxImageDimension3D uint32
	//  max cubemap image dimension;
	MaxImageDimensionCube uint32
	//  max layers for image arrays;
	MaxImageArrayLayers uint32
	//  max texel buffer size (fstexels);
	MaxTexelBufferElements uint32
	//  max uniform buffer range (bytes);
	MaxUniformBufferRange uint32
	//  max storage buffer range (bytes);
	MaxStorageBufferRange uint32
	//  max size of the push constants pool (bytes);
	MaxPushConstantsSize uint32
	//  max number of device memory allocations supported;
	MaxMemoryAllocationCount uint32
	//  max number of samplers that can be allocated on a device;
	MaxSamplerAllocationCount uint32
	//  Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage;
	BufferImageGranularity DeviceSize
	//  Total address space available for sparse allocations (bytes);
	SparseAddressSpaceSize DeviceSize
	//  max number of descriptors sets that can be bound to a pipeline;
	MaxBoundDescriptorSets uint32
	//  max number of samplers allowed per-stage in a descriptor set;
	MaxPerStageDescriptorSamplers uint32
	//  max number of uniform buffers allowed per-stage in a descriptor set;
	MaxPerStageDescriptorUniformBuffers uint32
	//  max number of storage buffers allowed per-stage in a descriptor set;
	MaxPerStageDescriptorStorageBuffers uint32
	//  max number of sampled images allowed per-stage in a descriptor set;
	MaxPerStageDescriptorSampledImages uint32
	//  max number of storage images allowed per-stage in a descriptor set;
	MaxPerStageDescriptorStorageImages uint32
	//  max number of input attachments allowed per-stage in a descriptor set;
	MaxPerStageDescriptorInputAttachments uint32
	//  max number of resources allowed by a single stage;
	MaxPerStageResources uint32
	//  max number of samplers allowed in all stages in a descriptor set;
	MaxDescriptorSetSamplers uint32
	//  max number of uniform buffers allowed in all stages in a descriptor set;
	MaxDescriptorSetUniformBuffers uint32
	//  max number of dynamic uniform buffers allowed in all stages in a descriptor set;
	MaxDescriptorSetUniformBuffersDynamic uint32
	//  max number of storage buffers allowed in all stages in a descriptor set;
	MaxDescriptorSetStorageBuffers uint32
	//  max number of dynamic storage buffers allowed in all stages in a descriptor set;
	MaxDescriptorSetStorageBuffersDynamic uint32
	//  max number of sampled images allowed in all stages in a descriptor set;
	MaxDescriptorSetSampledImages uint32
	//  max number of storage images allowed in all stages in a descriptor set;
	MaxDescriptorSetStorageImages uint32
	//  max number of input attachments allowed in all stages in a descriptor set;
	MaxDescriptorSetInputAttachments uint32
	//  max number of vertex input attribute slots;
	MaxVertexInputAttributes uint32
	//  max number of vertex input binding slots;
	MaxVertexInputBindings uint32
	//  max vertex input attribute offset added to vertex buffer offset;
	MaxVertexInputAttributeOffset uint32
	//  max vertex input binding stride;
	MaxVertexInputBindingStride uint32
	//  max number of output components written by vertex shader;
	MaxVertexOutputComponents uint32
	//  max level supported by tessellation primitive generator;
	MaxTessellationGenerationLevel uint32
	//  max patch size (vertices);
	MaxTessellationPatchSize uint32
	//  max number of input components per-vertex in TCS;
	MaxTessellationControlPerVertexInputComponents uint32
	//  max number of output components per-vertex in TCS;
	MaxTessellationControlPerVertexOutputComponents uint32
	//  max number of output components per-patch in TCS;
	MaxTessellationControlPerPatchOutputComponents uint32
	//  max total number of per-vertex and per-patch output components in TCS;
	MaxTessellationControlTotalOutputComponents uint32
	//  max number of input components per vertex in TES;
	MaxTessellationEvaluationInputComponents uint32
	//  max number of output components per vertex in TES;
	MaxTessellationEvaluationOutputComponents uint32
	//  max invocation count supported in geometry shader;
	MaxGeometryShaderInvocations uint32
	//  max number of input components read in geometry stage;
	MaxGeometryInputComponents uint32
	//  max number of output components written in geometry stage;
	MaxGeometryOutputComponents uint32
	//  max number of vertices that can be emitted in geometry stage;
	MaxGeometryOutputVertices uint32
	//  max total number of components (all vertices) written in geometry stage;
	MaxGeometryTotalOutputComponents uint32
	//  max number of input components read in fragment stage;
	MaxFragmentInputComponents uint32
	//  max number of output attachments written in fragment stage;
	MaxFragmentOutputAttachments uint32
	//  max number of output attachments written when using dual source blending;
	MaxFragmentDualSrcAttachments uint32
	//  max total number of storage buffers, storage images and output buffers;
	MaxFragmentCombinedOutputResources uint32
	//  max total storage size of work group local storage (bytes);
	MaxComputeSharedMemorySize uint32
	//  max num of compute work groups that may be dispatched by a single command (x,y,z);
	MaxComputeWorkGroupCount [3]uint32
	//  max total compute invocations in a single local work group;
	MaxComputeWorkGroupInvocations uint32
	//  max local size of a compute work group (x,y,z);
	MaxComputeWorkGroupSize [3]uint32
	//  number bits of subpixel precision in screen x and y;
	SubPixelPrecisionBits uint32
	//  number bits of precision for selecting texel weights;
	SubTexelPrecisionBits uint32
	//  number bits of precision for selecting mipmap weights;
	MipmapPrecisionBits uint32
	//  max index value for indexed draw calls (for 32-bit indices);
	MaxDrawIndexedIndexValue uint32
	//  max draw count for indirect drawing calls;
	MaxDrawIndirectCount uint32
	//  max absolute sampler LOD bias;
	MaxSamplerLodBias float32
	//  max degree of sampler anisotropy;
	MaxSamplerAnisotropy float32
	//  max number of active viewports;
	MaxViewports uint32
	//  max viewport dimensions (x,y);
	MaxViewportDimensions [2]uint32
	//  viewport bounds range (min,max);
	ViewportBoundsRange [2]float32
	//  number bits of subpixel precision for viewport;
	ViewportSubPixelBits uint32
	//  min required alignment of pointers returned by MapMemory (bytes);
	MinMemoryMapAlignment uintptr
	//  min required alignment for texel buffer offsets (bytes) ;
	MinTexelBufferOffsetAlignment DeviceSize
	//  min required alignment for uniform buffer sizes and offsets (bytes);
	MinUniformBufferOffsetAlignment DeviceSize
	//  min required alignment for storage buffer offsets (bytes);
	MinStorageBufferOffsetAlignment DeviceSize
	//  min texel offset for OpTextureSampleOffset;
	MinTexelOffset int32
	//  max texel offset for OpTextureSampleOffset;
	MaxTexelOffset uint32
	//  min texel offset for OpTextureGatherOffset;
	MinTexelGatherOffset int32
	//  max texel offset for OpTextureGatherOffset;
	MaxTexelGatherOffset uint32
	//  furthest negative offset for interpolateAtOffset;
	MinInterpolationOffset float32
	//  furthest positive offset for interpolateAtOffset;
	MaxInterpolationOffset float32
	//  number of subpixel bits for interpolateAtOffset;
	SubPixelInterpolationOffsetBits uint32
	//  max width for a framebuffer;
	MaxFramebufferWidth uint32
	//  max height for a framebuffer;
	MaxFramebufferHeight uint32
	//  max layer count for a layered framebuffer;
	MaxFramebufferLayers uint32
	//  supported color sample counts for a framebuffer;
	FramebufferColorSampleCounts SampleCountFlags
	//  supported depth sample counts for a framebuffer;
	FramebufferDepthSampleCounts SampleCountFlags
	//  supported stencil sample counts for a framebuffer;
	FramebufferStencilSampleCounts SampleCountFlags
	//  supported sample counts for a subpass which uses no attachments;
	FramebufferNoAttachmentsSampleCounts SampleCountFlags
	//  max number of color attachments per subpass;
	MaxColorAttachments uint32
	//  supported color sample counts for a non-integer sampled image;
	SampledImageColorSampleCounts SampleCountFlags
	//  supported sample counts for an integer image;
	SampledImageIntegerSampleCounts SampleCountFlags
	//  supported depth sample counts for a sampled image;
	SampledImageDepthSampleCounts SampleCountFlags
	//  supported stencil sample counts for a sampled image;
	SampledImageStencilSampleCounts SampleCountFlags
	//  supported sample counts for a storage image;
	StorageImageSampleCounts SampleCountFlags
	//  max number of sample mask words;
	MaxSampleMaskWords uint32
	//  timestamps on graphics and compute queues;
	TimestampComputeAndGraphics bool
	//  number of nanoseconds it takes for timestamp query value to increment by 1;
	TimestampPeriod float32
	//  max number of clip distances;
	MaxClipDistances uint32
	//  max number of cull distances;
	MaxCullDistances uint32
	//  max combined number of user clipping;
	MaxCombinedClipAndCullDistances uint32
	//  distinct queue priorities available ;
	DiscreteQueuePriorities uint32
	//  range (min,max) of supported point sizes;
	PointSizeRange [2]float32
	//  range (min,max) of supported line widths;
	LineWidthRange [2]float32
	//  granularity of supported point sizes;
	PointSizeGranularity float32
	//  granularity of supported line widths;
	LineWidthGranularity float32
	//  line rasterization follows preferred rules;
	StrictLines bool
	//  supports standard sample locations for all supported sample counts;
	StandardSampleLocations bool
	//  optimal offset of buffer copies;
	OptimalBufferCopyOffsetAlignment DeviceSize
	//  optimal pitch of buffer copies;
	OptimalBufferCopyRowPitchAlignment DeviceSize
	//  minimum size and alignment for non-coherent host-mapped device memory access;
	NonCoherentAtomSize DeviceSize
}

// WARNING - struct PhysicalDeviceLimits is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceLimits struct {
	maxImageDimension1D                             uint32
	maxImageDimension2D                             uint32
	maxImageDimension3D                             uint32
	maxImageDimensionCube                           uint32
	maxImageArrayLayers                             uint32
	maxTexelBufferElements                          uint32
	maxUniformBufferRange                           uint32
	maxStorageBufferRange                           uint32
	maxPushConstantsSize                            uint32
	maxMemoryAllocationCount                        uint32
	maxSamplerAllocationCount                       uint32
	bufferImageGranularity                          DeviceSize
	sparseAddressSpaceSize                          DeviceSize
	maxBoundDescriptorSets                          uint32
	maxPerStageDescriptorSamplers                   uint32
	maxPerStageDescriptorUniformBuffers             uint32
	maxPerStageDescriptorStorageBuffers             uint32
	maxPerStageDescriptorSampledImages              uint32
	maxPerStageDescriptorStorageImages              uint32
	maxPerStageDescriptorInputAttachments           uint32
	maxPerStageResources                            uint32
	maxDescriptorSetSamplers                        uint32
	maxDescriptorSetUniformBuffers                  uint32
	maxDescriptorSetUniformBuffersDynamic           uint32
	maxDescriptorSetStorageBuffers                  uint32
	maxDescriptorSetStorageBuffersDynamic           uint32
	maxDescriptorSetSampledImages                   uint32
	maxDescriptorSetStorageImages                   uint32
	maxDescriptorSetInputAttachments                uint32
	maxVertexInputAttributes                        uint32
	maxVertexInputBindings                          uint32
	maxVertexInputAttributeOffset                   uint32
	maxVertexInputBindingStride                     uint32
	maxVertexOutputComponents                       uint32
	maxTessellationGenerationLevel                  uint32
	maxTessellationPatchSize                        uint32
	maxTessellationControlPerVertexInputComponents  uint32
	maxTessellationControlPerVertexOutputComponents uint32
	maxTessellationControlPerPatchOutputComponents  uint32
	maxTessellationControlTotalOutputComponents     uint32
	maxTessellationEvaluationInputComponents        uint32
	maxTessellationEvaluationOutputComponents       uint32
	maxGeometryShaderInvocations                    uint32
	maxGeometryInputComponents                      uint32
	maxGeometryOutputComponents                     uint32
	maxGeometryOutputVertices                       uint32
	maxGeometryTotalOutputComponents                uint32
	maxFragmentInputComponents                      uint32
	maxFragmentOutputAttachments                    uint32
	maxFragmentDualSrcAttachments                   uint32
	maxFragmentCombinedOutputResources              uint32
	maxComputeSharedMemorySize                      uint32
	maxComputeWorkGroupCount                        [3]uint32
	maxComputeWorkGroupInvocations                  uint32
	maxComputeWorkGroupSize                         [3]uint32
	subPixelPrecisionBits                           uint32
	subTexelPrecisionBits                           uint32
	mipmapPrecisionBits                             uint32
	maxDrawIndexedIndexValue                        uint32
	maxDrawIndirectCount                            uint32
	maxSamplerLodBias                               float32
	maxSamplerAnisotropy                            float32
	maxViewports                                    uint32
	maxViewportDimensions                           [2]uint32
	viewportBoundsRange                             [2]float32
	viewportSubPixelBits                            uint32
	minMemoryMapAlignment                           uintptr
	minTexelBufferOffsetAlignment                   DeviceSize
	minUniformBufferOffsetAlignment                 DeviceSize
	minStorageBufferOffsetAlignment                 DeviceSize
	minTexelOffset                                  int32
	maxTexelOffset                                  uint32
	minTexelGatherOffset                            int32
	maxTexelGatherOffset                            uint32
	minInterpolationOffset                          float32
	maxInterpolationOffset                          float32
	subPixelInterpolationOffsetBits                 uint32
	maxFramebufferWidth                             uint32
	maxFramebufferHeight                            uint32
	maxFramebufferLayers                            uint32
	framebufferColorSampleCounts                    SampleCountFlags
	framebufferDepthSampleCounts                    SampleCountFlags
	framebufferStencilSampleCounts                  SampleCountFlags
	framebufferNoAttachmentsSampleCounts            SampleCountFlags
	maxColorAttachments                             uint32
	sampledImageColorSampleCounts                   SampleCountFlags
	sampledImageIntegerSampleCounts                 SampleCountFlags
	sampledImageDepthSampleCounts                   SampleCountFlags
	sampledImageStencilSampleCounts                 SampleCountFlags
	storageImageSampleCounts                        SampleCountFlags
	maxSampleMaskWords                              uint32
	timestampComputeAndGraphics                     Bool32
	timestampPeriod                                 float32
	maxClipDistances                                uint32
	maxCullDistances                                uint32
	maxCombinedClipAndCullDistances                 uint32
	discreteQueuePriorities                         uint32
	pointSizeRange                                  [2]float32
	lineWidthRange                                  [2]float32
	pointSizeGranularity                            float32
	lineWidthGranularity                            float32
	strictLines                                     Bool32
	standardSampleLocations                         Bool32
	optimalBufferCopyOffsetAlignment                DeviceSize
	optimalBufferCopyRowPitchAlignment              DeviceSize
	nonCoherentAtomSize                             DeviceSize
}

func (s *_vkPhysicalDeviceLimits) Goify() *PhysicalDeviceLimits {
	rval := &PhysicalDeviceLimits{
		MaxImageDimension1D:                             (uint32)(s.maxImageDimension1D),
		MaxImageDimension2D:                             (uint32)(s.maxImageDimension2D),
		MaxImageDimension3D:                             (uint32)(s.maxImageDimension3D),
		MaxImageDimensionCube:                           (uint32)(s.maxImageDimensionCube),
		MaxImageArrayLayers:                             (uint32)(s.maxImageArrayLayers),
		MaxTexelBufferElements:                          (uint32)(s.maxTexelBufferElements),
		MaxUniformBufferRange:                           (uint32)(s.maxUniformBufferRange),
		MaxStorageBufferRange:                           (uint32)(s.maxStorageBufferRange),
		MaxPushConstantsSize:                            (uint32)(s.maxPushConstantsSize),
		MaxMemoryAllocationCount:                        (uint32)(s.maxMemoryAllocationCount),
		MaxSamplerAllocationCount:                       (uint32)(s.maxSamplerAllocationCount),
		BufferImageGranularity:                          (DeviceSize)(s.bufferImageGranularity),
		SparseAddressSpaceSize:                          (DeviceSize)(s.sparseAddressSpaceSize),
		MaxBoundDescriptorSets:                          (uint32)(s.maxBoundDescriptorSets),
		MaxPerStageDescriptorSamplers:                   (uint32)(s.maxPerStageDescriptorSamplers),
		MaxPerStageDescriptorUniformBuffers:             (uint32)(s.maxPerStageDescriptorUniformBuffers),
		MaxPerStageDescriptorStorageBuffers:             (uint32)(s.maxPerStageDescriptorStorageBuffers),
		MaxPerStageDescriptorSampledImages:              (uint32)(s.maxPerStageDescriptorSampledImages),
		MaxPerStageDescriptorStorageImages:              (uint32)(s.maxPerStageDescriptorStorageImages),
		MaxPerStageDescriptorInputAttachments:           (uint32)(s.maxPerStageDescriptorInputAttachments),
		MaxPerStageResources:                            (uint32)(s.maxPerStageResources),
		MaxDescriptorSetSamplers:                        (uint32)(s.maxDescriptorSetSamplers),
		MaxDescriptorSetUniformBuffers:                  (uint32)(s.maxDescriptorSetUniformBuffers),
		MaxDescriptorSetUniformBuffersDynamic:           (uint32)(s.maxDescriptorSetUniformBuffersDynamic),
		MaxDescriptorSetStorageBuffers:                  (uint32)(s.maxDescriptorSetStorageBuffers),
		MaxDescriptorSetStorageBuffersDynamic:           (uint32)(s.maxDescriptorSetStorageBuffersDynamic),
		MaxDescriptorSetSampledImages:                   (uint32)(s.maxDescriptorSetSampledImages),
		MaxDescriptorSetStorageImages:                   (uint32)(s.maxDescriptorSetStorageImages),
		MaxDescriptorSetInputAttachments:                (uint32)(s.maxDescriptorSetInputAttachments),
		MaxVertexInputAttributes:                        (uint32)(s.maxVertexInputAttributes),
		MaxVertexInputBindings:                          (uint32)(s.maxVertexInputBindings),
		MaxVertexInputAttributeOffset:                   (uint32)(s.maxVertexInputAttributeOffset),
		MaxVertexInputBindingStride:                     (uint32)(s.maxVertexInputBindingStride),
		MaxVertexOutputComponents:                       (uint32)(s.maxVertexOutputComponents),
		MaxTessellationGenerationLevel:                  (uint32)(s.maxTessellationGenerationLevel),
		MaxTessellationPatchSize:                        (uint32)(s.maxTessellationPatchSize),
		MaxTessellationControlPerVertexInputComponents:  (uint32)(s.maxTessellationControlPerVertexInputComponents),
		MaxTessellationControlPerVertexOutputComponents: (uint32)(s.maxTessellationControlPerVertexOutputComponents),
		MaxTessellationControlPerPatchOutputComponents:  (uint32)(s.maxTessellationControlPerPatchOutputComponents),
		MaxTessellationControlTotalOutputComponents:     (uint32)(s.maxTessellationControlTotalOutputComponents),
		MaxTessellationEvaluationInputComponents:        (uint32)(s.maxTessellationEvaluationInputComponents),
		MaxTessellationEvaluationOutputComponents:       (uint32)(s.maxTessellationEvaluationOutputComponents),
		MaxGeometryShaderInvocations:                    (uint32)(s.maxGeometryShaderInvocations),
		MaxGeometryInputComponents:                      (uint32)(s.maxGeometryInputComponents),
		MaxGeometryOutputComponents:                     (uint32)(s.maxGeometryOutputComponents),
		MaxGeometryOutputVertices:                       (uint32)(s.maxGeometryOutputVertices),
		MaxGeometryTotalOutputComponents:                (uint32)(s.maxGeometryTotalOutputComponents),
		MaxFragmentInputComponents:                      (uint32)(s.maxFragmentInputComponents),
		MaxFragmentOutputAttachments:                    (uint32)(s.maxFragmentOutputAttachments),
		MaxFragmentDualSrcAttachments:                   (uint32)(s.maxFragmentDualSrcAttachments),
		MaxFragmentCombinedOutputResources:              (uint32)(s.maxFragmentCombinedOutputResources),
		MaxComputeSharedMemorySize:                      (uint32)(s.maxComputeSharedMemorySize),
		MaxComputeWorkGroupCount:                        ([3]uint32)(s.maxComputeWorkGroupCount),
		MaxComputeWorkGroupInvocations:                  (uint32)(s.maxComputeWorkGroupInvocations),
		MaxComputeWorkGroupSize:                         ([3]uint32)(s.maxComputeWorkGroupSize),
		SubPixelPrecisionBits:                           (uint32)(s.subPixelPrecisionBits),
		SubTexelPrecisionBits:                           (uint32)(s.subTexelPrecisionBits),
		MipmapPrecisionBits:                             (uint32)(s.mipmapPrecisionBits),
		MaxDrawIndexedIndexValue:                        (uint32)(s.maxDrawIndexedIndexValue),
		MaxDrawIndirectCount:                            (uint32)(s.maxDrawIndirectCount),
		MaxSamplerLodBias:                               (float32)(s.maxSamplerLodBias),
		MaxSamplerAnisotropy:                            (float32)(s.maxSamplerAnisotropy),
		MaxViewports:                                    (uint32)(s.maxViewports),
		MaxViewportDimensions:                           ([2]uint32)(s.maxViewportDimensions),
		ViewportBoundsRange:                             ([2]float32)(s.viewportBoundsRange),
		ViewportSubPixelBits:                            (uint32)(s.viewportSubPixelBits),
		MinMemoryMapAlignment:                           (uintptr)(s.minMemoryMapAlignment),
		MinTexelBufferOffsetAlignment:                   (DeviceSize)(s.minTexelBufferOffsetAlignment),
		MinUniformBufferOffsetAlignment:                 (DeviceSize)(s.minUniformBufferOffsetAlignment),
		MinStorageBufferOffsetAlignment:                 (DeviceSize)(s.minStorageBufferOffsetAlignment),
		MinTexelOffset:                                  (int32)(s.minTexelOffset),
		MaxTexelOffset:                                  (uint32)(s.maxTexelOffset),
		MinTexelGatherOffset:                            (int32)(s.minTexelGatherOffset),
		MaxTexelGatherOffset:                            (uint32)(s.maxTexelGatherOffset),
		MinInterpolationOffset:                          (float32)(s.minInterpolationOffset),
		MaxInterpolationOffset:                          (float32)(s.maxInterpolationOffset),
		SubPixelInterpolationOffsetBits:                 (uint32)(s.subPixelInterpolationOffsetBits),
		MaxFramebufferWidth:                             (uint32)(s.maxFramebufferWidth),
		MaxFramebufferHeight:                            (uint32)(s.maxFramebufferHeight),
		MaxFramebufferLayers:                            (uint32)(s.maxFramebufferLayers),
		FramebufferColorSampleCounts:                    (SampleCountFlags)(s.framebufferColorSampleCounts),
		FramebufferDepthSampleCounts:                    (SampleCountFlags)(s.framebufferDepthSampleCounts),
		FramebufferStencilSampleCounts:                  (SampleCountFlags)(s.framebufferStencilSampleCounts),
		FramebufferNoAttachmentsSampleCounts:            (SampleCountFlags)(s.framebufferNoAttachmentsSampleCounts),
		MaxColorAttachments:                             (uint32)(s.maxColorAttachments),
		SampledImageColorSampleCounts:                   (SampleCountFlags)(s.sampledImageColorSampleCounts),
		SampledImageIntegerSampleCounts:                 (SampleCountFlags)(s.sampledImageIntegerSampleCounts),
		SampledImageDepthSampleCounts:                   (SampleCountFlags)(s.sampledImageDepthSampleCounts),
		SampledImageStencilSampleCounts:                 (SampleCountFlags)(s.sampledImageStencilSampleCounts),
		StorageImageSampleCounts:                        (SampleCountFlags)(s.storageImageSampleCounts),
		MaxSampleMaskWords:                              (uint32)(s.maxSampleMaskWords),
		TimestampComputeAndGraphics:                     translatePublic_Bool32(s.timestampComputeAndGraphics), /*default*/
		TimestampPeriod:                                 (float32)(s.timestampPeriod),
		MaxClipDistances:                                (uint32)(s.maxClipDistances),
		MaxCullDistances:                                (uint32)(s.maxCullDistances),
		MaxCombinedClipAndCullDistances:                 (uint32)(s.maxCombinedClipAndCullDistances),
		DiscreteQueuePriorities:                         (uint32)(s.discreteQueuePriorities),
		PointSizeRange:                                  ([2]float32)(s.pointSizeRange),
		LineWidthRange:                                  ([2]float32)(s.lineWidthRange),
		PointSizeGranularity:                            (float32)(s.pointSizeGranularity),
		LineWidthGranularity:                            (float32)(s.lineWidthGranularity),
		StrictLines:                                     translatePublic_Bool32(s.strictLines),             /*default*/
		StandardSampleLocations:                         translatePublic_Bool32(s.standardSampleLocations), /*default*/
		OptimalBufferCopyOffsetAlignment:                (DeviceSize)(s.optimalBufferCopyOffsetAlignment),
		OptimalBufferCopyRowPitchAlignment:              (DeviceSize)(s.optimalBufferCopyRowPitchAlignment),
		NonCoherentAtomSize:                             (DeviceSize)(s.nonCoherentAtomSize),
	}
	return rval
}
func (s *PhysicalDeviceLimits) Vulkanize() *_vkPhysicalDeviceLimits {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceLimits{
		maxImageDimension1D:                             (uint32)(s.MaxImageDimension1D),                             /*cb*/
		maxImageDimension2D:                             (uint32)(s.MaxImageDimension2D),                             /*cb*/
		maxImageDimension3D:                             (uint32)(s.MaxImageDimension3D),                             /*cb*/
		maxImageDimensionCube:                           (uint32)(s.MaxImageDimensionCube),                           /*cb*/
		maxImageArrayLayers:                             (uint32)(s.MaxImageArrayLayers),                             /*cb*/
		maxTexelBufferElements:                          (uint32)(s.MaxTexelBufferElements),                          /*cb*/
		maxUniformBufferRange:                           (uint32)(s.MaxUniformBufferRange),                           /*cb*/
		maxStorageBufferRange:                           (uint32)(s.MaxStorageBufferRange),                           /*cb*/
		maxPushConstantsSize:                            (uint32)(s.MaxPushConstantsSize),                            /*cb*/
		maxMemoryAllocationCount:                        (uint32)(s.MaxMemoryAllocationCount),                        /*cb*/
		maxSamplerAllocationCount:                       (uint32)(s.MaxSamplerAllocationCount),                       /*cb*/
		bufferImageGranularity:                          (DeviceSize)(s.BufferImageGranularity),                      /*cb*/
		sparseAddressSpaceSize:                          (DeviceSize)(s.SparseAddressSpaceSize),                      /*cb*/
		maxBoundDescriptorSets:                          (uint32)(s.MaxBoundDescriptorSets),                          /*cb*/
		maxPerStageDescriptorSamplers:                   (uint32)(s.MaxPerStageDescriptorSamplers),                   /*cb*/
		maxPerStageDescriptorUniformBuffers:             (uint32)(s.MaxPerStageDescriptorUniformBuffers),             /*cb*/
		maxPerStageDescriptorStorageBuffers:             (uint32)(s.MaxPerStageDescriptorStorageBuffers),             /*cb*/
		maxPerStageDescriptorSampledImages:              (uint32)(s.MaxPerStageDescriptorSampledImages),              /*cb*/
		maxPerStageDescriptorStorageImages:              (uint32)(s.MaxPerStageDescriptorStorageImages),              /*cb*/
		maxPerStageDescriptorInputAttachments:           (uint32)(s.MaxPerStageDescriptorInputAttachments),           /*cb*/
		maxPerStageResources:                            (uint32)(s.MaxPerStageResources),                            /*cb*/
		maxDescriptorSetSamplers:                        (uint32)(s.MaxDescriptorSetSamplers),                        /*cb*/
		maxDescriptorSetUniformBuffers:                  (uint32)(s.MaxDescriptorSetUniformBuffers),                  /*cb*/
		maxDescriptorSetUniformBuffersDynamic:           (uint32)(s.MaxDescriptorSetUniformBuffersDynamic),           /*cb*/
		maxDescriptorSetStorageBuffers:                  (uint32)(s.MaxDescriptorSetStorageBuffers),                  /*cb*/
		maxDescriptorSetStorageBuffersDynamic:           (uint32)(s.MaxDescriptorSetStorageBuffersDynamic),           /*cb*/
		maxDescriptorSetSampledImages:                   (uint32)(s.MaxDescriptorSetSampledImages),                   /*cb*/
		maxDescriptorSetStorageImages:                   (uint32)(s.MaxDescriptorSetStorageImages),                   /*cb*/
		maxDescriptorSetInputAttachments:                (uint32)(s.MaxDescriptorSetInputAttachments),                /*cb*/
		maxVertexInputAttributes:                        (uint32)(s.MaxVertexInputAttributes),                        /*cb*/
		maxVertexInputBindings:                          (uint32)(s.MaxVertexInputBindings),                          /*cb*/
		maxVertexInputAttributeOffset:                   (uint32)(s.MaxVertexInputAttributeOffset),                   /*cb*/
		maxVertexInputBindingStride:                     (uint32)(s.MaxVertexInputBindingStride),                     /*cb*/
		maxVertexOutputComponents:                       (uint32)(s.MaxVertexOutputComponents),                       /*cb*/
		maxTessellationGenerationLevel:                  (uint32)(s.MaxTessellationGenerationLevel),                  /*cb*/
		maxTessellationPatchSize:                        (uint32)(s.MaxTessellationPatchSize),                        /*cb*/
		maxTessellationControlPerVertexInputComponents:  (uint32)(s.MaxTessellationControlPerVertexInputComponents),  /*cb*/
		maxTessellationControlPerVertexOutputComponents: (uint32)(s.MaxTessellationControlPerVertexOutputComponents), /*cb*/
		maxTessellationControlPerPatchOutputComponents:  (uint32)(s.MaxTessellationControlPerPatchOutputComponents),  /*cb*/
		maxTessellationControlTotalOutputComponents:     (uint32)(s.MaxTessellationControlTotalOutputComponents),     /*cb*/
		maxTessellationEvaluationInputComponents:        (uint32)(s.MaxTessellationEvaluationInputComponents),        /*cb*/
		maxTessellationEvaluationOutputComponents:       (uint32)(s.MaxTessellationEvaluationOutputComponents),       /*cb*/
		maxGeometryShaderInvocations:                    (uint32)(s.MaxGeometryShaderInvocations),                    /*cb*/
		maxGeometryInputComponents:                      (uint32)(s.MaxGeometryInputComponents),                      /*cb*/
		maxGeometryOutputComponents:                     (uint32)(s.MaxGeometryOutputComponents),                     /*cb*/
		maxGeometryOutputVertices:                       (uint32)(s.MaxGeometryOutputVertices),                       /*cb*/
		maxGeometryTotalOutputComponents:                (uint32)(s.MaxGeometryTotalOutputComponents),                /*cb*/
		maxFragmentInputComponents:                      (uint32)(s.MaxFragmentInputComponents),                      /*cb*/
		maxFragmentOutputAttachments:                    (uint32)(s.MaxFragmentOutputAttachments),                    /*cb*/
		maxFragmentDualSrcAttachments:                   (uint32)(s.MaxFragmentDualSrcAttachments),                   /*cb*/
		maxFragmentCombinedOutputResources:              (uint32)(s.MaxFragmentCombinedOutputResources),              /*cb*/
		maxComputeSharedMemorySize:                      (uint32)(s.MaxComputeSharedMemorySize),                      /*cb*/
		maxComputeWorkGroupCount:                        ([3]uint32)(s.MaxComputeWorkGroupCount),                     /*cb*/
		maxComputeWorkGroupInvocations:                  (uint32)(s.MaxComputeWorkGroupInvocations),                  /*cb*/
		maxComputeWorkGroupSize:                         ([3]uint32)(s.MaxComputeWorkGroupSize),                      /*cb*/
		subPixelPrecisionBits:                           (uint32)(s.SubPixelPrecisionBits),                           /*cb*/
		subTexelPrecisionBits:                           (uint32)(s.SubTexelPrecisionBits),                           /*cb*/
		mipmapPrecisionBits:                             (uint32)(s.MipmapPrecisionBits),                             /*cb*/
		maxDrawIndexedIndexValue:                        (uint32)(s.MaxDrawIndexedIndexValue),                        /*cb*/
		maxDrawIndirectCount:                            (uint32)(s.MaxDrawIndirectCount),                            /*cb*/
		maxSamplerLodBias:                               (float32)(s.MaxSamplerLodBias),                              /*cb*/
		maxSamplerAnisotropy:                            (float32)(s.MaxSamplerAnisotropy),                           /*cb*/
		maxViewports:                                    (uint32)(s.MaxViewports),                                    /*cb*/
		maxViewportDimensions:                           ([2]uint32)(s.MaxViewportDimensions),                        /*cb*/
		viewportBoundsRange:                             ([2]float32)(s.ViewportBoundsRange),                         /*cb*/
		viewportSubPixelBits:                            (uint32)(s.ViewportSubPixelBits),                            /*cb*/
		minMemoryMapAlignment:                           (uintptr)(s.MinMemoryMapAlignment),                          /*cb*/
		minTexelBufferOffsetAlignment:                   (DeviceSize)(s.MinTexelBufferOffsetAlignment),               /*cb*/
		minUniformBufferOffsetAlignment:                 (DeviceSize)(s.MinUniformBufferOffsetAlignment),             /*cb*/
		minStorageBufferOffsetAlignment:                 (DeviceSize)(s.MinStorageBufferOffsetAlignment),             /*cb*/
		minTexelOffset:                                  (int32)(s.MinTexelOffset),                                   /*cb*/
		maxTexelOffset:                                  (uint32)(s.MaxTexelOffset),                                  /*cb*/
		minTexelGatherOffset:                            (int32)(s.MinTexelGatherOffset),                             /*cb*/
		maxTexelGatherOffset:                            (uint32)(s.MaxTexelGatherOffset),                            /*cb*/
		minInterpolationOffset:                          (float32)(s.MinInterpolationOffset),                         /*cb*/
		maxInterpolationOffset:                          (float32)(s.MaxInterpolationOffset),                         /*cb*/
		subPixelInterpolationOffsetBits:                 (uint32)(s.SubPixelInterpolationOffsetBits),                 /*cb*/
		maxFramebufferWidth:                             (uint32)(s.MaxFramebufferWidth),                             /*cb*/
		maxFramebufferHeight:                            (uint32)(s.MaxFramebufferHeight),                            /*cb*/
		maxFramebufferLayers:                            (uint32)(s.MaxFramebufferLayers),                            /*cb*/
		framebufferColorSampleCounts:                    (SampleCountFlags)(s.FramebufferColorSampleCounts),          /*cb*/
		framebufferDepthSampleCounts:                    (SampleCountFlags)(s.FramebufferDepthSampleCounts),          /*cb*/
		framebufferStencilSampleCounts:                  (SampleCountFlags)(s.FramebufferStencilSampleCounts),        /*cb*/
		framebufferNoAttachmentsSampleCounts:            (SampleCountFlags)(s.FramebufferNoAttachmentsSampleCounts),  /*cb*/
		maxColorAttachments:                             (uint32)(s.MaxColorAttachments),                             /*cb*/
		sampledImageColorSampleCounts:                   (SampleCountFlags)(s.SampledImageColorSampleCounts),         /*cb*/
		sampledImageIntegerSampleCounts:                 (SampleCountFlags)(s.SampledImageIntegerSampleCounts),       /*cb*/
		sampledImageDepthSampleCounts:                   (SampleCountFlags)(s.SampledImageDepthSampleCounts),         /*cb*/
		sampledImageStencilSampleCounts:                 (SampleCountFlags)(s.SampledImageStencilSampleCounts),       /*cb*/
		storageImageSampleCounts:                        (SampleCountFlags)(s.StorageImageSampleCounts),              /*cb*/
		maxSampleMaskWords:                              (uint32)(s.MaxSampleMaskWords),                              /*cb*/
		timestampComputeAndGraphics:                     translateInternal_Bool32(s.TimestampComputeAndGraphics),     /*default*/
		timestampPeriod:                                 (float32)(s.TimestampPeriod),                                /*cb*/
		maxClipDistances:                                (uint32)(s.MaxClipDistances),                                /*cb*/
		maxCullDistances:                                (uint32)(s.MaxCullDistances),                                /*cb*/
		maxCombinedClipAndCullDistances:                 (uint32)(s.MaxCombinedClipAndCullDistances),                 /*cb*/
		discreteQueuePriorities:                         (uint32)(s.DiscreteQueuePriorities),                         /*cb*/
		pointSizeRange:                                  ([2]float32)(s.PointSizeRange),                              /*cb*/
		lineWidthRange:                                  ([2]float32)(s.LineWidthRange),                              /*cb*/
		pointSizeGranularity:                            (float32)(s.PointSizeGranularity),                           /*cb*/
		lineWidthGranularity:                            (float32)(s.LineWidthGranularity),                           /*cb*/
		strictLines:                                     translateInternal_Bool32(s.StrictLines),                     /*default*/
		standardSampleLocations:                         translateInternal_Bool32(s.StandardSampleLocations),         /*default*/
		optimalBufferCopyOffsetAlignment:                (DeviceSize)(s.OptimalBufferCopyOffsetAlignment),            /*cb*/
		optimalBufferCopyRowPitchAlignment:              (DeviceSize)(s.OptimalBufferCopyRowPitchAlignment),          /*cb*/
		nonCoherentAtomSize:                             (DeviceSize)(s.NonCoherentAtomSize),                         /*cb*/
	}
	return rval
}

// PhysicalDeviceLineRasterizationFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html
type PhysicalDeviceLineRasterizationFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT
	PNext                    unsafe.Pointer
	RectangularLines         bool
	BresenhamLines           bool
	SmoothLines              bool
	StippledRectangularLines bool
	StippledBresenhamLines   bool
	StippledSmoothLines      bool
}

type _vkPhysicalDeviceLineRasterizationFeaturesEXT struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	rectangularLines         Bool32
	bresenhamLines           Bool32
	smoothLines              Bool32
	stippledRectangularLines Bool32
	stippledBresenhamLines   Bool32
	stippledSmoothLines      Bool32
}

func (s *_vkPhysicalDeviceLineRasterizationFeaturesEXT) Goify() *PhysicalDeviceLineRasterizationFeaturesEXT {
	rval := &PhysicalDeviceLineRasterizationFeaturesEXT{
		PNext:                    (unsafe.Pointer)(s.pNext),
		RectangularLines:         translatePublic_Bool32(s.rectangularLines),         /*default*/
		BresenhamLines:           translatePublic_Bool32(s.bresenhamLines),           /*default*/
		SmoothLines:              translatePublic_Bool32(s.smoothLines),              /*default*/
		StippledRectangularLines: translatePublic_Bool32(s.stippledRectangularLines), /*default*/
		StippledBresenhamLines:   translatePublic_Bool32(s.stippledBresenhamLines),   /*default*/
		StippledSmoothLines:      translatePublic_Bool32(s.stippledSmoothLines),      /*default*/
	}
	return rval
}
func (s *PhysicalDeviceLineRasterizationFeaturesEXT) Vulkanize() *_vkPhysicalDeviceLineRasterizationFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceLineRasterizationFeaturesEXT{
		sType:                    STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                      /*cb*/
		rectangularLines:         translateInternal_Bool32(s.RectangularLines),                   /*default*/
		bresenhamLines:           translateInternal_Bool32(s.BresenhamLines),                     /*default*/
		smoothLines:              translateInternal_Bool32(s.SmoothLines),                        /*default*/
		stippledRectangularLines: translateInternal_Bool32(s.StippledRectangularLines),           /*default*/
		stippledBresenhamLines:   translateInternal_Bool32(s.StippledBresenhamLines),             /*default*/
		stippledSmoothLines:      translateInternal_Bool32(s.StippledSmoothLines),                /*default*/
	}
	return rval
}

// PhysicalDeviceLineRasterizationPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html
type PhysicalDeviceLineRasterizationPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT
	PNext                     unsafe.Pointer
	LineSubPixelPrecisionBits uint32
}

// WARNING - struct PhysicalDeviceLineRasterizationPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceLineRasterizationPropertiesEXT struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	lineSubPixelPrecisionBits uint32
}

func (s *_vkPhysicalDeviceLineRasterizationPropertiesEXT) Goify() *PhysicalDeviceLineRasterizationPropertiesEXT {
	rval := &PhysicalDeviceLineRasterizationPropertiesEXT{
		PNext:                     (unsafe.Pointer)(s.pNext),
		LineSubPixelPrecisionBits: (uint32)(s.lineSubPixelPrecisionBits),
	}
	return rval
}
func (s *PhysicalDeviceLineRasterizationPropertiesEXT) Vulkanize() *_vkPhysicalDeviceLineRasterizationPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceLineRasterizationPropertiesEXT{
		sType:                     STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                                        /*cb*/
		lineSubPixelPrecisionBits: (uint32)(s.LineSubPixelPrecisionBits),                            /*cb*/
	}
	return rval
}

// PhysicalDeviceLinearColorAttachmentFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.html
type PhysicalDeviceLinearColorAttachmentFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV
	PNext                 unsafe.Pointer
	LinearColorAttachment bool
}

type _vkPhysicalDeviceLinearColorAttachmentFeaturesNV struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	linearColorAttachment Bool32
}

func (s *_vkPhysicalDeviceLinearColorAttachmentFeaturesNV) Goify() *PhysicalDeviceLinearColorAttachmentFeaturesNV {
	rval := &PhysicalDeviceLinearColorAttachmentFeaturesNV{
		PNext:                 (unsafe.Pointer)(s.pNext),
		LinearColorAttachment: translatePublic_Bool32(s.linearColorAttachment), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceLinearColorAttachmentFeaturesNV) Vulkanize() *_vkPhysicalDeviceLinearColorAttachmentFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceLinearColorAttachmentFeaturesNV{
		sType:                 STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                          /*cb*/
		linearColorAttachment: translateInternal_Bool32(s.LinearColorAttachment),                  /*default*/
	}
	return rval
}

// PhysicalDeviceMaintenance3Properties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance3Properties.html
type PhysicalDeviceMaintenance3Properties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES
	PNext                   unsafe.Pointer
	MaxPerSetDescriptors    uint32
	MaxMemoryAllocationSize DeviceSize
}

// WARNING - struct PhysicalDeviceMaintenance3Properties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMaintenance3Properties struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	maxPerSetDescriptors    uint32
	maxMemoryAllocationSize DeviceSize
}

func (s *_vkPhysicalDeviceMaintenance3Properties) Goify() *PhysicalDeviceMaintenance3Properties {
	rval := &PhysicalDeviceMaintenance3Properties{
		PNext:                   (unsafe.Pointer)(s.pNext),
		MaxPerSetDescriptors:    (uint32)(s.maxPerSetDescriptors),
		MaxMemoryAllocationSize: (DeviceSize)(s.maxMemoryAllocationSize),
	}
	return rval
}
func (s *PhysicalDeviceMaintenance3Properties) Vulkanize() *_vkPhysicalDeviceMaintenance3Properties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMaintenance3Properties{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                               /*cb*/
		maxPerSetDescriptors:    (uint32)(s.MaxPerSetDescriptors),                        /*cb*/
		maxMemoryAllocationSize: (DeviceSize)(s.MaxMemoryAllocationSize),                 /*cb*/
	}
	return rval
}

// PhysicalDeviceMaintenance3PropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance3PropertiesKHR.html
type PhysicalDeviceMaintenance3PropertiesKHR struct {
}

type _vkPhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3PropertiesKHR

func (s *_vkPhysicalDeviceMaintenance3PropertiesKHR) Goify() *PhysicalDeviceMaintenance3PropertiesKHR {
	rval := (*PhysicalDeviceMaintenance3PropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceMaintenance3PropertiesKHR) Vulkanize() *_vkPhysicalDeviceMaintenance3PropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceMaintenance3PropertiesKHR)(s)
	return rval
}

// PhysicalDeviceMaintenance4FeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4FeaturesKHR.html
type PhysicalDeviceMaintenance4FeaturesKHR struct {
}

type _vkPhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4FeaturesKHR

func (s *_vkPhysicalDeviceMaintenance4FeaturesKHR) Goify() *PhysicalDeviceMaintenance4FeaturesKHR {
	rval := (*PhysicalDeviceMaintenance4FeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceMaintenance4FeaturesKHR) Vulkanize() *_vkPhysicalDeviceMaintenance4FeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceMaintenance4FeaturesKHR)(s)
	return rval
}

// PhysicalDeviceMaintenance4PropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4PropertiesKHR.html
type PhysicalDeviceMaintenance4PropertiesKHR struct {
}

type _vkPhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4PropertiesKHR

func (s *_vkPhysicalDeviceMaintenance4PropertiesKHR) Goify() *PhysicalDeviceMaintenance4PropertiesKHR {
	rval := (*PhysicalDeviceMaintenance4PropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceMaintenance4PropertiesKHR) Vulkanize() *_vkPhysicalDeviceMaintenance4PropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceMaintenance4PropertiesKHR)(s)
	return rval
}

// PhysicalDeviceMaintenance5FeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance5FeaturesKHR.html
type PhysicalDeviceMaintenance5FeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR
	PNext        unsafe.Pointer
	Maintenance5 bool
}

type _vkPhysicalDeviceMaintenance5FeaturesKHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	maintenance5 Bool32
}

func (s *_vkPhysicalDeviceMaintenance5FeaturesKHR) Goify() *PhysicalDeviceMaintenance5FeaturesKHR {
	rval := &PhysicalDeviceMaintenance5FeaturesKHR{
		PNext:        (unsafe.Pointer)(s.pNext),
		Maintenance5: translatePublic_Bool32(s.maintenance5), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMaintenance5FeaturesKHR) Vulkanize() *_vkPhysicalDeviceMaintenance5FeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMaintenance5FeaturesKHR{
		sType:        STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                                 /*cb*/
		maintenance5: translateInternal_Bool32(s.Maintenance5),                  /*default*/
	}
	return rval
}

// PhysicalDeviceMaintenance5PropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance5PropertiesKHR.html
type PhysicalDeviceMaintenance5PropertiesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR
	PNext                                               unsafe.Pointer
	EarlyFragmentMultisampleCoverageAfterSampleCounting bool
	EarlyFragmentSampleMaskTestBeforeSampleCounting     bool
	DepthStencilSwizzleOneSupport                       bool
	PolygonModePointSize                                bool
	NonStrictSinglePixelWideLinesUseParallelogram       bool
	NonStrictWideLinesUseParallelogram                  bool
}

// WARNING - struct PhysicalDeviceMaintenance5PropertiesKHR is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMaintenance5PropertiesKHR struct {
	sType                                               StructureType
	pNext                                               unsafe.Pointer
	earlyFragmentMultisampleCoverageAfterSampleCounting Bool32
	earlyFragmentSampleMaskTestBeforeSampleCounting     Bool32
	depthStencilSwizzleOneSupport                       Bool32
	polygonModePointSize                                Bool32
	nonStrictSinglePixelWideLinesUseParallelogram       Bool32
	nonStrictWideLinesUseParallelogram                  Bool32
}

func (s *_vkPhysicalDeviceMaintenance5PropertiesKHR) Goify() *PhysicalDeviceMaintenance5PropertiesKHR {
	rval := &PhysicalDeviceMaintenance5PropertiesKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		EarlyFragmentMultisampleCoverageAfterSampleCounting: translatePublic_Bool32(s.earlyFragmentMultisampleCoverageAfterSampleCounting), /*default*/
		EarlyFragmentSampleMaskTestBeforeSampleCounting:     translatePublic_Bool32(s.earlyFragmentSampleMaskTestBeforeSampleCounting),     /*default*/
		DepthStencilSwizzleOneSupport:                       translatePublic_Bool32(s.depthStencilSwizzleOneSupport),                       /*default*/
		PolygonModePointSize:                                translatePublic_Bool32(s.polygonModePointSize),                                /*default*/
		NonStrictSinglePixelWideLinesUseParallelogram:       translatePublic_Bool32(s.nonStrictSinglePixelWideLinesUseParallelogram),       /*default*/
		NonStrictWideLinesUseParallelogram:                  translatePublic_Bool32(s.nonStrictWideLinesUseParallelogram),                  /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMaintenance5PropertiesKHR) Vulkanize() *_vkPhysicalDeviceMaintenance5PropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMaintenance5PropertiesKHR{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                   /*cb*/
		earlyFragmentMultisampleCoverageAfterSampleCounting: translateInternal_Bool32(s.EarlyFragmentMultisampleCoverageAfterSampleCounting), /*default*/
		earlyFragmentSampleMaskTestBeforeSampleCounting:     translateInternal_Bool32(s.EarlyFragmentSampleMaskTestBeforeSampleCounting),     /*default*/
		depthStencilSwizzleOneSupport:                       translateInternal_Bool32(s.DepthStencilSwizzleOneSupport),                       /*default*/
		polygonModePointSize:                                translateInternal_Bool32(s.PolygonModePointSize),                                /*default*/
		nonStrictSinglePixelWideLinesUseParallelogram:       translateInternal_Bool32(s.NonStrictSinglePixelWideLinesUseParallelogram),       /*default*/
		nonStrictWideLinesUseParallelogram:                  translateInternal_Bool32(s.NonStrictWideLinesUseParallelogram),                  /*default*/
	}
	return rval
}

// PhysicalDeviceMemoryBudgetPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html
type PhysicalDeviceMemoryBudgetPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT
	PNext      unsafe.Pointer
	HeapBudget [MAX_MEMORY_HEAPS]DeviceSize
	HeapUsage  [MAX_MEMORY_HEAPS]DeviceSize
}

// WARNING - struct PhysicalDeviceMemoryBudgetPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMemoryBudgetPropertiesEXT struct {
	sType      StructureType
	pNext      unsafe.Pointer
	heapBudget [MAX_MEMORY_HEAPS]DeviceSize
	heapUsage  [MAX_MEMORY_HEAPS]DeviceSize
}

func (s *_vkPhysicalDeviceMemoryBudgetPropertiesEXT) Goify() *PhysicalDeviceMemoryBudgetPropertiesEXT {
	rval := &PhysicalDeviceMemoryBudgetPropertiesEXT{
		PNext:      (unsafe.Pointer)(s.pNext),
		HeapBudget: ([MAX_MEMORY_HEAPS]DeviceSize)(s.heapBudget),
		HeapUsage:  ([MAX_MEMORY_HEAPS]DeviceSize)(s.heapUsage),
	}
	return rval
}
func (s *PhysicalDeviceMemoryBudgetPropertiesEXT) Vulkanize() *_vkPhysicalDeviceMemoryBudgetPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMemoryBudgetPropertiesEXT{
		sType:      STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                                   /*cb*/
		heapBudget: ([MAX_MEMORY_HEAPS]DeviceSize)(s.HeapBudget),                /*cb*/
		heapUsage:  ([MAX_MEMORY_HEAPS]DeviceSize)(s.HeapUsage),                 /*cb*/
	}
	return rval
}

// PhysicalDeviceMemoryDecompressionFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryDecompressionFeaturesNV.html
type PhysicalDeviceMemoryDecompressionFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV
	PNext               unsafe.Pointer
	MemoryDecompression bool
}

type _vkPhysicalDeviceMemoryDecompressionFeaturesNV struct {
	sType               StructureType
	pNext               unsafe.Pointer
	memoryDecompression Bool32
}

func (s *_vkPhysicalDeviceMemoryDecompressionFeaturesNV) Goify() *PhysicalDeviceMemoryDecompressionFeaturesNV {
	rval := &PhysicalDeviceMemoryDecompressionFeaturesNV{
		PNext:               (unsafe.Pointer)(s.pNext),
		MemoryDecompression: translatePublic_Bool32(s.memoryDecompression), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMemoryDecompressionFeaturesNV) Vulkanize() *_vkPhysicalDeviceMemoryDecompressionFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMemoryDecompressionFeaturesNV{
		sType:               STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                       /*cb*/
		memoryDecompression: translateInternal_Bool32(s.MemoryDecompression),                 /*default*/
	}
	return rval
}

// PhysicalDeviceMemoryDecompressionPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryDecompressionPropertiesNV.html
type PhysicalDeviceMemoryDecompressionPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV
	PNext                         unsafe.Pointer
	DecompressionMethods          MemoryDecompressionMethodFlagsNV
	MaxDecompressionIndirectCount uint64
}

// WARNING - struct PhysicalDeviceMemoryDecompressionPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMemoryDecompressionPropertiesNV struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	decompressionMethods          MemoryDecompressionMethodFlagsNV
	maxDecompressionIndirectCount uint64
}

func (s *_vkPhysicalDeviceMemoryDecompressionPropertiesNV) Goify() *PhysicalDeviceMemoryDecompressionPropertiesNV {
	rval := &PhysicalDeviceMemoryDecompressionPropertiesNV{
		PNext:                         (unsafe.Pointer)(s.pNext),
		DecompressionMethods:          (MemoryDecompressionMethodFlagsNV)(s.decompressionMethods),
		MaxDecompressionIndirectCount: (uint64)(s.maxDecompressionIndirectCount),
	}
	return rval
}
func (s *PhysicalDeviceMemoryDecompressionPropertiesNV) Vulkanize() *_vkPhysicalDeviceMemoryDecompressionPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMemoryDecompressionPropertiesNV{
		sType:                         STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                         /*cb*/
		decompressionMethods:          (MemoryDecompressionMethodFlagsNV)(s.DecompressionMethods),        /*cb*/
		maxDecompressionIndirectCount: (uint64)(s.MaxDecompressionIndirectCount),                         /*cb*/
	}
	return rval
}

// PhysicalDeviceMemoryPriorityFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html
type PhysicalDeviceMemoryPriorityFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT
	PNext          unsafe.Pointer
	MemoryPriority bool
}

type _vkPhysicalDeviceMemoryPriorityFeaturesEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	memoryPriority Bool32
}

func (s *_vkPhysicalDeviceMemoryPriorityFeaturesEXT) Goify() *PhysicalDeviceMemoryPriorityFeaturesEXT {
	rval := &PhysicalDeviceMemoryPriorityFeaturesEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		MemoryPriority: translatePublic_Bool32(s.memoryPriority), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMemoryPriorityFeaturesEXT) Vulkanize() *_vkPhysicalDeviceMemoryPriorityFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMemoryPriorityFeaturesEXT{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                   /*cb*/
		memoryPriority: translateInternal_Bool32(s.MemoryPriority),                  /*default*/
	}
	return rval
}

// PhysicalDeviceMemoryProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties.html
type PhysicalDeviceMemoryProperties struct {
	MemoryTypeCount uint32
	MemoryTypes     [MAX_MEMORY_TYPES]MemoryType
	MemoryHeapCount uint32
	MemoryHeaps     [MAX_MEMORY_HEAPS]MemoryHeap
}

type _vkPhysicalDeviceMemoryProperties = PhysicalDeviceMemoryProperties

func (s *_vkPhysicalDeviceMemoryProperties) Goify() *PhysicalDeviceMemoryProperties {
	rval := (*PhysicalDeviceMemoryProperties)(s)
	return rval
}
func (s *PhysicalDeviceMemoryProperties) Vulkanize() *_vkPhysicalDeviceMemoryProperties {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceMemoryProperties)(s)
	return rval
}

// PhysicalDeviceMemoryProperties2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties2.html
type PhysicalDeviceMemoryProperties2 struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2
	PNext            unsafe.Pointer
	MemoryProperties PhysicalDeviceMemoryProperties
}

// WARNING - struct PhysicalDeviceMemoryProperties2 is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMemoryProperties2 struct {
	sType            StructureType
	pNext            unsafe.Pointer
	memoryProperties _vkPhysicalDeviceMemoryProperties
}

func (s *_vkPhysicalDeviceMemoryProperties2) Goify() *PhysicalDeviceMemoryProperties2 {
	rval := &PhysicalDeviceMemoryProperties2{
		PNext:            (unsafe.Pointer)(s.pNext),
		MemoryProperties: (PhysicalDeviceMemoryProperties)(s.memoryProperties),
	}
	return rval
}
func (s *PhysicalDeviceMemoryProperties2) Vulkanize() *_vkPhysicalDeviceMemoryProperties2 {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMemoryProperties2{
		sType:            STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,      /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                               /*cb*/
		memoryProperties: (_vkPhysicalDeviceMemoryProperties)(s.MemoryProperties), /*cb*/
	}
	return rval
}

// PhysicalDeviceMemoryProperties2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties2KHR.html
type PhysicalDeviceMemoryProperties2KHR struct {
}

type _vkPhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2KHR

func (s *_vkPhysicalDeviceMemoryProperties2KHR) Goify() *PhysicalDeviceMemoryProperties2KHR {
	rval := (*PhysicalDeviceMemoryProperties2KHR)(s)
	return rval
}
func (s *PhysicalDeviceMemoryProperties2KHR) Vulkanize() *_vkPhysicalDeviceMemoryProperties2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceMemoryProperties2KHR)(s)
	return rval
}

// PhysicalDeviceMeshShaderFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesEXT.html
type PhysicalDeviceMeshShaderFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT
	PNext                                  unsafe.Pointer
	TaskShader                             bool
	MeshShader                             bool
	MultiviewMeshShader                    bool
	PrimitiveFragmentShadingRateMeshShader bool
	MeshShaderQueries                      bool
}

type _vkPhysicalDeviceMeshShaderFeaturesEXT struct {
	sType                                  StructureType
	pNext                                  unsafe.Pointer
	taskShader                             Bool32
	meshShader                             Bool32
	multiviewMeshShader                    Bool32
	primitiveFragmentShadingRateMeshShader Bool32
	meshShaderQueries                      Bool32
}

func (s *_vkPhysicalDeviceMeshShaderFeaturesEXT) Goify() *PhysicalDeviceMeshShaderFeaturesEXT {
	rval := &PhysicalDeviceMeshShaderFeaturesEXT{
		PNext:                                  (unsafe.Pointer)(s.pNext),
		TaskShader:                             translatePublic_Bool32(s.taskShader),                             /*default*/
		MeshShader:                             translatePublic_Bool32(s.meshShader),                             /*default*/
		MultiviewMeshShader:                    translatePublic_Bool32(s.multiviewMeshShader),                    /*default*/
		PrimitiveFragmentShadingRateMeshShader: translatePublic_Bool32(s.primitiveFragmentShadingRateMeshShader), /*default*/
		MeshShaderQueries:                      translatePublic_Bool32(s.meshShaderQueries),                      /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMeshShaderFeaturesEXT) Vulkanize() *_vkPhysicalDeviceMeshShaderFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMeshShaderFeaturesEXT{
		sType:                                  STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT,            /*c1*/
		pNext:                                  (unsafe.Pointer)(s.PNext),                                          /*cb*/
		taskShader:                             translateInternal_Bool32(s.TaskShader),                             /*default*/
		meshShader:                             translateInternal_Bool32(s.MeshShader),                             /*default*/
		multiviewMeshShader:                    translateInternal_Bool32(s.MultiviewMeshShader),                    /*default*/
		primitiveFragmentShadingRateMeshShader: translateInternal_Bool32(s.PrimitiveFragmentShadingRateMeshShader), /*default*/
		meshShaderQueries:                      translateInternal_Bool32(s.MeshShaderQueries),                      /*default*/
	}
	return rval
}

// PhysicalDeviceMeshShaderFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html
type PhysicalDeviceMeshShaderFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV
	PNext      unsafe.Pointer
	TaskShader bool
	MeshShader bool
}

type _vkPhysicalDeviceMeshShaderFeaturesNV struct {
	sType      StructureType
	pNext      unsafe.Pointer
	taskShader Bool32
	meshShader Bool32
}

func (s *_vkPhysicalDeviceMeshShaderFeaturesNV) Goify() *PhysicalDeviceMeshShaderFeaturesNV {
	rval := &PhysicalDeviceMeshShaderFeaturesNV{
		PNext:      (unsafe.Pointer)(s.pNext),
		TaskShader: translatePublic_Bool32(s.taskShader), /*default*/
		MeshShader: translatePublic_Bool32(s.meshShader), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMeshShaderFeaturesNV) Vulkanize() *_vkPhysicalDeviceMeshShaderFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMeshShaderFeaturesNV{
		sType:      STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                              /*cb*/
		taskShader: translateInternal_Bool32(s.TaskShader),                 /*default*/
		meshShader: translateInternal_Bool32(s.MeshShader),                 /*default*/
	}
	return rval
}

// PhysicalDeviceMeshShaderPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesEXT.html
type PhysicalDeviceMeshShaderPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT
	PNext                                 unsafe.Pointer
	MaxTaskWorkGroupTotalCount            uint32
	MaxTaskWorkGroupCount                 [3]uint32
	MaxTaskWorkGroupInvocations           uint32
	MaxTaskWorkGroupSize                  [3]uint32
	MaxTaskPayloadSize                    uint32
	MaxTaskSharedMemorySize               uint32
	MaxTaskPayloadAndSharedMemorySize     uint32
	MaxMeshWorkGroupTotalCount            uint32
	MaxMeshWorkGroupCount                 [3]uint32
	MaxMeshWorkGroupInvocations           uint32
	MaxMeshWorkGroupSize                  [3]uint32
	MaxMeshSharedMemorySize               uint32
	MaxMeshPayloadAndSharedMemorySize     uint32
	MaxMeshOutputMemorySize               uint32
	MaxMeshPayloadAndOutputMemorySize     uint32
	MaxMeshOutputComponents               uint32
	MaxMeshOutputVertices                 uint32
	MaxMeshOutputPrimitives               uint32
	MaxMeshOutputLayers                   uint32
	MaxMeshMultiviewViewCount             uint32
	MeshOutputPerVertexGranularity        uint32
	MeshOutputPerPrimitiveGranularity     uint32
	MaxPreferredTaskWorkGroupInvocations  uint32
	MaxPreferredMeshWorkGroupInvocations  uint32
	PrefersLocalInvocationVertexOutput    bool
	PrefersLocalInvocationPrimitiveOutput bool
	PrefersCompactVertexOutput            bool
	PrefersCompactPrimitiveOutput         bool
}

// WARNING - struct PhysicalDeviceMeshShaderPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMeshShaderPropertiesEXT struct {
	sType                                 StructureType
	pNext                                 unsafe.Pointer
	maxTaskWorkGroupTotalCount            uint32
	maxTaskWorkGroupCount                 [3]uint32
	maxTaskWorkGroupInvocations           uint32
	maxTaskWorkGroupSize                  [3]uint32
	maxTaskPayloadSize                    uint32
	maxTaskSharedMemorySize               uint32
	maxTaskPayloadAndSharedMemorySize     uint32
	maxMeshWorkGroupTotalCount            uint32
	maxMeshWorkGroupCount                 [3]uint32
	maxMeshWorkGroupInvocations           uint32
	maxMeshWorkGroupSize                  [3]uint32
	maxMeshSharedMemorySize               uint32
	maxMeshPayloadAndSharedMemorySize     uint32
	maxMeshOutputMemorySize               uint32
	maxMeshPayloadAndOutputMemorySize     uint32
	maxMeshOutputComponents               uint32
	maxMeshOutputVertices                 uint32
	maxMeshOutputPrimitives               uint32
	maxMeshOutputLayers                   uint32
	maxMeshMultiviewViewCount             uint32
	meshOutputPerVertexGranularity        uint32
	meshOutputPerPrimitiveGranularity     uint32
	maxPreferredTaskWorkGroupInvocations  uint32
	maxPreferredMeshWorkGroupInvocations  uint32
	prefersLocalInvocationVertexOutput    Bool32
	prefersLocalInvocationPrimitiveOutput Bool32
	prefersCompactVertexOutput            Bool32
	prefersCompactPrimitiveOutput         Bool32
}

func (s *_vkPhysicalDeviceMeshShaderPropertiesEXT) Goify() *PhysicalDeviceMeshShaderPropertiesEXT {
	rval := &PhysicalDeviceMeshShaderPropertiesEXT{
		PNext:                                 (unsafe.Pointer)(s.pNext),
		MaxTaskWorkGroupTotalCount:            (uint32)(s.maxTaskWorkGroupTotalCount),
		MaxTaskWorkGroupCount:                 ([3]uint32)(s.maxTaskWorkGroupCount),
		MaxTaskWorkGroupInvocations:           (uint32)(s.maxTaskWorkGroupInvocations),
		MaxTaskWorkGroupSize:                  ([3]uint32)(s.maxTaskWorkGroupSize),
		MaxTaskPayloadSize:                    (uint32)(s.maxTaskPayloadSize),
		MaxTaskSharedMemorySize:               (uint32)(s.maxTaskSharedMemorySize),
		MaxTaskPayloadAndSharedMemorySize:     (uint32)(s.maxTaskPayloadAndSharedMemorySize),
		MaxMeshWorkGroupTotalCount:            (uint32)(s.maxMeshWorkGroupTotalCount),
		MaxMeshWorkGroupCount:                 ([3]uint32)(s.maxMeshWorkGroupCount),
		MaxMeshWorkGroupInvocations:           (uint32)(s.maxMeshWorkGroupInvocations),
		MaxMeshWorkGroupSize:                  ([3]uint32)(s.maxMeshWorkGroupSize),
		MaxMeshSharedMemorySize:               (uint32)(s.maxMeshSharedMemorySize),
		MaxMeshPayloadAndSharedMemorySize:     (uint32)(s.maxMeshPayloadAndSharedMemorySize),
		MaxMeshOutputMemorySize:               (uint32)(s.maxMeshOutputMemorySize),
		MaxMeshPayloadAndOutputMemorySize:     (uint32)(s.maxMeshPayloadAndOutputMemorySize),
		MaxMeshOutputComponents:               (uint32)(s.maxMeshOutputComponents),
		MaxMeshOutputVertices:                 (uint32)(s.maxMeshOutputVertices),
		MaxMeshOutputPrimitives:               (uint32)(s.maxMeshOutputPrimitives),
		MaxMeshOutputLayers:                   (uint32)(s.maxMeshOutputLayers),
		MaxMeshMultiviewViewCount:             (uint32)(s.maxMeshMultiviewViewCount),
		MeshOutputPerVertexGranularity:        (uint32)(s.meshOutputPerVertexGranularity),
		MeshOutputPerPrimitiveGranularity:     (uint32)(s.meshOutputPerPrimitiveGranularity),
		MaxPreferredTaskWorkGroupInvocations:  (uint32)(s.maxPreferredTaskWorkGroupInvocations),
		MaxPreferredMeshWorkGroupInvocations:  (uint32)(s.maxPreferredMeshWorkGroupInvocations),
		PrefersLocalInvocationVertexOutput:    translatePublic_Bool32(s.prefersLocalInvocationVertexOutput),    /*default*/
		PrefersLocalInvocationPrimitiveOutput: translatePublic_Bool32(s.prefersLocalInvocationPrimitiveOutput), /*default*/
		PrefersCompactVertexOutput:            translatePublic_Bool32(s.prefersCompactVertexOutput),            /*default*/
		PrefersCompactPrimitiveOutput:         translatePublic_Bool32(s.prefersCompactPrimitiveOutput),         /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMeshShaderPropertiesEXT) Vulkanize() *_vkPhysicalDeviceMeshShaderPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMeshShaderPropertiesEXT{
		sType:                                 STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT,         /*c1*/
		pNext:                                 (unsafe.Pointer)(s.PNext),                                         /*cb*/
		maxTaskWorkGroupTotalCount:            (uint32)(s.MaxTaskWorkGroupTotalCount),                            /*cb*/
		maxTaskWorkGroupCount:                 ([3]uint32)(s.MaxTaskWorkGroupCount),                              /*cb*/
		maxTaskWorkGroupInvocations:           (uint32)(s.MaxTaskWorkGroupInvocations),                           /*cb*/
		maxTaskWorkGroupSize:                  ([3]uint32)(s.MaxTaskWorkGroupSize),                               /*cb*/
		maxTaskPayloadSize:                    (uint32)(s.MaxTaskPayloadSize),                                    /*cb*/
		maxTaskSharedMemorySize:               (uint32)(s.MaxTaskSharedMemorySize),                               /*cb*/
		maxTaskPayloadAndSharedMemorySize:     (uint32)(s.MaxTaskPayloadAndSharedMemorySize),                     /*cb*/
		maxMeshWorkGroupTotalCount:            (uint32)(s.MaxMeshWorkGroupTotalCount),                            /*cb*/
		maxMeshWorkGroupCount:                 ([3]uint32)(s.MaxMeshWorkGroupCount),                              /*cb*/
		maxMeshWorkGroupInvocations:           (uint32)(s.MaxMeshWorkGroupInvocations),                           /*cb*/
		maxMeshWorkGroupSize:                  ([3]uint32)(s.MaxMeshWorkGroupSize),                               /*cb*/
		maxMeshSharedMemorySize:               (uint32)(s.MaxMeshSharedMemorySize),                               /*cb*/
		maxMeshPayloadAndSharedMemorySize:     (uint32)(s.MaxMeshPayloadAndSharedMemorySize),                     /*cb*/
		maxMeshOutputMemorySize:               (uint32)(s.MaxMeshOutputMemorySize),                               /*cb*/
		maxMeshPayloadAndOutputMemorySize:     (uint32)(s.MaxMeshPayloadAndOutputMemorySize),                     /*cb*/
		maxMeshOutputComponents:               (uint32)(s.MaxMeshOutputComponents),                               /*cb*/
		maxMeshOutputVertices:                 (uint32)(s.MaxMeshOutputVertices),                                 /*cb*/
		maxMeshOutputPrimitives:               (uint32)(s.MaxMeshOutputPrimitives),                               /*cb*/
		maxMeshOutputLayers:                   (uint32)(s.MaxMeshOutputLayers),                                   /*cb*/
		maxMeshMultiviewViewCount:             (uint32)(s.MaxMeshMultiviewViewCount),                             /*cb*/
		meshOutputPerVertexGranularity:        (uint32)(s.MeshOutputPerVertexGranularity),                        /*cb*/
		meshOutputPerPrimitiveGranularity:     (uint32)(s.MeshOutputPerPrimitiveGranularity),                     /*cb*/
		maxPreferredTaskWorkGroupInvocations:  (uint32)(s.MaxPreferredTaskWorkGroupInvocations),                  /*cb*/
		maxPreferredMeshWorkGroupInvocations:  (uint32)(s.MaxPreferredMeshWorkGroupInvocations),                  /*cb*/
		prefersLocalInvocationVertexOutput:    translateInternal_Bool32(s.PrefersLocalInvocationVertexOutput),    /*default*/
		prefersLocalInvocationPrimitiveOutput: translateInternal_Bool32(s.PrefersLocalInvocationPrimitiveOutput), /*default*/
		prefersCompactVertexOutput:            translateInternal_Bool32(s.PrefersCompactVertexOutput),            /*default*/
		prefersCompactPrimitiveOutput:         translateInternal_Bool32(s.PrefersCompactPrimitiveOutput),         /*default*/
	}
	return rval
}

// PhysicalDeviceMeshShaderPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html
type PhysicalDeviceMeshShaderPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV
	PNext                             unsafe.Pointer
	MaxDrawMeshTasksCount             uint32
	MaxTaskWorkGroupInvocations       uint32
	MaxTaskWorkGroupSize              [3]uint32
	MaxTaskTotalMemorySize            uint32
	MaxTaskOutputCount                uint32
	MaxMeshWorkGroupInvocations       uint32
	MaxMeshWorkGroupSize              [3]uint32
	MaxMeshTotalMemorySize            uint32
	MaxMeshOutputVertices             uint32
	MaxMeshOutputPrimitives           uint32
	MaxMeshMultiviewViewCount         uint32
	MeshOutputPerVertexGranularity    uint32
	MeshOutputPerPrimitiveGranularity uint32
}

// WARNING - struct PhysicalDeviceMeshShaderPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMeshShaderPropertiesNV struct {
	sType                             StructureType
	pNext                             unsafe.Pointer
	maxDrawMeshTasksCount             uint32
	maxTaskWorkGroupInvocations       uint32
	maxTaskWorkGroupSize              [3]uint32
	maxTaskTotalMemorySize            uint32
	maxTaskOutputCount                uint32
	maxMeshWorkGroupInvocations       uint32
	maxMeshWorkGroupSize              [3]uint32
	maxMeshTotalMemorySize            uint32
	maxMeshOutputVertices             uint32
	maxMeshOutputPrimitives           uint32
	maxMeshMultiviewViewCount         uint32
	meshOutputPerVertexGranularity    uint32
	meshOutputPerPrimitiveGranularity uint32
}

func (s *_vkPhysicalDeviceMeshShaderPropertiesNV) Goify() *PhysicalDeviceMeshShaderPropertiesNV {
	rval := &PhysicalDeviceMeshShaderPropertiesNV{
		PNext:                             (unsafe.Pointer)(s.pNext),
		MaxDrawMeshTasksCount:             (uint32)(s.maxDrawMeshTasksCount),
		MaxTaskWorkGroupInvocations:       (uint32)(s.maxTaskWorkGroupInvocations),
		MaxTaskWorkGroupSize:              ([3]uint32)(s.maxTaskWorkGroupSize),
		MaxTaskTotalMemorySize:            (uint32)(s.maxTaskTotalMemorySize),
		MaxTaskOutputCount:                (uint32)(s.maxTaskOutputCount),
		MaxMeshWorkGroupInvocations:       (uint32)(s.maxMeshWorkGroupInvocations),
		MaxMeshWorkGroupSize:              ([3]uint32)(s.maxMeshWorkGroupSize),
		MaxMeshTotalMemorySize:            (uint32)(s.maxMeshTotalMemorySize),
		MaxMeshOutputVertices:             (uint32)(s.maxMeshOutputVertices),
		MaxMeshOutputPrimitives:           (uint32)(s.maxMeshOutputPrimitives),
		MaxMeshMultiviewViewCount:         (uint32)(s.maxMeshMultiviewViewCount),
		MeshOutputPerVertexGranularity:    (uint32)(s.meshOutputPerVertexGranularity),
		MeshOutputPerPrimitiveGranularity: (uint32)(s.meshOutputPerPrimitiveGranularity),
	}
	return rval
}
func (s *PhysicalDeviceMeshShaderPropertiesNV) Vulkanize() *_vkPhysicalDeviceMeshShaderPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMeshShaderPropertiesNV{
		sType:                             STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV, /*c1*/
		pNext:                             (unsafe.Pointer)(s.PNext),                                /*cb*/
		maxDrawMeshTasksCount:             (uint32)(s.MaxDrawMeshTasksCount),                        /*cb*/
		maxTaskWorkGroupInvocations:       (uint32)(s.MaxTaskWorkGroupInvocations),                  /*cb*/
		maxTaskWorkGroupSize:              ([3]uint32)(s.MaxTaskWorkGroupSize),                      /*cb*/
		maxTaskTotalMemorySize:            (uint32)(s.MaxTaskTotalMemorySize),                       /*cb*/
		maxTaskOutputCount:                (uint32)(s.MaxTaskOutputCount),                           /*cb*/
		maxMeshWorkGroupInvocations:       (uint32)(s.MaxMeshWorkGroupInvocations),                  /*cb*/
		maxMeshWorkGroupSize:              ([3]uint32)(s.MaxMeshWorkGroupSize),                      /*cb*/
		maxMeshTotalMemorySize:            (uint32)(s.MaxMeshTotalMemorySize),                       /*cb*/
		maxMeshOutputVertices:             (uint32)(s.MaxMeshOutputVertices),                        /*cb*/
		maxMeshOutputPrimitives:           (uint32)(s.MaxMeshOutputPrimitives),                      /*cb*/
		maxMeshMultiviewViewCount:         (uint32)(s.MaxMeshMultiviewViewCount),                    /*cb*/
		meshOutputPerVertexGranularity:    (uint32)(s.MeshOutputPerVertexGranularity),               /*cb*/
		meshOutputPerPrimitiveGranularity: (uint32)(s.MeshOutputPerPrimitiveGranularity),            /*cb*/
	}
	return rval
}

// PhysicalDeviceMultiDrawFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html
type PhysicalDeviceMultiDrawFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT
	PNext     unsafe.Pointer
	MultiDraw bool
}

type _vkPhysicalDeviceMultiDrawFeaturesEXT struct {
	sType     StructureType
	pNext     unsafe.Pointer
	multiDraw Bool32
}

func (s *_vkPhysicalDeviceMultiDrawFeaturesEXT) Goify() *PhysicalDeviceMultiDrawFeaturesEXT {
	rval := &PhysicalDeviceMultiDrawFeaturesEXT{
		PNext:     (unsafe.Pointer)(s.pNext),
		MultiDraw: translatePublic_Bool32(s.multiDraw), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMultiDrawFeaturesEXT) Vulkanize() *_vkPhysicalDeviceMultiDrawFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMultiDrawFeaturesEXT{
		sType:     STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                              /*cb*/
		multiDraw: translateInternal_Bool32(s.MultiDraw),                  /*default*/
	}
	return rval
}

// PhysicalDeviceMultiDrawPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html
type PhysicalDeviceMultiDrawPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT
	PNext             unsafe.Pointer
	MaxMultiDrawCount uint32
}

// WARNING - struct PhysicalDeviceMultiDrawPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMultiDrawPropertiesEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	maxMultiDrawCount uint32
}

func (s *_vkPhysicalDeviceMultiDrawPropertiesEXT) Goify() *PhysicalDeviceMultiDrawPropertiesEXT {
	rval := &PhysicalDeviceMultiDrawPropertiesEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		MaxMultiDrawCount: (uint32)(s.maxMultiDrawCount),
	}
	return rval
}
func (s *PhysicalDeviceMultiDrawPropertiesEXT) Vulkanize() *_vkPhysicalDeviceMultiDrawPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMultiDrawPropertiesEXT{
		sType:             STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                /*cb*/
		maxMultiDrawCount: (uint32)(s.MaxMultiDrawCount),                            /*cb*/
	}
	return rval
}

// PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.html
type PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT
	PNext                             unsafe.Pointer
	MultisampledRenderToSingleSampled bool
}

type _vkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT struct {
	sType                             StructureType
	pNext                             unsafe.Pointer
	multisampledRenderToSingleSampled Bool32
}

func (s *_vkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT) Goify() *PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
	rval := &PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT{
		PNext:                             (unsafe.Pointer)(s.pNext),
		MultisampledRenderToSingleSampled: translatePublic_Bool32(s.multisampledRenderToSingleSampled), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT) Vulkanize() *_vkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT{
		sType:                             STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, /*c1*/
		pNext:                             (unsafe.Pointer)(s.PNext),                                                         /*cb*/
		multisampledRenderToSingleSampled: translateInternal_Bool32(s.MultisampledRenderToSingleSampled),                     /*default*/
	}
	return rval
}

// PhysicalDeviceMultiviewFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewFeatures.html
type PhysicalDeviceMultiviewFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES
	PNext unsafe.Pointer
	//  Multiple views in a renderpass;
	Multiview bool
	//  Multiple views in a renderpass w/ geometry shader;
	MultiviewGeometryShader bool
	//  Multiple views in a renderpass w/ tessellation shader;
	MultiviewTessellationShader bool
}

type _vkPhysicalDeviceMultiviewFeatures struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	multiview                   Bool32
	multiviewGeometryShader     Bool32
	multiviewTessellationShader Bool32
}

func (s *_vkPhysicalDeviceMultiviewFeatures) Goify() *PhysicalDeviceMultiviewFeatures {
	rval := &PhysicalDeviceMultiviewFeatures{
		PNext:                       (unsafe.Pointer)(s.pNext),
		Multiview:                   translatePublic_Bool32(s.multiview),                   /*default*/
		MultiviewGeometryShader:     translatePublic_Bool32(s.multiviewGeometryShader),     /*default*/
		MultiviewTessellationShader: translatePublic_Bool32(s.multiviewTessellationShader), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMultiviewFeatures) Vulkanize() *_vkPhysicalDeviceMultiviewFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMultiviewFeatures{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,       /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                               /*cb*/
		multiview:                   translateInternal_Bool32(s.Multiview),                   /*default*/
		multiviewGeometryShader:     translateInternal_Bool32(s.MultiviewGeometryShader),     /*default*/
		multiviewTessellationShader: translateInternal_Bool32(s.MultiviewTessellationShader), /*default*/
	}
	return rval
}

// PhysicalDeviceMultiviewFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewFeaturesKHR.html
type PhysicalDeviceMultiviewFeaturesKHR struct {
}

type _vkPhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeaturesKHR

func (s *_vkPhysicalDeviceMultiviewFeaturesKHR) Goify() *PhysicalDeviceMultiviewFeaturesKHR {
	rval := (*PhysicalDeviceMultiviewFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceMultiviewFeaturesKHR) Vulkanize() *_vkPhysicalDeviceMultiviewFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceMultiviewFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html
type PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX
	PNext                        unsafe.Pointer
	PerViewPositionAllComponents bool
}

// WARNING - struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	perViewPositionAllComponents Bool32
}

func (s *_vkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX) Goify() *PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
	rval := &PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX{
		PNext:                        (unsafe.Pointer)(s.pNext),
		PerViewPositionAllComponents: translatePublic_Bool32(s.perViewPositionAllComponents), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX) Vulkanize() *_vkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                                   /*cb*/
		perViewPositionAllComponents: translateInternal_Bool32(s.PerViewPositionAllComponents),                    /*default*/
	}
	return rval
}

// PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.html
type PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM
	PNext                       unsafe.Pointer
	MultiviewPerViewRenderAreas bool
}

type _vkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	multiviewPerViewRenderAreas Bool32
}

func (s *_vkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM) Goify() *PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
	rval := &PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM{
		PNext:                       (unsafe.Pointer)(s.pNext),
		MultiviewPerViewRenderAreas: translatePublic_Bool32(s.multiviewPerViewRenderAreas), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM) Vulkanize() *_vkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                                    /*cb*/
		multiviewPerViewRenderAreas: translateInternal_Bool32(s.MultiviewPerViewRenderAreas),                      /*default*/
	}
	return rval
}

// PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.html
type PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM
	PNext                     unsafe.Pointer
	MultiviewPerViewViewports bool
}

type _vkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	multiviewPerViewViewports Bool32
}

func (s *_vkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM) Goify() *PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
	rval := &PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM{
		PNext:                     (unsafe.Pointer)(s.pNext),
		MultiviewPerViewViewports: translatePublic_Bool32(s.multiviewPerViewViewports), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM) Vulkanize() *_vkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM{
		sType:                     STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                                                 /*cb*/
		multiviewPerViewViewports: translateInternal_Bool32(s.MultiviewPerViewViewports),                     /*default*/
	}
	return rval
}

// PhysicalDeviceMultiviewProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewProperties.html
type PhysicalDeviceMultiviewProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES
	PNext unsafe.Pointer
	//  max number of views in a subpass;
	MaxMultiviewViewCount uint32
	//  max instance index for a draw in a multiview subpass;
	MaxMultiviewInstanceIndex uint32
}

// WARNING - struct PhysicalDeviceMultiviewProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceMultiviewProperties struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	maxMultiviewViewCount     uint32
	maxMultiviewInstanceIndex uint32
}

func (s *_vkPhysicalDeviceMultiviewProperties) Goify() *PhysicalDeviceMultiviewProperties {
	rval := &PhysicalDeviceMultiviewProperties{
		PNext:                     (unsafe.Pointer)(s.pNext),
		MaxMultiviewViewCount:     (uint32)(s.maxMultiviewViewCount),
		MaxMultiviewInstanceIndex: (uint32)(s.maxMultiviewInstanceIndex),
	}
	return rval
}
func (s *PhysicalDeviceMultiviewProperties) Vulkanize() *_vkPhysicalDeviceMultiviewProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMultiviewProperties{
		sType:                     STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                           /*cb*/
		maxMultiviewViewCount:     (uint32)(s.MaxMultiviewViewCount),                   /*cb*/
		maxMultiviewInstanceIndex: (uint32)(s.MaxMultiviewInstanceIndex),               /*cb*/
	}
	return rval
}

// PhysicalDeviceMultiviewPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPropertiesKHR.html
type PhysicalDeviceMultiviewPropertiesKHR struct {
}

type _vkPhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewPropertiesKHR

func (s *_vkPhysicalDeviceMultiviewPropertiesKHR) Goify() *PhysicalDeviceMultiviewPropertiesKHR {
	rval := (*PhysicalDeviceMultiviewPropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceMultiviewPropertiesKHR) Vulkanize() *_vkPhysicalDeviceMultiviewPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceMultiviewPropertiesKHR)(s)
	return rval
}

// PhysicalDeviceMutableDescriptorTypeFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.html
type PhysicalDeviceMutableDescriptorTypeFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT
	PNext                 unsafe.Pointer
	MutableDescriptorType bool
}

type _vkPhysicalDeviceMutableDescriptorTypeFeaturesEXT struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	mutableDescriptorType Bool32
}

func (s *_vkPhysicalDeviceMutableDescriptorTypeFeaturesEXT) Goify() *PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
	rval := &PhysicalDeviceMutableDescriptorTypeFeaturesEXT{
		PNext:                 (unsafe.Pointer)(s.pNext),
		MutableDescriptorType: translatePublic_Bool32(s.mutableDescriptorType), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceMutableDescriptorTypeFeaturesEXT) Vulkanize() *_vkPhysicalDeviceMutableDescriptorTypeFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceMutableDescriptorTypeFeaturesEXT{
		sType:                 STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                           /*cb*/
		mutableDescriptorType: translateInternal_Bool32(s.MutableDescriptorType),                   /*default*/
	}
	return rval
}

// PhysicalDeviceMutableDescriptorTypeFeaturesVALVE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.html
type PhysicalDeviceMutableDescriptorTypeFeaturesVALVE struct {
}

type _vkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE

func (s *_vkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE) Goify() *PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
	rval := (*PhysicalDeviceMutableDescriptorTypeFeaturesVALVE)(s)
	return rval
}
func (s *PhysicalDeviceMutableDescriptorTypeFeaturesVALVE) Vulkanize() *_vkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)(s)
	return rval
}

// PhysicalDeviceNestedCommandBufferFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceNestedCommandBufferFeaturesEXT.html
type PhysicalDeviceNestedCommandBufferFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT
	PNext                              unsafe.Pointer
	NestedCommandBuffer                bool
	NestedCommandBufferRendering       bool
	NestedCommandBufferSimultaneousUse bool
}

type _vkPhysicalDeviceNestedCommandBufferFeaturesEXT struct {
	sType                              StructureType
	pNext                              unsafe.Pointer
	nestedCommandBuffer                Bool32
	nestedCommandBufferRendering       Bool32
	nestedCommandBufferSimultaneousUse Bool32
}

func (s *_vkPhysicalDeviceNestedCommandBufferFeaturesEXT) Goify() *PhysicalDeviceNestedCommandBufferFeaturesEXT {
	rval := &PhysicalDeviceNestedCommandBufferFeaturesEXT{
		PNext:                              (unsafe.Pointer)(s.pNext),
		NestedCommandBuffer:                translatePublic_Bool32(s.nestedCommandBuffer),                /*default*/
		NestedCommandBufferRendering:       translatePublic_Bool32(s.nestedCommandBufferRendering),       /*default*/
		NestedCommandBufferSimultaneousUse: translatePublic_Bool32(s.nestedCommandBufferSimultaneousUse), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceNestedCommandBufferFeaturesEXT) Vulkanize() *_vkPhysicalDeviceNestedCommandBufferFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceNestedCommandBufferFeaturesEXT{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT, /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                         /*cb*/
		nestedCommandBuffer:                translateInternal_Bool32(s.NestedCommandBuffer),                   /*default*/
		nestedCommandBufferRendering:       translateInternal_Bool32(s.NestedCommandBufferRendering),          /*default*/
		nestedCommandBufferSimultaneousUse: translateInternal_Bool32(s.NestedCommandBufferSimultaneousUse),    /*default*/
	}
	return rval
}

// PhysicalDeviceNestedCommandBufferPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceNestedCommandBufferPropertiesEXT.html
type PhysicalDeviceNestedCommandBufferPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT
	PNext                        unsafe.Pointer
	MaxCommandBufferNestingLevel uint32
}

type _vkPhysicalDeviceNestedCommandBufferPropertiesEXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	maxCommandBufferNestingLevel uint32
}

func (s *_vkPhysicalDeviceNestedCommandBufferPropertiesEXT) Goify() *PhysicalDeviceNestedCommandBufferPropertiesEXT {
	rval := &PhysicalDeviceNestedCommandBufferPropertiesEXT{
		PNext:                        (unsafe.Pointer)(s.pNext),
		MaxCommandBufferNestingLevel: (uint32)(s.maxCommandBufferNestingLevel),
	}
	return rval
}
func (s *PhysicalDeviceNestedCommandBufferPropertiesEXT) Vulkanize() *_vkPhysicalDeviceNestedCommandBufferPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceNestedCommandBufferPropertiesEXT{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                           /*cb*/
		maxCommandBufferNestingLevel: (uint32)(s.MaxCommandBufferNestingLevel),                            /*cb*/
	}
	return rval
}

// PhysicalDeviceNonSeamlessCubeMapFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.html
type PhysicalDeviceNonSeamlessCubeMapFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT
	PNext              unsafe.Pointer
	NonSeamlessCubeMap bool
}

type _vkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT struct {
	sType              StructureType
	pNext              unsafe.Pointer
	nonSeamlessCubeMap Bool32
}

func (s *_vkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT) Goify() *PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
	rval := &PhysicalDeviceNonSeamlessCubeMapFeaturesEXT{
		PNext:              (unsafe.Pointer)(s.pNext),
		NonSeamlessCubeMap: translatePublic_Bool32(s.nonSeamlessCubeMap), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceNonSeamlessCubeMapFeaturesEXT) Vulkanize() *_vkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                         /*cb*/
		nonSeamlessCubeMap: translateInternal_Bool32(s.NonSeamlessCubeMap),                    /*default*/
	}
	return rval
}

// PhysicalDeviceOpacityMicromapFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpacityMicromapFeaturesEXT.html
type PhysicalDeviceOpacityMicromapFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT
	PNext                 unsafe.Pointer
	Micromap              bool
	MicromapCaptureReplay bool
	MicromapHostCommands  bool
}

type _vkPhysicalDeviceOpacityMicromapFeaturesEXT struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	micromap              Bool32
	micromapCaptureReplay Bool32
	micromapHostCommands  Bool32
}

func (s *_vkPhysicalDeviceOpacityMicromapFeaturesEXT) Goify() *PhysicalDeviceOpacityMicromapFeaturesEXT {
	rval := &PhysicalDeviceOpacityMicromapFeaturesEXT{
		PNext:                 (unsafe.Pointer)(s.pNext),
		Micromap:              translatePublic_Bool32(s.micromap),              /*default*/
		MicromapCaptureReplay: translatePublic_Bool32(s.micromapCaptureReplay), /*default*/
		MicromapHostCommands:  translatePublic_Bool32(s.micromapHostCommands),  /*default*/
	}
	return rval
}
func (s *PhysicalDeviceOpacityMicromapFeaturesEXT) Vulkanize() *_vkPhysicalDeviceOpacityMicromapFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceOpacityMicromapFeaturesEXT{
		sType:                 STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                    /*cb*/
		micromap:              translateInternal_Bool32(s.Micromap),                         /*default*/
		micromapCaptureReplay: translateInternal_Bool32(s.MicromapCaptureReplay),            /*default*/
		micromapHostCommands:  translateInternal_Bool32(s.MicromapHostCommands),             /*default*/
	}
	return rval
}

// PhysicalDeviceOpacityMicromapPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpacityMicromapPropertiesEXT.html
type PhysicalDeviceOpacityMicromapPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT
	PNext                            unsafe.Pointer
	MaxOpacity2StateSubdivisionLevel uint32
	MaxOpacity4StateSubdivisionLevel uint32
}

// WARNING - struct PhysicalDeviceOpacityMicromapPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceOpacityMicromapPropertiesEXT struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	maxOpacity2StateSubdivisionLevel uint32
	maxOpacity4StateSubdivisionLevel uint32
}

func (s *_vkPhysicalDeviceOpacityMicromapPropertiesEXT) Goify() *PhysicalDeviceOpacityMicromapPropertiesEXT {
	rval := &PhysicalDeviceOpacityMicromapPropertiesEXT{
		PNext:                            (unsafe.Pointer)(s.pNext),
		MaxOpacity2StateSubdivisionLevel: (uint32)(s.maxOpacity2StateSubdivisionLevel),
		MaxOpacity4StateSubdivisionLevel: (uint32)(s.maxOpacity4StateSubdivisionLevel),
	}
	return rval
}
func (s *PhysicalDeviceOpacityMicromapPropertiesEXT) Vulkanize() *_vkPhysicalDeviceOpacityMicromapPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceOpacityMicromapPropertiesEXT{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                      /*cb*/
		maxOpacity2StateSubdivisionLevel: (uint32)(s.MaxOpacity2StateSubdivisionLevel),                   /*cb*/
		maxOpacity4StateSubdivisionLevel: (uint32)(s.MaxOpacity4StateSubdivisionLevel),                   /*cb*/
	}
	return rval
}

// PhysicalDeviceOpticalFlowFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpticalFlowFeaturesNV.html
type PhysicalDeviceOpticalFlowFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV
	PNext       unsafe.Pointer
	OpticalFlow bool
}

type _vkPhysicalDeviceOpticalFlowFeaturesNV struct {
	sType       StructureType
	pNext       unsafe.Pointer
	opticalFlow Bool32
}

func (s *_vkPhysicalDeviceOpticalFlowFeaturesNV) Goify() *PhysicalDeviceOpticalFlowFeaturesNV {
	rval := &PhysicalDeviceOpticalFlowFeaturesNV{
		PNext:       (unsafe.Pointer)(s.pNext),
		OpticalFlow: translatePublic_Bool32(s.opticalFlow), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceOpticalFlowFeaturesNV) Vulkanize() *_vkPhysicalDeviceOpticalFlowFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceOpticalFlowFeaturesNV{
		sType:       STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                               /*cb*/
		opticalFlow: translateInternal_Bool32(s.OpticalFlow),                 /*default*/
	}
	return rval
}

// PhysicalDeviceOpticalFlowPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpticalFlowPropertiesNV.html
type PhysicalDeviceOpticalFlowPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV
	PNext                      unsafe.Pointer
	SupportedOutputGridSizes   OpticalFlowGridSizeFlagsNV
	SupportedHintGridSizes     OpticalFlowGridSizeFlagsNV
	HintSupported              bool
	CostSupported              bool
	BidirectionalFlowSupported bool
	GlobalFlowSupported        bool
	MinWidth                   uint32
	MinHeight                  uint32
	MaxWidth                   uint32
	MaxHeight                  uint32
	MaxNumRegionsOfInterest    uint32
}

// WARNING - struct PhysicalDeviceOpticalFlowPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceOpticalFlowPropertiesNV struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	supportedOutputGridSizes   OpticalFlowGridSizeFlagsNV
	supportedHintGridSizes     OpticalFlowGridSizeFlagsNV
	hintSupported              Bool32
	costSupported              Bool32
	bidirectionalFlowSupported Bool32
	globalFlowSupported        Bool32
	minWidth                   uint32
	minHeight                  uint32
	maxWidth                   uint32
	maxHeight                  uint32
	maxNumRegionsOfInterest    uint32
}

func (s *_vkPhysicalDeviceOpticalFlowPropertiesNV) Goify() *PhysicalDeviceOpticalFlowPropertiesNV {
	rval := &PhysicalDeviceOpticalFlowPropertiesNV{
		PNext:                      (unsafe.Pointer)(s.pNext),
		SupportedOutputGridSizes:   (OpticalFlowGridSizeFlagsNV)(s.supportedOutputGridSizes),
		SupportedHintGridSizes:     (OpticalFlowGridSizeFlagsNV)(s.supportedHintGridSizes),
		HintSupported:              translatePublic_Bool32(s.hintSupported),              /*default*/
		CostSupported:              translatePublic_Bool32(s.costSupported),              /*default*/
		BidirectionalFlowSupported: translatePublic_Bool32(s.bidirectionalFlowSupported), /*default*/
		GlobalFlowSupported:        translatePublic_Bool32(s.globalFlowSupported),        /*default*/
		MinWidth:                   (uint32)(s.minWidth),
		MinHeight:                  (uint32)(s.minHeight),
		MaxWidth:                   (uint32)(s.maxWidth),
		MaxHeight:                  (uint32)(s.maxHeight),
		MaxNumRegionsOfInterest:    (uint32)(s.maxNumRegionsOfInterest),
	}
	return rval
}
func (s *PhysicalDeviceOpticalFlowPropertiesNV) Vulkanize() *_vkPhysicalDeviceOpticalFlowPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceOpticalFlowPropertiesNV{
		sType:                      STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                 /*cb*/
		supportedOutputGridSizes:   (OpticalFlowGridSizeFlagsNV)(s.SupportedOutputGridSizes),  /*cb*/
		supportedHintGridSizes:     (OpticalFlowGridSizeFlagsNV)(s.SupportedHintGridSizes),    /*cb*/
		hintSupported:              translateInternal_Bool32(s.HintSupported),                 /*default*/
		costSupported:              translateInternal_Bool32(s.CostSupported),                 /*default*/
		bidirectionalFlowSupported: translateInternal_Bool32(s.BidirectionalFlowSupported),    /*default*/
		globalFlowSupported:        translateInternal_Bool32(s.GlobalFlowSupported),           /*default*/
		minWidth:                   (uint32)(s.MinWidth),                                      /*cb*/
		minHeight:                  (uint32)(s.MinHeight),                                     /*cb*/
		maxWidth:                   (uint32)(s.MaxWidth),                                      /*cb*/
		maxHeight:                  (uint32)(s.MaxHeight),                                     /*cb*/
		maxNumRegionsOfInterest:    (uint32)(s.MaxNumRegionsOfInterest),                       /*cb*/
	}
	return rval
}

// PhysicalDevicePCIBusInfoPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html
type PhysicalDevicePCIBusInfoPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT
	PNext       unsafe.Pointer
	PciDomain   uint32
	PciBus      uint32
	PciDevice   uint32
	PciFunction uint32
}

// WARNING - struct PhysicalDevicePCIBusInfoPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDevicePCIBusInfoPropertiesEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	pciDomain   uint32
	pciBus      uint32
	pciDevice   uint32
	pciFunction uint32
}

func (s *_vkPhysicalDevicePCIBusInfoPropertiesEXT) Goify() *PhysicalDevicePCIBusInfoPropertiesEXT {
	rval := &PhysicalDevicePCIBusInfoPropertiesEXT{
		PNext:       (unsafe.Pointer)(s.pNext),
		PciDomain:   (uint32)(s.pciDomain),
		PciBus:      (uint32)(s.pciBus),
		PciDevice:   (uint32)(s.pciDevice),
		PciFunction: (uint32)(s.pciFunction),
	}
	return rval
}
func (s *PhysicalDevicePCIBusInfoPropertiesEXT) Vulkanize() *_vkPhysicalDevicePCIBusInfoPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePCIBusInfoPropertiesEXT{
		sType:       STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                                  /*cb*/
		pciDomain:   (uint32)(s.PciDomain),                                      /*cb*/
		pciBus:      (uint32)(s.PciBus),                                         /*cb*/
		pciDevice:   (uint32)(s.PciDevice),                                      /*cb*/
		pciFunction: (uint32)(s.PciFunction),                                    /*cb*/
	}
	return rval
}

// PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.html
type PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT
	PNext                     unsafe.Pointer
	PageableDeviceLocalMemory bool
}

type _vkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	pageableDeviceLocalMemory Bool32
}

func (s *_vkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT) Goify() *PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
	rval := &PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT{
		PNext:                     (unsafe.Pointer)(s.pNext),
		PageableDeviceLocalMemory: translatePublic_Bool32(s.pageableDeviceLocalMemory), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT) Vulkanize() *_vkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT{
		sType:                     STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                                                /*cb*/
		pageableDeviceLocalMemory: translateInternal_Bool32(s.PageableDeviceLocalMemory),                    /*default*/
	}
	return rval
}

// PhysicalDevicePerformanceQueryFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html
type PhysicalDevicePerformanceQueryFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR
	PNext unsafe.Pointer
	//  performance counters supported in query pools;
	PerformanceCounterQueryPools bool
	//  performance counters from multiple query pools can be accessed in the same primary command buffer;
	PerformanceCounterMultipleQueryPools bool
}

type _vkPhysicalDevicePerformanceQueryFeaturesKHR struct {
	sType                                StructureType
	pNext                                unsafe.Pointer
	performanceCounterQueryPools         Bool32
	performanceCounterMultipleQueryPools Bool32
}

func (s *_vkPhysicalDevicePerformanceQueryFeaturesKHR) Goify() *PhysicalDevicePerformanceQueryFeaturesKHR {
	rval := &PhysicalDevicePerformanceQueryFeaturesKHR{
		PNext:                                (unsafe.Pointer)(s.pNext),
		PerformanceCounterQueryPools:         translatePublic_Bool32(s.performanceCounterQueryPools),         /*default*/
		PerformanceCounterMultipleQueryPools: translatePublic_Bool32(s.performanceCounterMultipleQueryPools), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePerformanceQueryFeaturesKHR) Vulkanize() *_vkPhysicalDevicePerformanceQueryFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePerformanceQueryFeaturesKHR{
		sType:                                STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,    /*c1*/
		pNext:                                (unsafe.Pointer)(s.PNext),                                        /*cb*/
		performanceCounterQueryPools:         translateInternal_Bool32(s.PerformanceCounterQueryPools),         /*default*/
		performanceCounterMultipleQueryPools: translateInternal_Bool32(s.PerformanceCounterMultipleQueryPools), /*default*/
	}
	return rval
}

// PhysicalDevicePerformanceQueryPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html
type PhysicalDevicePerformanceQueryPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR
	PNext unsafe.Pointer
	//  Flag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults;
	AllowCommandBufferQueryCopies bool
}

// WARNING - struct PhysicalDevicePerformanceQueryPropertiesKHR is returned only, which is not yet handled in the binding
type _vkPhysicalDevicePerformanceQueryPropertiesKHR struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	allowCommandBufferQueryCopies Bool32
}

func (s *_vkPhysicalDevicePerformanceQueryPropertiesKHR) Goify() *PhysicalDevicePerformanceQueryPropertiesKHR {
	rval := &PhysicalDevicePerformanceQueryPropertiesKHR{
		PNext:                         (unsafe.Pointer)(s.pNext),
		AllowCommandBufferQueryCopies: translatePublic_Bool32(s.allowCommandBufferQueryCopies), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePerformanceQueryPropertiesKHR) Vulkanize() *_vkPhysicalDevicePerformanceQueryPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePerformanceQueryPropertiesKHR{
		sType:                         STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                       /*cb*/
		allowCommandBufferQueryCopies: translateInternal_Bool32(s.AllowCommandBufferQueryCopies),       /*default*/
	}
	return rval
}

// PhysicalDevicePipelineCreationCacheControlFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT.html
type PhysicalDevicePipelineCreationCacheControlFeaturesEXT struct {
}

type _vkPhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeaturesEXT

func (s *_vkPhysicalDevicePipelineCreationCacheControlFeaturesEXT) Goify() *PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
	rval := (*PhysicalDevicePipelineCreationCacheControlFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDevicePipelineCreationCacheControlFeaturesEXT) Vulkanize() *_vkPhysicalDevicePipelineCreationCacheControlFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)(s)
	return rval
}

// PhysicalDevicePipelineExecutablePropertiesFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html
type PhysicalDevicePipelineExecutablePropertiesFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR
	PNext                  unsafe.Pointer
	PipelineExecutableInfo bool
}

type _vkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	pipelineExecutableInfo Bool32
}

func (s *_vkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR) Goify() *PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
	rval := &PhysicalDevicePipelineExecutablePropertiesFeaturesKHR{
		PNext:                  (unsafe.Pointer)(s.pNext),
		PipelineExecutableInfo: translatePublic_Bool32(s.pipelineExecutableInfo), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePipelineExecutablePropertiesFeaturesKHR) Vulkanize() *_vkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR{
		sType:                  STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                                  /*cb*/
		pipelineExecutableInfo: translateInternal_Bool32(s.PipelineExecutableInfo),                         /*default*/
	}
	return rval
}

// PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.html
type PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT
	PNext                       unsafe.Pointer
	PipelineLibraryGroupHandles bool
}

type _vkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	pipelineLibraryGroupHandles Bool32
}

func (s *_vkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT) Goify() *PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
	rval := &PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT{
		PNext:                       (unsafe.Pointer)(s.pNext),
		PipelineLibraryGroupHandles: translatePublic_Bool32(s.pipelineLibraryGroupHandles), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT) Vulkanize() *_vkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                                  /*cb*/
		pipelineLibraryGroupHandles: translateInternal_Bool32(s.PipelineLibraryGroupHandles),                    /*default*/
	}
	return rval
}

// PhysicalDevicePipelinePropertiesFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelinePropertiesFeaturesEXT.html
type PhysicalDevicePipelinePropertiesFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT
	PNext                        unsafe.Pointer
	PipelinePropertiesIdentifier bool
}

type _vkPhysicalDevicePipelinePropertiesFeaturesEXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	pipelinePropertiesIdentifier Bool32
}

func (s *_vkPhysicalDevicePipelinePropertiesFeaturesEXT) Goify() *PhysicalDevicePipelinePropertiesFeaturesEXT {
	rval := &PhysicalDevicePipelinePropertiesFeaturesEXT{
		PNext:                        (unsafe.Pointer)(s.pNext),
		PipelinePropertiesIdentifier: translatePublic_Bool32(s.pipelinePropertiesIdentifier), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePipelinePropertiesFeaturesEXT) Vulkanize() *_vkPhysicalDevicePipelinePropertiesFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePipelinePropertiesFeaturesEXT{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                       /*cb*/
		pipelinePropertiesIdentifier: translateInternal_Bool32(s.PipelinePropertiesIdentifier),        /*default*/
	}
	return rval
}

// PhysicalDevicePipelineProtectedAccessFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineProtectedAccessFeaturesEXT.html
type PhysicalDevicePipelineProtectedAccessFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT
	PNext                   unsafe.Pointer
	PipelineProtectedAccess bool
}

type _vkPhysicalDevicePipelineProtectedAccessFeaturesEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	pipelineProtectedAccess Bool32
}

func (s *_vkPhysicalDevicePipelineProtectedAccessFeaturesEXT) Goify() *PhysicalDevicePipelineProtectedAccessFeaturesEXT {
	rval := &PhysicalDevicePipelineProtectedAccessFeaturesEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		PipelineProtectedAccess: translatePublic_Bool32(s.pipelineProtectedAccess), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePipelineProtectedAccessFeaturesEXT) Vulkanize() *_vkPhysicalDevicePipelineProtectedAccessFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePipelineProtectedAccessFeaturesEXT{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                             /*cb*/
		pipelineProtectedAccess: translateInternal_Bool32(s.PipelineProtectedAccess),                   /*default*/
	}
	return rval
}

// PhysicalDevicePipelineRobustnessFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineRobustnessFeaturesEXT.html
type PhysicalDevicePipelineRobustnessFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT
	PNext              unsafe.Pointer
	PipelineRobustness bool
}

type _vkPhysicalDevicePipelineRobustnessFeaturesEXT struct {
	sType              StructureType
	pNext              unsafe.Pointer
	pipelineRobustness Bool32
}

func (s *_vkPhysicalDevicePipelineRobustnessFeaturesEXT) Goify() *PhysicalDevicePipelineRobustnessFeaturesEXT {
	rval := &PhysicalDevicePipelineRobustnessFeaturesEXT{
		PNext:              (unsafe.Pointer)(s.pNext),
		PipelineRobustness: translatePublic_Bool32(s.pipelineRobustness), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePipelineRobustnessFeaturesEXT) Vulkanize() *_vkPhysicalDevicePipelineRobustnessFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePipelineRobustnessFeaturesEXT{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                       /*cb*/
		pipelineRobustness: translateInternal_Bool32(s.PipelineRobustness),                  /*default*/
	}
	return rval
}

// PhysicalDevicePipelineRobustnessPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineRobustnessPropertiesEXT.html
type PhysicalDevicePipelineRobustnessPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT
	PNext                           unsafe.Pointer
	DefaultRobustnessStorageBuffers PipelineRobustnessBufferBehaviorEXT
	DefaultRobustnessUniformBuffers PipelineRobustnessBufferBehaviorEXT
	DefaultRobustnessVertexInputs   PipelineRobustnessBufferBehaviorEXT
	DefaultRobustnessImages         PipelineRobustnessImageBehaviorEXT
}

// WARNING - struct PhysicalDevicePipelineRobustnessPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDevicePipelineRobustnessPropertiesEXT struct {
	sType                           StructureType
	pNext                           unsafe.Pointer
	defaultRobustnessStorageBuffers PipelineRobustnessBufferBehaviorEXT
	defaultRobustnessUniformBuffers PipelineRobustnessBufferBehaviorEXT
	defaultRobustnessVertexInputs   PipelineRobustnessBufferBehaviorEXT
	defaultRobustnessImages         PipelineRobustnessImageBehaviorEXT
}

func (s *_vkPhysicalDevicePipelineRobustnessPropertiesEXT) Goify() *PhysicalDevicePipelineRobustnessPropertiesEXT {
	rval := &PhysicalDevicePipelineRobustnessPropertiesEXT{
		PNext:                           (unsafe.Pointer)(s.pNext),
		DefaultRobustnessStorageBuffers: (PipelineRobustnessBufferBehaviorEXT)(s.defaultRobustnessStorageBuffers),
		DefaultRobustnessUniformBuffers: (PipelineRobustnessBufferBehaviorEXT)(s.defaultRobustnessUniformBuffers),
		DefaultRobustnessVertexInputs:   (PipelineRobustnessBufferBehaviorEXT)(s.defaultRobustnessVertexInputs),
		DefaultRobustnessImages:         (PipelineRobustnessImageBehaviorEXT)(s.defaultRobustnessImages),
	}
	return rval
}
func (s *PhysicalDevicePipelineRobustnessPropertiesEXT) Vulkanize() *_vkPhysicalDevicePipelineRobustnessPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePipelineRobustnessPropertiesEXT{
		sType:                           STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT,        /*c1*/
		pNext:                           (unsafe.Pointer)(s.PNext),                                                /*cb*/
		defaultRobustnessStorageBuffers: (PipelineRobustnessBufferBehaviorEXT)(s.DefaultRobustnessStorageBuffers), /*cb*/
		defaultRobustnessUniformBuffers: (PipelineRobustnessBufferBehaviorEXT)(s.DefaultRobustnessUniformBuffers), /*cb*/
		defaultRobustnessVertexInputs:   (PipelineRobustnessBufferBehaviorEXT)(s.DefaultRobustnessVertexInputs),   /*cb*/
		defaultRobustnessImages:         (PipelineRobustnessImageBehaviorEXT)(s.DefaultRobustnessImages),          /*cb*/
	}
	return rval
}

// PhysicalDevicePointClippingProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePointClippingProperties.html
type PhysicalDevicePointClippingProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES
	PNext                 unsafe.Pointer
	PointClippingBehavior PointClippingBehavior
}

// WARNING - struct PhysicalDevicePointClippingProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDevicePointClippingProperties struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	pointClippingBehavior PointClippingBehavior
}

func (s *_vkPhysicalDevicePointClippingProperties) Goify() *PhysicalDevicePointClippingProperties {
	rval := &PhysicalDevicePointClippingProperties{
		PNext:                 (unsafe.Pointer)(s.pNext),
		PointClippingBehavior: (PointClippingBehavior)(s.pointClippingBehavior),
	}
	return rval
}
func (s *PhysicalDevicePointClippingProperties) Vulkanize() *_vkPhysicalDevicePointClippingProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePointClippingProperties{
		sType:                 STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                /*cb*/
		pointClippingBehavior: (PointClippingBehavior)(s.PointClippingBehavior),         /*cb*/
	}
	return rval
}

// PhysicalDevicePointClippingPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePointClippingPropertiesKHR.html
type PhysicalDevicePointClippingPropertiesKHR struct {
}

type _vkPhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingPropertiesKHR

func (s *_vkPhysicalDevicePointClippingPropertiesKHR) Goify() *PhysicalDevicePointClippingPropertiesKHR {
	rval := (*PhysicalDevicePointClippingPropertiesKHR)(s)
	return rval
}
func (s *PhysicalDevicePointClippingPropertiesKHR) Vulkanize() *_vkPhysicalDevicePointClippingPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDevicePointClippingPropertiesKHR)(s)
	return rval
}

// PhysicalDevicePresentBarrierFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentBarrierFeaturesNV.html
type PhysicalDevicePresentBarrierFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV
	PNext          unsafe.Pointer
	PresentBarrier bool
}

type _vkPhysicalDevicePresentBarrierFeaturesNV struct {
	sType          StructureType
	pNext          unsafe.Pointer
	presentBarrier Bool32
}

func (s *_vkPhysicalDevicePresentBarrierFeaturesNV) Goify() *PhysicalDevicePresentBarrierFeaturesNV {
	rval := &PhysicalDevicePresentBarrierFeaturesNV{
		PNext:          (unsafe.Pointer)(s.pNext),
		PresentBarrier: translatePublic_Bool32(s.presentBarrier), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePresentBarrierFeaturesNV) Vulkanize() *_vkPhysicalDevicePresentBarrierFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePresentBarrierFeaturesNV{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                  /*cb*/
		presentBarrier: translateInternal_Bool32(s.PresentBarrier),                 /*default*/
	}
	return rval
}

// PhysicalDevicePresentIdFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html
type PhysicalDevicePresentIdFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR
	PNext unsafe.Pointer
	//  Present ID in VkPresentInfoKHR;
	PresentId bool
}

type _vkPhysicalDevicePresentIdFeaturesKHR struct {
	sType     StructureType
	pNext     unsafe.Pointer
	presentId Bool32
}

func (s *_vkPhysicalDevicePresentIdFeaturesKHR) Goify() *PhysicalDevicePresentIdFeaturesKHR {
	rval := &PhysicalDevicePresentIdFeaturesKHR{
		PNext:     (unsafe.Pointer)(s.pNext),
		PresentId: translatePublic_Bool32(s.presentId), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePresentIdFeaturesKHR) Vulkanize() *_vkPhysicalDevicePresentIdFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePresentIdFeaturesKHR{
		sType:     STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                              /*cb*/
		presentId: translateInternal_Bool32(s.PresentId),                  /*default*/
	}
	return rval
}

// PhysicalDevicePresentWaitFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html
type PhysicalDevicePresentWaitFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR
	PNext unsafe.Pointer
	//  vkWaitForPresentKHR is supported;
	PresentWait bool
}

type _vkPhysicalDevicePresentWaitFeaturesKHR struct {
	sType       StructureType
	pNext       unsafe.Pointer
	presentWait Bool32
}

func (s *_vkPhysicalDevicePresentWaitFeaturesKHR) Goify() *PhysicalDevicePresentWaitFeaturesKHR {
	rval := &PhysicalDevicePresentWaitFeaturesKHR{
		PNext:       (unsafe.Pointer)(s.pNext),
		PresentWait: translatePublic_Bool32(s.presentWait), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePresentWaitFeaturesKHR) Vulkanize() *_vkPhysicalDevicePresentWaitFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePresentWaitFeaturesKHR{
		sType:       STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                                /*cb*/
		presentWait: translateInternal_Bool32(s.PresentWait),                  /*default*/
	}
	return rval
}

// PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html
type PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT
	PNext                             unsafe.Pointer
	PrimitiveTopologyListRestart      bool
	PrimitiveTopologyPatchListRestart bool
}

type _vkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT struct {
	sType                             StructureType
	pNext                             unsafe.Pointer
	primitiveTopologyListRestart      Bool32
	primitiveTopologyPatchListRestart Bool32
}

func (s *_vkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT) Goify() *PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
	rval := &PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT{
		PNext:                             (unsafe.Pointer)(s.pNext),
		PrimitiveTopologyListRestart:      translatePublic_Bool32(s.primitiveTopologyListRestart),      /*default*/
		PrimitiveTopologyPatchListRestart: translatePublic_Bool32(s.primitiveTopologyPatchListRestart), /*default*/
	}
	return rval
}
func (s *PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT) Vulkanize() *_vkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT{
		sType:                             STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, /*c1*/
		pNext:                             (unsafe.Pointer)(s.PNext),                                                   /*cb*/
		primitiveTopologyListRestart:      translateInternal_Bool32(s.PrimitiveTopologyListRestart),                    /*default*/
		primitiveTopologyPatchListRestart: translateInternal_Bool32(s.PrimitiveTopologyPatchListRestart),               /*default*/
	}
	return rval
}

// PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.html
type PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT
	PNext                                         unsafe.Pointer
	PrimitivesGeneratedQuery                      bool
	PrimitivesGeneratedQueryWithRasterizerDiscard bool
	PrimitivesGeneratedQueryWithNonZeroStreams    bool
}

type _vkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT struct {
	sType                                         StructureType
	pNext                                         unsafe.Pointer
	primitivesGeneratedQuery                      Bool32
	primitivesGeneratedQueryWithRasterizerDiscard Bool32
	primitivesGeneratedQueryWithNonZeroStreams    Bool32
}

func (s *_vkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT) Goify() *PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
	rval := &PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT{
		PNext:                    (unsafe.Pointer)(s.pNext),
		PrimitivesGeneratedQuery: translatePublic_Bool32(s.primitivesGeneratedQuery), /*default*/
		PrimitivesGeneratedQueryWithRasterizerDiscard: translatePublic_Bool32(s.primitivesGeneratedQueryWithRasterizerDiscard), /*default*/
		PrimitivesGeneratedQueryWithNonZeroStreams:    translatePublic_Bool32(s.primitivesGeneratedQueryWithNonZeroStreams),    /*default*/
	}
	return rval
}
func (s *PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT) Vulkanize() *_vkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT{
		sType:                    STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                              /*cb*/
		primitivesGeneratedQuery: translateInternal_Bool32(s.PrimitivesGeneratedQuery),                   /*default*/
		primitivesGeneratedQueryWithRasterizerDiscard: translateInternal_Bool32(s.PrimitivesGeneratedQueryWithRasterizerDiscard), /*default*/
		primitivesGeneratedQueryWithNonZeroStreams:    translateInternal_Bool32(s.PrimitivesGeneratedQueryWithNonZeroStreams),    /*default*/
	}
	return rval
}

// PhysicalDevicePrivateDataFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrivateDataFeaturesEXT.html
type PhysicalDevicePrivateDataFeaturesEXT struct {
}

type _vkPhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeaturesEXT

func (s *_vkPhysicalDevicePrivateDataFeaturesEXT) Goify() *PhysicalDevicePrivateDataFeaturesEXT {
	rval := (*PhysicalDevicePrivateDataFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDevicePrivateDataFeaturesEXT) Vulkanize() *_vkPhysicalDevicePrivateDataFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDevicePrivateDataFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties.html
type PhysicalDeviceProperties struct {
	ApiVersion        uint32
	DriverVersion     uint32
	VendorID          uint32
	DeviceID          uint32
	DeviceType        PhysicalDeviceType
	DeviceName        string
	PipelineCacheUUID [UUID_SIZE]uint8
	Limits            PhysicalDeviceLimits
	SparseProperties  PhysicalDeviceSparseProperties
}

// WARNING - struct PhysicalDeviceProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceProperties struct {
	apiVersion        uint32
	driverVersion     uint32
	vendorID          uint32
	deviceID          uint32
	deviceType        PhysicalDeviceType
	deviceName        [MAX_PHYSICAL_DEVICE_NAME_SIZE]byte
	pipelineCacheUUID [UUID_SIZE]uint8
	limits            _vkPhysicalDeviceLimits
	sparseProperties  _vkPhysicalDeviceSparseProperties
}

func (s *_vkPhysicalDeviceProperties) Goify() *PhysicalDeviceProperties {
	rval := &PhysicalDeviceProperties{
		ApiVersion:        (uint32)(s.apiVersion),
		DriverVersion:     (uint32)(s.driverVersion),
		VendorID:          (uint32)(s.vendorID),
		DeviceID:          (uint32)(s.deviceID),
		DeviceType:        (PhysicalDeviceType)(s.deviceType),
		DeviceName:        nullTermBytesToString(s.deviceName[:]), /*c arr*/
		PipelineCacheUUID: ([UUID_SIZE]uint8)(s.pipelineCacheUUID),
		Limits:            *(s.limits.Goify()),
		SparseProperties:  *(s.sparseProperties.Goify()),
	}
	return rval
}
func (s *PhysicalDeviceProperties) Vulkanize() *_vkPhysicalDeviceProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceProperties{
		apiVersion:    (uint32)(s.ApiVersion),             /*cb*/
		driverVersion: (uint32)(s.DriverVersion),          /*cb*/
		vendorID:      (uint32)(s.VendorID),               /*cb*/
		deviceID:      (uint32)(s.DeviceID),               /*cb*/
		deviceType:    (PhysicalDeviceType)(s.DeviceType), /*cb*/
		// deviceName : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		pipelineCacheUUID: ([UUID_SIZE]uint8)(s.PipelineCacheUUID), /*cb*/
		limits:            *(s.Limits.Vulkanize()),                 /*c3*/
		sparseProperties:  *(s.SparseProperties.Vulkanize()),       /*c3*/
	}
	return rval
}

// PhysicalDeviceProperties2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties2.html
type PhysicalDeviceProperties2 struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2
	PNext      unsafe.Pointer
	Properties PhysicalDeviceProperties
}

// WARNING - struct PhysicalDeviceProperties2 is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceProperties2 struct {
	sType      StructureType
	pNext      unsafe.Pointer
	properties _vkPhysicalDeviceProperties
}

func (s *_vkPhysicalDeviceProperties2) Goify() *PhysicalDeviceProperties2 {
	rval := &PhysicalDeviceProperties2{
		PNext:      (unsafe.Pointer)(s.pNext),
		Properties: *(s.properties.Goify()),
	}
	return rval
}
func (s *PhysicalDeviceProperties2) Vulkanize() *_vkPhysicalDeviceProperties2 {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceProperties2{
		sType:      STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                   /*cb*/
		properties: *(s.Properties.Vulkanize()),                 /*c3*/
	}
	return rval
}

// PhysicalDeviceProperties2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties2KHR.html
type PhysicalDeviceProperties2KHR struct {
}

type _vkPhysicalDeviceProperties2KHR = PhysicalDeviceProperties2KHR

func (s *_vkPhysicalDeviceProperties2KHR) Goify() *PhysicalDeviceProperties2KHR {
	rval := (*PhysicalDeviceProperties2KHR)(s)
	return rval
}
func (s *PhysicalDeviceProperties2KHR) Vulkanize() *_vkPhysicalDeviceProperties2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceProperties2KHR)(s)
	return rval
}

// PhysicalDeviceProtectedMemoryFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html
type PhysicalDeviceProtectedMemoryFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES
	PNext           unsafe.Pointer
	ProtectedMemory bool
}

type _vkPhysicalDeviceProtectedMemoryFeatures struct {
	sType           StructureType
	pNext           unsafe.Pointer
	protectedMemory Bool32
}

func (s *_vkPhysicalDeviceProtectedMemoryFeatures) Goify() *PhysicalDeviceProtectedMemoryFeatures {
	rval := &PhysicalDeviceProtectedMemoryFeatures{
		PNext:           (unsafe.Pointer)(s.pNext),
		ProtectedMemory: translatePublic_Bool32(s.protectedMemory), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceProtectedMemoryFeatures) Vulkanize() *_vkPhysicalDeviceProtectedMemoryFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceProtectedMemoryFeatures{
		sType:           STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                /*cb*/
		protectedMemory: translateInternal_Bool32(s.ProtectedMemory),              /*default*/
	}
	return rval
}

// PhysicalDeviceProtectedMemoryProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryProperties.html
type PhysicalDeviceProtectedMemoryProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES
	PNext            unsafe.Pointer
	ProtectedNoFault bool
}

// WARNING - struct PhysicalDeviceProtectedMemoryProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceProtectedMemoryProperties struct {
	sType            StructureType
	pNext            unsafe.Pointer
	protectedNoFault Bool32
}

func (s *_vkPhysicalDeviceProtectedMemoryProperties) Goify() *PhysicalDeviceProtectedMemoryProperties {
	rval := &PhysicalDeviceProtectedMemoryProperties{
		PNext:            (unsafe.Pointer)(s.pNext),
		ProtectedNoFault: translatePublic_Bool32(s.protectedNoFault), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceProtectedMemoryProperties) Vulkanize() *_vkPhysicalDeviceProtectedMemoryProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceProtectedMemoryProperties{
		sType:            STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                  /*cb*/
		protectedNoFault: translateInternal_Bool32(s.ProtectedNoFault),               /*default*/
	}
	return rval
}

// PhysicalDeviceProvokingVertexFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html
type PhysicalDeviceProvokingVertexFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT
	PNext                                     unsafe.Pointer
	ProvokingVertexLast                       bool
	TransformFeedbackPreservesProvokingVertex bool
}

type _vkPhysicalDeviceProvokingVertexFeaturesEXT struct {
	sType                                     StructureType
	pNext                                     unsafe.Pointer
	provokingVertexLast                       Bool32
	transformFeedbackPreservesProvokingVertex Bool32
}

func (s *_vkPhysicalDeviceProvokingVertexFeaturesEXT) Goify() *PhysicalDeviceProvokingVertexFeaturesEXT {
	rval := &PhysicalDeviceProvokingVertexFeaturesEXT{
		PNext:               (unsafe.Pointer)(s.pNext),
		ProvokingVertexLast: translatePublic_Bool32(s.provokingVertexLast), /*default*/
		TransformFeedbackPreservesProvokingVertex: translatePublic_Bool32(s.transformFeedbackPreservesProvokingVertex), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceProvokingVertexFeaturesEXT) Vulkanize() *_vkPhysicalDeviceProvokingVertexFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceProvokingVertexFeaturesEXT{
		sType:               STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                    /*cb*/
		provokingVertexLast: translateInternal_Bool32(s.ProvokingVertexLast),              /*default*/
		transformFeedbackPreservesProvokingVertex: translateInternal_Bool32(s.TransformFeedbackPreservesProvokingVertex), /*default*/
	}
	return rval
}

// PhysicalDeviceProvokingVertexPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html
type PhysicalDeviceProvokingVertexPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT
	PNext                                                unsafe.Pointer
	ProvokingVertexModePerPipeline                       bool
	TransformFeedbackPreservesTriangleFanProvokingVertex bool
}

// WARNING - struct PhysicalDeviceProvokingVertexPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceProvokingVertexPropertiesEXT struct {
	sType                                                StructureType
	pNext                                                unsafe.Pointer
	provokingVertexModePerPipeline                       Bool32
	transformFeedbackPreservesTriangleFanProvokingVertex Bool32
}

func (s *_vkPhysicalDeviceProvokingVertexPropertiesEXT) Goify() *PhysicalDeviceProvokingVertexPropertiesEXT {
	rval := &PhysicalDeviceProvokingVertexPropertiesEXT{
		PNext:                          (unsafe.Pointer)(s.pNext),
		ProvokingVertexModePerPipeline: translatePublic_Bool32(s.provokingVertexModePerPipeline), /*default*/
		TransformFeedbackPreservesTriangleFanProvokingVertex: translatePublic_Bool32(s.transformFeedbackPreservesTriangleFanProvokingVertex), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceProvokingVertexPropertiesEXT) Vulkanize() *_vkPhysicalDeviceProvokingVertexPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceProvokingVertexPropertiesEXT{
		sType:                          STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT, /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                      /*cb*/
		provokingVertexModePerPipeline: translateInternal_Bool32(s.ProvokingVertexModePerPipeline),     /*default*/
		transformFeedbackPreservesTriangleFanProvokingVertex: translateInternal_Bool32(s.TransformFeedbackPreservesTriangleFanProvokingVertex), /*default*/
	}
	return rval
}

// PhysicalDevicePushDescriptorPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html
type PhysicalDevicePushDescriptorPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR
	PNext              unsafe.Pointer
	MaxPushDescriptors uint32
}

// WARNING - struct PhysicalDevicePushDescriptorPropertiesKHR is returned only, which is not yet handled in the binding
type _vkPhysicalDevicePushDescriptorPropertiesKHR struct {
	sType              StructureType
	pNext              unsafe.Pointer
	maxPushDescriptors uint32
}

func (s *_vkPhysicalDevicePushDescriptorPropertiesKHR) Goify() *PhysicalDevicePushDescriptorPropertiesKHR {
	rval := &PhysicalDevicePushDescriptorPropertiesKHR{
		PNext:              (unsafe.Pointer)(s.pNext),
		MaxPushDescriptors: (uint32)(s.maxPushDescriptors),
	}
	return rval
}
func (s *PhysicalDevicePushDescriptorPropertiesKHR) Vulkanize() *_vkPhysicalDevicePushDescriptorPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDevicePushDescriptorPropertiesKHR{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                     /*cb*/
		maxPushDescriptors: (uint32)(s.MaxPushDescriptors),                                /*cb*/
	}
	return rval
}

// PhysicalDeviceRGBA10X6FormatsFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.html
type PhysicalDeviceRGBA10X6FormatsFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT
	PNext                             unsafe.Pointer
	FormatRgba10x6WithoutYCbCrSampler bool
}

type _vkPhysicalDeviceRGBA10X6FormatsFeaturesEXT struct {
	sType                             StructureType
	pNext                             unsafe.Pointer
	formatRgba10x6WithoutYCbCrSampler Bool32
}

func (s *_vkPhysicalDeviceRGBA10X6FormatsFeaturesEXT) Goify() *PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
	rval := &PhysicalDeviceRGBA10X6FormatsFeaturesEXT{
		PNext:                             (unsafe.Pointer)(s.pNext),
		FormatRgba10x6WithoutYCbCrSampler: translatePublic_Bool32(s.formatRgba10x6WithoutYCbCrSampler), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRGBA10X6FormatsFeaturesEXT) Vulkanize() *_vkPhysicalDeviceRGBA10X6FormatsFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRGBA10X6FormatsFeaturesEXT{
		sType:                             STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT,  /*c1*/
		pNext:                             (unsafe.Pointer)(s.PNext),                                     /*cb*/
		formatRgba10x6WithoutYCbCrSampler: translateInternal_Bool32(s.FormatRgba10x6WithoutYCbCrSampler), /*default*/
	}
	return rval
}

// PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.html
type PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM struct {
}

type _vkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM

func (s *_vkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM) Goify() *PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
	rval := (*PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)(s)
	return rval
}
func (s *PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM) Vulkanize() *_vkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)(s)
	return rval
}

// PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.html
type PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT
	PNext                                     unsafe.Pointer
	RasterizationOrderColorAttachmentAccess   bool
	RasterizationOrderDepthAttachmentAccess   bool
	RasterizationOrderStencilAttachmentAccess bool
}

type _vkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT struct {
	sType                                     StructureType
	pNext                                     unsafe.Pointer
	rasterizationOrderColorAttachmentAccess   Bool32
	rasterizationOrderDepthAttachmentAccess   Bool32
	rasterizationOrderStencilAttachmentAccess Bool32
}

func (s *_vkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT) Goify() *PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
	rval := &PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT{
		PNext:                                     (unsafe.Pointer)(s.pNext),
		RasterizationOrderColorAttachmentAccess:   translatePublic_Bool32(s.rasterizationOrderColorAttachmentAccess),   /*default*/
		RasterizationOrderDepthAttachmentAccess:   translatePublic_Bool32(s.rasterizationOrderDepthAttachmentAccess),   /*default*/
		RasterizationOrderStencilAttachmentAccess: translatePublic_Bool32(s.rasterizationOrderStencilAttachmentAccess), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT) Vulkanize() *_vkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT{
		sType:                                   STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, /*c1*/
		pNext:                                   (unsafe.Pointer)(s.PNext),                                                         /*cb*/
		rasterizationOrderColorAttachmentAccess: translateInternal_Bool32(s.RasterizationOrderColorAttachmentAccess),               /*default*/
		rasterizationOrderDepthAttachmentAccess: translateInternal_Bool32(s.RasterizationOrderDepthAttachmentAccess),               /*default*/
		rasterizationOrderStencilAttachmentAccess: translateInternal_Bool32(s.RasterizationOrderStencilAttachmentAccess), /*default*/
	}
	return rval
}

// PhysicalDeviceRayQueryFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html
type PhysicalDeviceRayQueryFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR
	PNext    unsafe.Pointer
	RayQuery bool
}

type _vkPhysicalDeviceRayQueryFeaturesKHR struct {
	sType    StructureType
	pNext    unsafe.Pointer
	rayQuery Bool32
}

func (s *_vkPhysicalDeviceRayQueryFeaturesKHR) Goify() *PhysicalDeviceRayQueryFeaturesKHR {
	rval := &PhysicalDeviceRayQueryFeaturesKHR{
		PNext:    (unsafe.Pointer)(s.pNext),
		RayQuery: translatePublic_Bool32(s.rayQuery), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRayQueryFeaturesKHR) Vulkanize() *_vkPhysicalDeviceRayQueryFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRayQueryFeaturesKHR{
		sType:    STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                             /*cb*/
		rayQuery: translateInternal_Bool32(s.RayQuery),                  /*default*/
	}
	return rval
}

// PhysicalDeviceRayTracingInvocationReorderFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.html
type PhysicalDeviceRayTracingInvocationReorderFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV
	PNext                       unsafe.Pointer
	RayTracingInvocationReorder bool
}

type _vkPhysicalDeviceRayTracingInvocationReorderFeaturesNV struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	rayTracingInvocationReorder Bool32
}

func (s *_vkPhysicalDeviceRayTracingInvocationReorderFeaturesNV) Goify() *PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
	rval := &PhysicalDeviceRayTracingInvocationReorderFeaturesNV{
		PNext:                       (unsafe.Pointer)(s.pNext),
		RayTracingInvocationReorder: translatePublic_Bool32(s.rayTracingInvocationReorder), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRayTracingInvocationReorderFeaturesNV) Vulkanize() *_vkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRayTracingInvocationReorderFeaturesNV{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                                 /*cb*/
		rayTracingInvocationReorder: translateInternal_Bool32(s.RayTracingInvocationReorder),                   /*default*/
	}
	return rval
}

// PhysicalDeviceRayTracingInvocationReorderPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.html
type PhysicalDeviceRayTracingInvocationReorderPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV
	PNext                                     unsafe.Pointer
	RayTracingInvocationReorderReorderingHint RayTracingInvocationReorderModeNV
}

// WARNING - struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceRayTracingInvocationReorderPropertiesNV struct {
	sType                                     StructureType
	pNext                                     unsafe.Pointer
	rayTracingInvocationReorderReorderingHint RayTracingInvocationReorderModeNV
}

func (s *_vkPhysicalDeviceRayTracingInvocationReorderPropertiesNV) Goify() *PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
	rval := &PhysicalDeviceRayTracingInvocationReorderPropertiesNV{
		PNext: (unsafe.Pointer)(s.pNext),
		RayTracingInvocationReorderReorderingHint: (RayTracingInvocationReorderModeNV)(s.rayTracingInvocationReorderReorderingHint),
	}
	return rval
}
func (s *PhysicalDeviceRayTracingInvocationReorderPropertiesNV) Vulkanize() *_vkPhysicalDeviceRayTracingInvocationReorderPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRayTracingInvocationReorderPropertiesNV{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                                   /*cb*/
		rayTracingInvocationReorderReorderingHint: (RayTracingInvocationReorderModeNV)(s.RayTracingInvocationReorderReorderingHint), /*cb*/
	}
	return rval
}

// PhysicalDeviceRayTracingMaintenance1FeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.html
type PhysicalDeviceRayTracingMaintenance1FeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR
	PNext                                unsafe.Pointer
	RayTracingMaintenance1               bool
	RayTracingPipelineTraceRaysIndirect2 bool
}

type _vkPhysicalDeviceRayTracingMaintenance1FeaturesKHR struct {
	sType                                StructureType
	pNext                                unsafe.Pointer
	rayTracingMaintenance1               Bool32
	rayTracingPipelineTraceRaysIndirect2 Bool32
}

func (s *_vkPhysicalDeviceRayTracingMaintenance1FeaturesKHR) Goify() *PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
	rval := &PhysicalDeviceRayTracingMaintenance1FeaturesKHR{
		PNext:                                (unsafe.Pointer)(s.pNext),
		RayTracingMaintenance1:               translatePublic_Bool32(s.rayTracingMaintenance1),               /*default*/
		RayTracingPipelineTraceRaysIndirect2: translatePublic_Bool32(s.rayTracingPipelineTraceRaysIndirect2), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRayTracingMaintenance1FeaturesKHR) Vulkanize() *_vkPhysicalDeviceRayTracingMaintenance1FeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRayTracingMaintenance1FeaturesKHR{
		sType:                                STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, /*c1*/
		pNext:                                (unsafe.Pointer)(s.PNext),                                             /*cb*/
		rayTracingMaintenance1:               translateInternal_Bool32(s.RayTracingMaintenance1),                    /*default*/
		rayTracingPipelineTraceRaysIndirect2: translateInternal_Bool32(s.RayTracingPipelineTraceRaysIndirect2),      /*default*/
	}
	return rval
}

// PhysicalDeviceRayTracingMotionBlurFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html
type PhysicalDeviceRayTracingMotionBlurFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV
	PNext                                         unsafe.Pointer
	RayTracingMotionBlur                          bool
	RayTracingMotionBlurPipelineTraceRaysIndirect bool
}

type _vkPhysicalDeviceRayTracingMotionBlurFeaturesNV struct {
	sType                                         StructureType
	pNext                                         unsafe.Pointer
	rayTracingMotionBlur                          Bool32
	rayTracingMotionBlurPipelineTraceRaysIndirect Bool32
}

func (s *_vkPhysicalDeviceRayTracingMotionBlurFeaturesNV) Goify() *PhysicalDeviceRayTracingMotionBlurFeaturesNV {
	rval := &PhysicalDeviceRayTracingMotionBlurFeaturesNV{
		PNext:                (unsafe.Pointer)(s.pNext),
		RayTracingMotionBlur: translatePublic_Bool32(s.rayTracingMotionBlur), /*default*/
		RayTracingMotionBlurPipelineTraceRaysIndirect: translatePublic_Bool32(s.rayTracingMotionBlurPipelineTraceRaysIndirect), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRayTracingMotionBlurFeaturesNV) Vulkanize() *_vkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRayTracingMotionBlurFeaturesNV{
		sType:                STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                          /*cb*/
		rayTracingMotionBlur: translateInternal_Bool32(s.RayTracingMotionBlur),                   /*default*/
		rayTracingMotionBlurPipelineTraceRaysIndirect: translateInternal_Bool32(s.RayTracingMotionBlurPipelineTraceRaysIndirect), /*default*/
	}
	return rval
}

// PhysicalDeviceRayTracingPipelineFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html
type PhysicalDeviceRayTracingPipelineFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR
	PNext                                                 unsafe.Pointer
	RayTracingPipeline                                    bool
	RayTracingPipelineShaderGroupHandleCaptureReplay      bool
	RayTracingPipelineShaderGroupHandleCaptureReplayMixed bool
	RayTracingPipelineTraceRaysIndirect                   bool
	RayTraversalPrimitiveCulling                          bool
}

type _vkPhysicalDeviceRayTracingPipelineFeaturesKHR struct {
	sType                                                 StructureType
	pNext                                                 unsafe.Pointer
	rayTracingPipeline                                    Bool32
	rayTracingPipelineShaderGroupHandleCaptureReplay      Bool32
	rayTracingPipelineShaderGroupHandleCaptureReplayMixed Bool32
	rayTracingPipelineTraceRaysIndirect                   Bool32
	rayTraversalPrimitiveCulling                          Bool32
}

func (s *_vkPhysicalDeviceRayTracingPipelineFeaturesKHR) Goify() *PhysicalDeviceRayTracingPipelineFeaturesKHR {
	rval := &PhysicalDeviceRayTracingPipelineFeaturesKHR{
		PNext:              (unsafe.Pointer)(s.pNext),
		RayTracingPipeline: translatePublic_Bool32(s.rayTracingPipeline), /*default*/
		RayTracingPipelineShaderGroupHandleCaptureReplay:      translatePublic_Bool32(s.rayTracingPipelineShaderGroupHandleCaptureReplay),      /*default*/
		RayTracingPipelineShaderGroupHandleCaptureReplayMixed: translatePublic_Bool32(s.rayTracingPipelineShaderGroupHandleCaptureReplayMixed), /*default*/
		RayTracingPipelineTraceRaysIndirect:                   translatePublic_Bool32(s.rayTracingPipelineTraceRaysIndirect),                   /*default*/
		RayTraversalPrimitiveCulling:                          translatePublic_Bool32(s.rayTraversalPrimitiveCulling),                          /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRayTracingPipelineFeaturesKHR) Vulkanize() *_vkPhysicalDeviceRayTracingPipelineFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRayTracingPipelineFeaturesKHR{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                        /*cb*/
		rayTracingPipeline: translateInternal_Bool32(s.RayTracingPipeline),                   /*default*/
		rayTracingPipelineShaderGroupHandleCaptureReplay:      translateInternal_Bool32(s.RayTracingPipelineShaderGroupHandleCaptureReplay),      /*default*/
		rayTracingPipelineShaderGroupHandleCaptureReplayMixed: translateInternal_Bool32(s.RayTracingPipelineShaderGroupHandleCaptureReplayMixed), /*default*/
		rayTracingPipelineTraceRaysIndirect:                   translateInternal_Bool32(s.RayTracingPipelineTraceRaysIndirect),                   /*default*/
		rayTraversalPrimitiveCulling:                          translateInternal_Bool32(s.RayTraversalPrimitiveCulling),                          /*default*/
	}
	return rval
}

// PhysicalDeviceRayTracingPipelinePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html
type PhysicalDeviceRayTracingPipelinePropertiesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR
	PNext                              unsafe.Pointer
	ShaderGroupHandleSize              uint32
	MaxRayRecursionDepth               uint32
	MaxShaderGroupStride               uint32
	ShaderGroupBaseAlignment           uint32
	ShaderGroupHandleCaptureReplaySize uint32
	MaxRayDispatchInvocationCount      uint32
	ShaderGroupHandleAlignment         uint32
	MaxRayHitAttributeSize             uint32
}

// WARNING - struct PhysicalDeviceRayTracingPipelinePropertiesKHR is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceRayTracingPipelinePropertiesKHR struct {
	sType                              StructureType
	pNext                              unsafe.Pointer
	shaderGroupHandleSize              uint32
	maxRayRecursionDepth               uint32
	maxShaderGroupStride               uint32
	shaderGroupBaseAlignment           uint32
	shaderGroupHandleCaptureReplaySize uint32
	maxRayDispatchInvocationCount      uint32
	shaderGroupHandleAlignment         uint32
	maxRayHitAttributeSize             uint32
}

func (s *_vkPhysicalDeviceRayTracingPipelinePropertiesKHR) Goify() *PhysicalDeviceRayTracingPipelinePropertiesKHR {
	rval := &PhysicalDeviceRayTracingPipelinePropertiesKHR{
		PNext:                              (unsafe.Pointer)(s.pNext),
		ShaderGroupHandleSize:              (uint32)(s.shaderGroupHandleSize),
		MaxRayRecursionDepth:               (uint32)(s.maxRayRecursionDepth),
		MaxShaderGroupStride:               (uint32)(s.maxShaderGroupStride),
		ShaderGroupBaseAlignment:           (uint32)(s.shaderGroupBaseAlignment),
		ShaderGroupHandleCaptureReplaySize: (uint32)(s.shaderGroupHandleCaptureReplaySize),
		MaxRayDispatchInvocationCount:      (uint32)(s.maxRayDispatchInvocationCount),
		ShaderGroupHandleAlignment:         (uint32)(s.shaderGroupHandleAlignment),
		MaxRayHitAttributeSize:             (uint32)(s.maxRayHitAttributeSize),
	}
	return rval
}
func (s *PhysicalDeviceRayTracingPipelinePropertiesKHR) Vulkanize() *_vkPhysicalDeviceRayTracingPipelinePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRayTracingPipelinePropertiesKHR{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR, /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                          /*cb*/
		shaderGroupHandleSize:              (uint32)(s.ShaderGroupHandleSize),                                  /*cb*/
		maxRayRecursionDepth:               (uint32)(s.MaxRayRecursionDepth),                                   /*cb*/
		maxShaderGroupStride:               (uint32)(s.MaxShaderGroupStride),                                   /*cb*/
		shaderGroupBaseAlignment:           (uint32)(s.ShaderGroupBaseAlignment),                               /*cb*/
		shaderGroupHandleCaptureReplaySize: (uint32)(s.ShaderGroupHandleCaptureReplaySize),                     /*cb*/
		maxRayDispatchInvocationCount:      (uint32)(s.MaxRayDispatchInvocationCount),                          /*cb*/
		shaderGroupHandleAlignment:         (uint32)(s.ShaderGroupHandleAlignment),                             /*cb*/
		maxRayHitAttributeSize:             (uint32)(s.MaxRayHitAttributeSize),                                 /*cb*/
	}
	return rval
}

// PhysicalDeviceRayTracingPositionFetchFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.html
type PhysicalDeviceRayTracingPositionFetchFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR
	PNext                   unsafe.Pointer
	RayTracingPositionFetch bool
}

type _vkPhysicalDeviceRayTracingPositionFetchFeaturesKHR struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	rayTracingPositionFetch Bool32
}

func (s *_vkPhysicalDeviceRayTracingPositionFetchFeaturesKHR) Goify() *PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
	rval := &PhysicalDeviceRayTracingPositionFetchFeaturesKHR{
		PNext:                   (unsafe.Pointer)(s.pNext),
		RayTracingPositionFetch: translatePublic_Bool32(s.rayTracingPositionFetch), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRayTracingPositionFetchFeaturesKHR) Vulkanize() *_vkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRayTracingPositionFetchFeaturesKHR{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                              /*cb*/
		rayTracingPositionFetch: translateInternal_Bool32(s.RayTracingPositionFetch),                    /*default*/
	}
	return rval
}

// PhysicalDeviceRayTracingPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html
type PhysicalDeviceRayTracingPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV
	PNext                                  unsafe.Pointer
	ShaderGroupHandleSize                  uint32
	MaxRecursionDepth                      uint32
	MaxShaderGroupStride                   uint32
	ShaderGroupBaseAlignment               uint32
	MaxGeometryCount                       uint64
	MaxInstanceCount                       uint64
	MaxTriangleCount                       uint64
	MaxDescriptorSetAccelerationStructures uint32
}

// WARNING - struct PhysicalDeviceRayTracingPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceRayTracingPropertiesNV struct {
	sType                                  StructureType
	pNext                                  unsafe.Pointer
	shaderGroupHandleSize                  uint32
	maxRecursionDepth                      uint32
	maxShaderGroupStride                   uint32
	shaderGroupBaseAlignment               uint32
	maxGeometryCount                       uint64
	maxInstanceCount                       uint64
	maxTriangleCount                       uint64
	maxDescriptorSetAccelerationStructures uint32
}

func (s *_vkPhysicalDeviceRayTracingPropertiesNV) Goify() *PhysicalDeviceRayTracingPropertiesNV {
	rval := &PhysicalDeviceRayTracingPropertiesNV{
		PNext:                                  (unsafe.Pointer)(s.pNext),
		ShaderGroupHandleSize:                  (uint32)(s.shaderGroupHandleSize),
		MaxRecursionDepth:                      (uint32)(s.maxRecursionDepth),
		MaxShaderGroupStride:                   (uint32)(s.maxShaderGroupStride),
		ShaderGroupBaseAlignment:               (uint32)(s.shaderGroupBaseAlignment),
		MaxGeometryCount:                       (uint64)(s.maxGeometryCount),
		MaxInstanceCount:                       (uint64)(s.maxInstanceCount),
		MaxTriangleCount:                       (uint64)(s.maxTriangleCount),
		MaxDescriptorSetAccelerationStructures: (uint32)(s.maxDescriptorSetAccelerationStructures),
	}
	return rval
}
func (s *PhysicalDeviceRayTracingPropertiesNV) Vulkanize() *_vkPhysicalDeviceRayTracingPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRayTracingPropertiesNV{
		sType:                                  STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV, /*c1*/
		pNext:                                  (unsafe.Pointer)(s.PNext),                                /*cb*/
		shaderGroupHandleSize:                  (uint32)(s.ShaderGroupHandleSize),                        /*cb*/
		maxRecursionDepth:                      (uint32)(s.MaxRecursionDepth),                            /*cb*/
		maxShaderGroupStride:                   (uint32)(s.MaxShaderGroupStride),                         /*cb*/
		shaderGroupBaseAlignment:               (uint32)(s.ShaderGroupBaseAlignment),                     /*cb*/
		maxGeometryCount:                       (uint64)(s.MaxGeometryCount),                             /*cb*/
		maxInstanceCount:                       (uint64)(s.MaxInstanceCount),                             /*cb*/
		maxTriangleCount:                       (uint64)(s.MaxTriangleCount),                             /*cb*/
		maxDescriptorSetAccelerationStructures: (uint32)(s.MaxDescriptorSetAccelerationStructures),       /*cb*/
	}
	return rval
}

// PhysicalDeviceRelaxedLineRasterizationFeaturesIMG: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.html
type PhysicalDeviceRelaxedLineRasterizationFeaturesIMG struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG
	PNext                    unsafe.Pointer
	RelaxedLineRasterization bool
}

type _vkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	relaxedLineRasterization Bool32
}

func (s *_vkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG) Goify() *PhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
	rval := &PhysicalDeviceRelaxedLineRasterizationFeaturesIMG{
		PNext:                    (unsafe.Pointer)(s.pNext),
		RelaxedLineRasterization: translatePublic_Bool32(s.relaxedLineRasterization), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRelaxedLineRasterizationFeaturesIMG) Vulkanize() *_vkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG{
		sType:                    STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                              /*cb*/
		relaxedLineRasterization: translateInternal_Bool32(s.RelaxedLineRasterization),                   /*default*/
	}
	return rval
}

// PhysicalDeviceRepresentativeFragmentTestFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html
type PhysicalDeviceRepresentativeFragmentTestFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV
	PNext                      unsafe.Pointer
	RepresentativeFragmentTest bool
}

type _vkPhysicalDeviceRepresentativeFragmentTestFeaturesNV struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	representativeFragmentTest Bool32
}

func (s *_vkPhysicalDeviceRepresentativeFragmentTestFeaturesNV) Goify() *PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
	rval := &PhysicalDeviceRepresentativeFragmentTestFeaturesNV{
		PNext:                      (unsafe.Pointer)(s.pNext),
		RepresentativeFragmentTest: translatePublic_Bool32(s.representativeFragmentTest), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRepresentativeFragmentTestFeaturesNV) Vulkanize() *_vkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRepresentativeFragmentTestFeaturesNV{
		sType:                      STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                               /*cb*/
		representativeFragmentTest: translateInternal_Bool32(s.RepresentativeFragmentTest),                  /*default*/
	}
	return rval
}

// PhysicalDeviceRobustness2FeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html
type PhysicalDeviceRobustness2FeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT
	PNext               unsafe.Pointer
	RobustBufferAccess2 bool
	RobustImageAccess2  bool
	NullDescriptor      bool
}

type _vkPhysicalDeviceRobustness2FeaturesEXT struct {
	sType               StructureType
	pNext               unsafe.Pointer
	robustBufferAccess2 Bool32
	robustImageAccess2  Bool32
	nullDescriptor      Bool32
}

func (s *_vkPhysicalDeviceRobustness2FeaturesEXT) Goify() *PhysicalDeviceRobustness2FeaturesEXT {
	rval := &PhysicalDeviceRobustness2FeaturesEXT{
		PNext:               (unsafe.Pointer)(s.pNext),
		RobustBufferAccess2: translatePublic_Bool32(s.robustBufferAccess2), /*default*/
		RobustImageAccess2:  translatePublic_Bool32(s.robustImageAccess2),  /*default*/
		NullDescriptor:      translatePublic_Bool32(s.nullDescriptor),      /*default*/
	}
	return rval
}
func (s *PhysicalDeviceRobustness2FeaturesEXT) Vulkanize() *_vkPhysicalDeviceRobustness2FeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRobustness2FeaturesEXT{
		sType:               STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                /*cb*/
		robustBufferAccess2: translateInternal_Bool32(s.RobustBufferAccess2),          /*default*/
		robustImageAccess2:  translateInternal_Bool32(s.RobustImageAccess2),           /*default*/
		nullDescriptor:      translateInternal_Bool32(s.NullDescriptor),               /*default*/
	}
	return rval
}

// PhysicalDeviceRobustness2PropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html
type PhysicalDeviceRobustness2PropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT
	PNext                                  unsafe.Pointer
	RobustStorageBufferAccessSizeAlignment DeviceSize
	RobustUniformBufferAccessSizeAlignment DeviceSize
}

// WARNING - struct PhysicalDeviceRobustness2PropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceRobustness2PropertiesEXT struct {
	sType                                  StructureType
	pNext                                  unsafe.Pointer
	robustStorageBufferAccessSizeAlignment DeviceSize
	robustUniformBufferAccessSizeAlignment DeviceSize
}

func (s *_vkPhysicalDeviceRobustness2PropertiesEXT) Goify() *PhysicalDeviceRobustness2PropertiesEXT {
	rval := &PhysicalDeviceRobustness2PropertiesEXT{
		PNext:                                  (unsafe.Pointer)(s.pNext),
		RobustStorageBufferAccessSizeAlignment: (DeviceSize)(s.robustStorageBufferAccessSizeAlignment),
		RobustUniformBufferAccessSizeAlignment: (DeviceSize)(s.robustUniformBufferAccessSizeAlignment),
	}
	return rval
}
func (s *PhysicalDeviceRobustness2PropertiesEXT) Vulkanize() *_vkPhysicalDeviceRobustness2PropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceRobustness2PropertiesEXT{
		sType:                                  STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, /*c1*/
		pNext:                                  (unsafe.Pointer)(s.PNext),                                  /*cb*/
		robustStorageBufferAccessSizeAlignment: (DeviceSize)(s.RobustStorageBufferAccessSizeAlignment),     /*cb*/
		robustUniformBufferAccessSizeAlignment: (DeviceSize)(s.RobustUniformBufferAccessSizeAlignment),     /*cb*/
	}
	return rval
}

// PhysicalDeviceSampleLocationsPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html
type PhysicalDeviceSampleLocationsPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT
	PNext                         unsafe.Pointer
	SampleLocationSampleCounts    SampleCountFlags
	MaxSampleLocationGridSize     Extent2D
	SampleLocationCoordinateRange [2]float32
	SampleLocationSubPixelBits    uint32
	VariableSampleLocations       bool
}

// WARNING - struct PhysicalDeviceSampleLocationsPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceSampleLocationsPropertiesEXT struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	sampleLocationSampleCounts    SampleCountFlags
	maxSampleLocationGridSize     _vkExtent2D
	sampleLocationCoordinateRange [2]float32
	sampleLocationSubPixelBits    uint32
	variableSampleLocations       Bool32
}

func (s *_vkPhysicalDeviceSampleLocationsPropertiesEXT) Goify() *PhysicalDeviceSampleLocationsPropertiesEXT {
	rval := &PhysicalDeviceSampleLocationsPropertiesEXT{
		PNext:                         (unsafe.Pointer)(s.pNext),
		SampleLocationSampleCounts:    (SampleCountFlags)(s.sampleLocationSampleCounts),
		MaxSampleLocationGridSize:     (Extent2D)(s.maxSampleLocationGridSize),
		SampleLocationCoordinateRange: ([2]float32)(s.sampleLocationCoordinateRange),
		SampleLocationSubPixelBits:    (uint32)(s.sampleLocationSubPixelBits),
		VariableSampleLocations:       translatePublic_Bool32(s.variableSampleLocations), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSampleLocationsPropertiesEXT) Vulkanize() *_vkPhysicalDeviceSampleLocationsPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSampleLocationsPropertiesEXT{
		sType:                         STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                      /*cb*/
		sampleLocationSampleCounts:    (SampleCountFlags)(s.SampleLocationSampleCounts),               /*cb*/
		maxSampleLocationGridSize:     (_vkExtent2D)(s.MaxSampleLocationGridSize),                     /*cb*/
		sampleLocationCoordinateRange: ([2]float32)(s.SampleLocationCoordinateRange),                  /*cb*/
		sampleLocationSubPixelBits:    (uint32)(s.SampleLocationSubPixelBits),                         /*cb*/
		variableSampleLocations:       translateInternal_Bool32(s.VariableSampleLocations),            /*default*/
	}
	return rval
}

// PhysicalDeviceSamplerFilterMinmaxProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html
type PhysicalDeviceSamplerFilterMinmaxProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES
	PNext                              unsafe.Pointer
	FilterMinmaxSingleComponentFormats bool
	FilterMinmaxImageComponentMapping  bool
}

// WARNING - struct PhysicalDeviceSamplerFilterMinmaxProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceSamplerFilterMinmaxProperties struct {
	sType                              StructureType
	pNext                              unsafe.Pointer
	filterMinmaxSingleComponentFormats Bool32
	filterMinmaxImageComponentMapping  Bool32
}

func (s *_vkPhysicalDeviceSamplerFilterMinmaxProperties) Goify() *PhysicalDeviceSamplerFilterMinmaxProperties {
	rval := &PhysicalDeviceSamplerFilterMinmaxProperties{
		PNext:                              (unsafe.Pointer)(s.pNext),
		FilterMinmaxSingleComponentFormats: translatePublic_Bool32(s.filterMinmaxSingleComponentFormats), /*default*/
		FilterMinmaxImageComponentMapping:  translatePublic_Bool32(s.filterMinmaxImageComponentMapping),  /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSamplerFilterMinmaxProperties) Vulkanize() *_vkPhysicalDeviceSamplerFilterMinmaxProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSamplerFilterMinmaxProperties{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                       /*cb*/
		filterMinmaxSingleComponentFormats: translateInternal_Bool32(s.FilterMinmaxSingleComponentFormats),  /*default*/
		filterMinmaxImageComponentMapping:  translateInternal_Bool32(s.FilterMinmaxImageComponentMapping),   /*default*/
	}
	return rval
}

// PhysicalDeviceSamplerFilterMinmaxPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT.html
type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT struct {
}

type _vkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxPropertiesEXT

func (s *_vkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT) Goify() *PhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
	rval := (*PhysicalDeviceSamplerFilterMinmaxPropertiesEXT)(s)
	return rval
}
func (s *PhysicalDeviceSamplerFilterMinmaxPropertiesEXT) Vulkanize() *_vkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)(s)
	return rval
}

// PhysicalDeviceSamplerYcbcrConversionFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html
type PhysicalDeviceSamplerYcbcrConversionFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES
	PNext unsafe.Pointer
	//  Sampler color conversion supported;
	SamplerYcbcrConversion bool
}

type _vkPhysicalDeviceSamplerYcbcrConversionFeatures struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	samplerYcbcrConversion Bool32
}

func (s *_vkPhysicalDeviceSamplerYcbcrConversionFeatures) Goify() *PhysicalDeviceSamplerYcbcrConversionFeatures {
	rval := &PhysicalDeviceSamplerYcbcrConversionFeatures{
		PNext:                  (unsafe.Pointer)(s.pNext),
		SamplerYcbcrConversion: translatePublic_Bool32(s.samplerYcbcrConversion), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSamplerYcbcrConversionFeatures) Vulkanize() *_vkPhysicalDeviceSamplerYcbcrConversionFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSamplerYcbcrConversionFeatures{
		sType:                  STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                        /*cb*/
		samplerYcbcrConversion: translateInternal_Bool32(s.SamplerYcbcrConversion),               /*default*/
	}
	return rval
}

// PhysicalDeviceSamplerYcbcrConversionFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR.html
type PhysicalDeviceSamplerYcbcrConversionFeaturesKHR struct {
}

type _vkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeaturesKHR

func (s *_vkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR) Goify() *PhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
	rval := (*PhysicalDeviceSamplerYcbcrConversionFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceSamplerYcbcrConversionFeaturesKHR) Vulkanize() *_vkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceScalarBlockLayoutFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html
type PhysicalDeviceScalarBlockLayoutFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES
	PNext             unsafe.Pointer
	ScalarBlockLayout bool
}

type _vkPhysicalDeviceScalarBlockLayoutFeatures struct {
	sType             StructureType
	pNext             unsafe.Pointer
	scalarBlockLayout Bool32
}

func (s *_vkPhysicalDeviceScalarBlockLayoutFeatures) Goify() *PhysicalDeviceScalarBlockLayoutFeatures {
	rval := &PhysicalDeviceScalarBlockLayoutFeatures{
		PNext:             (unsafe.Pointer)(s.pNext),
		ScalarBlockLayout: translatePublic_Bool32(s.scalarBlockLayout), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceScalarBlockLayoutFeatures) Vulkanize() *_vkPhysicalDeviceScalarBlockLayoutFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceScalarBlockLayoutFeatures{
		sType:             STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                   /*cb*/
		scalarBlockLayout: translateInternal_Bool32(s.ScalarBlockLayout),               /*default*/
	}
	return rval
}

// PhysicalDeviceScalarBlockLayoutFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceScalarBlockLayoutFeaturesEXT.html
type PhysicalDeviceScalarBlockLayoutFeaturesEXT struct {
}

type _vkPhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeaturesEXT

func (s *_vkPhysicalDeviceScalarBlockLayoutFeaturesEXT) Goify() *PhysicalDeviceScalarBlockLayoutFeaturesEXT {
	rval := (*PhysicalDeviceScalarBlockLayoutFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceScalarBlockLayoutFeaturesEXT) Vulkanize() *_vkPhysicalDeviceScalarBlockLayoutFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceScalarBlockLayoutFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceSchedulingControlsFeaturesARM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSchedulingControlsFeaturesARM.html
type PhysicalDeviceSchedulingControlsFeaturesARM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM
	PNext              unsafe.Pointer
	SchedulingControls bool
}

type _vkPhysicalDeviceSchedulingControlsFeaturesARM struct {
	sType              StructureType
	pNext              unsafe.Pointer
	schedulingControls Bool32
}

func (s *_vkPhysicalDeviceSchedulingControlsFeaturesARM) Goify() *PhysicalDeviceSchedulingControlsFeaturesARM {
	rval := &PhysicalDeviceSchedulingControlsFeaturesARM{
		PNext:              (unsafe.Pointer)(s.pNext),
		SchedulingControls: translatePublic_Bool32(s.schedulingControls), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSchedulingControlsFeaturesARM) Vulkanize() *_vkPhysicalDeviceSchedulingControlsFeaturesARM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSchedulingControlsFeaturesARM{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                       /*cb*/
		schedulingControls: translateInternal_Bool32(s.SchedulingControls),                  /*default*/
	}
	return rval
}

// PhysicalDeviceSchedulingControlsPropertiesARM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSchedulingControlsPropertiesARM.html
type PhysicalDeviceSchedulingControlsPropertiesARM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM
	PNext                   unsafe.Pointer
	SchedulingControlsFlags PhysicalDeviceSchedulingControlsFlagsARM
}

type _vkPhysicalDeviceSchedulingControlsPropertiesARM struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	schedulingControlsFlags PhysicalDeviceSchedulingControlsFlagsARM
}

func (s *_vkPhysicalDeviceSchedulingControlsPropertiesARM) Goify() *PhysicalDeviceSchedulingControlsPropertiesARM {
	rval := &PhysicalDeviceSchedulingControlsPropertiesARM{
		PNext:                   (unsafe.Pointer)(s.pNext),
		SchedulingControlsFlags: (PhysicalDeviceSchedulingControlsFlagsARM)(s.schedulingControlsFlags),
	}
	return rval
}
func (s *PhysicalDeviceSchedulingControlsPropertiesARM) Vulkanize() *_vkPhysicalDeviceSchedulingControlsPropertiesARM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSchedulingControlsPropertiesARM{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM,     /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                             /*cb*/
		schedulingControlsFlags: (PhysicalDeviceSchedulingControlsFlagsARM)(s.SchedulingControlsFlags), /*cb*/
	}
	return rval
}

// PhysicalDeviceSeparateDepthStencilLayoutsFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html
type PhysicalDeviceSeparateDepthStencilLayoutsFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES
	PNext                       unsafe.Pointer
	SeparateDepthStencilLayouts bool
}

type _vkPhysicalDeviceSeparateDepthStencilLayoutsFeatures struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	separateDepthStencilLayouts Bool32
}

func (s *_vkPhysicalDeviceSeparateDepthStencilLayoutsFeatures) Goify() *PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
	rval := &PhysicalDeviceSeparateDepthStencilLayoutsFeatures{
		PNext:                       (unsafe.Pointer)(s.pNext),
		SeparateDepthStencilLayouts: translatePublic_Bool32(s.separateDepthStencilLayouts), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSeparateDepthStencilLayoutsFeatures) Vulkanize() *_vkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSeparateDepthStencilLayoutsFeatures{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                              /*cb*/
		separateDepthStencilLayouts: translateInternal_Bool32(s.SeparateDepthStencilLayouts),                /*default*/
	}
	return rval
}

// PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR.html
type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR struct {
}

type _vkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR

func (s *_vkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR) Goify() *PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR {
	rval := (*PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR) Vulkanize() *_vkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceShaderAtomicFloat2FeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html
type PhysicalDeviceShaderAtomicFloat2FeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT
	PNext                           unsafe.Pointer
	ShaderBufferFloat16Atomics      bool
	ShaderBufferFloat16AtomicAdd    bool
	ShaderBufferFloat16AtomicMinMax bool
	ShaderBufferFloat32AtomicMinMax bool
	ShaderBufferFloat64AtomicMinMax bool
	ShaderSharedFloat16Atomics      bool
	ShaderSharedFloat16AtomicAdd    bool
	ShaderSharedFloat16AtomicMinMax bool
	ShaderSharedFloat32AtomicMinMax bool
	ShaderSharedFloat64AtomicMinMax bool
	ShaderImageFloat32AtomicMinMax  bool
	SparseImageFloat32AtomicMinMax  bool
}

type _vkPhysicalDeviceShaderAtomicFloat2FeaturesEXT struct {
	sType                           StructureType
	pNext                           unsafe.Pointer
	shaderBufferFloat16Atomics      Bool32
	shaderBufferFloat16AtomicAdd    Bool32
	shaderBufferFloat16AtomicMinMax Bool32
	shaderBufferFloat32AtomicMinMax Bool32
	shaderBufferFloat64AtomicMinMax Bool32
	shaderSharedFloat16Atomics      Bool32
	shaderSharedFloat16AtomicAdd    Bool32
	shaderSharedFloat16AtomicMinMax Bool32
	shaderSharedFloat32AtomicMinMax Bool32
	shaderSharedFloat64AtomicMinMax Bool32
	shaderImageFloat32AtomicMinMax  Bool32
	sparseImageFloat32AtomicMinMax  Bool32
}

func (s *_vkPhysicalDeviceShaderAtomicFloat2FeaturesEXT) Goify() *PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
	rval := &PhysicalDeviceShaderAtomicFloat2FeaturesEXT{
		PNext:                           (unsafe.Pointer)(s.pNext),
		ShaderBufferFloat16Atomics:      translatePublic_Bool32(s.shaderBufferFloat16Atomics),      /*default*/
		ShaderBufferFloat16AtomicAdd:    translatePublic_Bool32(s.shaderBufferFloat16AtomicAdd),    /*default*/
		ShaderBufferFloat16AtomicMinMax: translatePublic_Bool32(s.shaderBufferFloat16AtomicMinMax), /*default*/
		ShaderBufferFloat32AtomicMinMax: translatePublic_Bool32(s.shaderBufferFloat32AtomicMinMax), /*default*/
		ShaderBufferFloat64AtomicMinMax: translatePublic_Bool32(s.shaderBufferFloat64AtomicMinMax), /*default*/
		ShaderSharedFloat16Atomics:      translatePublic_Bool32(s.shaderSharedFloat16Atomics),      /*default*/
		ShaderSharedFloat16AtomicAdd:    translatePublic_Bool32(s.shaderSharedFloat16AtomicAdd),    /*default*/
		ShaderSharedFloat16AtomicMinMax: translatePublic_Bool32(s.shaderSharedFloat16AtomicMinMax), /*default*/
		ShaderSharedFloat32AtomicMinMax: translatePublic_Bool32(s.shaderSharedFloat32AtomicMinMax), /*default*/
		ShaderSharedFloat64AtomicMinMax: translatePublic_Bool32(s.shaderSharedFloat64AtomicMinMax), /*default*/
		ShaderImageFloat32AtomicMinMax:  translatePublic_Bool32(s.shaderImageFloat32AtomicMinMax),  /*default*/
		SparseImageFloat32AtomicMinMax:  translatePublic_Bool32(s.sparseImageFloat32AtomicMinMax),  /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderAtomicFloat2FeaturesEXT) Vulkanize() *_vkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderAtomicFloat2FeaturesEXT{
		sType:                           STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, /*c1*/
		pNext:                           (unsafe.Pointer)(s.PNext),                                         /*cb*/
		shaderBufferFloat16Atomics:      translateInternal_Bool32(s.ShaderBufferFloat16Atomics),            /*default*/
		shaderBufferFloat16AtomicAdd:    translateInternal_Bool32(s.ShaderBufferFloat16AtomicAdd),          /*default*/
		shaderBufferFloat16AtomicMinMax: translateInternal_Bool32(s.ShaderBufferFloat16AtomicMinMax),       /*default*/
		shaderBufferFloat32AtomicMinMax: translateInternal_Bool32(s.ShaderBufferFloat32AtomicMinMax),       /*default*/
		shaderBufferFloat64AtomicMinMax: translateInternal_Bool32(s.ShaderBufferFloat64AtomicMinMax),       /*default*/
		shaderSharedFloat16Atomics:      translateInternal_Bool32(s.ShaderSharedFloat16Atomics),            /*default*/
		shaderSharedFloat16AtomicAdd:    translateInternal_Bool32(s.ShaderSharedFloat16AtomicAdd),          /*default*/
		shaderSharedFloat16AtomicMinMax: translateInternal_Bool32(s.ShaderSharedFloat16AtomicMinMax),       /*default*/
		shaderSharedFloat32AtomicMinMax: translateInternal_Bool32(s.ShaderSharedFloat32AtomicMinMax),       /*default*/
		shaderSharedFloat64AtomicMinMax: translateInternal_Bool32(s.ShaderSharedFloat64AtomicMinMax),       /*default*/
		shaderImageFloat32AtomicMinMax:  translateInternal_Bool32(s.ShaderImageFloat32AtomicMinMax),        /*default*/
		sparseImageFloat32AtomicMinMax:  translateInternal_Bool32(s.SparseImageFloat32AtomicMinMax),        /*default*/
	}
	return rval
}

// PhysicalDeviceShaderAtomicFloatFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html
type PhysicalDeviceShaderAtomicFloatFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT
	PNext                        unsafe.Pointer
	ShaderBufferFloat32Atomics   bool
	ShaderBufferFloat32AtomicAdd bool
	ShaderBufferFloat64Atomics   bool
	ShaderBufferFloat64AtomicAdd bool
	ShaderSharedFloat32Atomics   bool
	ShaderSharedFloat32AtomicAdd bool
	ShaderSharedFloat64Atomics   bool
	ShaderSharedFloat64AtomicAdd bool
	ShaderImageFloat32Atomics    bool
	ShaderImageFloat32AtomicAdd  bool
	SparseImageFloat32Atomics    bool
	SparseImageFloat32AtomicAdd  bool
}

type _vkPhysicalDeviceShaderAtomicFloatFeaturesEXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	shaderBufferFloat32Atomics   Bool32
	shaderBufferFloat32AtomicAdd Bool32
	shaderBufferFloat64Atomics   Bool32
	shaderBufferFloat64AtomicAdd Bool32
	shaderSharedFloat32Atomics   Bool32
	shaderSharedFloat32AtomicAdd Bool32
	shaderSharedFloat64Atomics   Bool32
	shaderSharedFloat64AtomicAdd Bool32
	shaderImageFloat32Atomics    Bool32
	shaderImageFloat32AtomicAdd  Bool32
	sparseImageFloat32Atomics    Bool32
	sparseImageFloat32AtomicAdd  Bool32
}

func (s *_vkPhysicalDeviceShaderAtomicFloatFeaturesEXT) Goify() *PhysicalDeviceShaderAtomicFloatFeaturesEXT {
	rval := &PhysicalDeviceShaderAtomicFloatFeaturesEXT{
		PNext:                        (unsafe.Pointer)(s.pNext),
		ShaderBufferFloat32Atomics:   translatePublic_Bool32(s.shaderBufferFloat32Atomics),   /*default*/
		ShaderBufferFloat32AtomicAdd: translatePublic_Bool32(s.shaderBufferFloat32AtomicAdd), /*default*/
		ShaderBufferFloat64Atomics:   translatePublic_Bool32(s.shaderBufferFloat64Atomics),   /*default*/
		ShaderBufferFloat64AtomicAdd: translatePublic_Bool32(s.shaderBufferFloat64AtomicAdd), /*default*/
		ShaderSharedFloat32Atomics:   translatePublic_Bool32(s.shaderSharedFloat32Atomics),   /*default*/
		ShaderSharedFloat32AtomicAdd: translatePublic_Bool32(s.shaderSharedFloat32AtomicAdd), /*default*/
		ShaderSharedFloat64Atomics:   translatePublic_Bool32(s.shaderSharedFloat64Atomics),   /*default*/
		ShaderSharedFloat64AtomicAdd: translatePublic_Bool32(s.shaderSharedFloat64AtomicAdd), /*default*/
		ShaderImageFloat32Atomics:    translatePublic_Bool32(s.shaderImageFloat32Atomics),    /*default*/
		ShaderImageFloat32AtomicAdd:  translatePublic_Bool32(s.shaderImageFloat32AtomicAdd),  /*default*/
		SparseImageFloat32Atomics:    translatePublic_Bool32(s.sparseImageFloat32Atomics),    /*default*/
		SparseImageFloat32AtomicAdd:  translatePublic_Bool32(s.sparseImageFloat32AtomicAdd),  /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderAtomicFloatFeaturesEXT) Vulkanize() *_vkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderAtomicFloatFeaturesEXT{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                       /*cb*/
		shaderBufferFloat32Atomics:   translateInternal_Bool32(s.ShaderBufferFloat32Atomics),          /*default*/
		shaderBufferFloat32AtomicAdd: translateInternal_Bool32(s.ShaderBufferFloat32AtomicAdd),        /*default*/
		shaderBufferFloat64Atomics:   translateInternal_Bool32(s.ShaderBufferFloat64Atomics),          /*default*/
		shaderBufferFloat64AtomicAdd: translateInternal_Bool32(s.ShaderBufferFloat64AtomicAdd),        /*default*/
		shaderSharedFloat32Atomics:   translateInternal_Bool32(s.ShaderSharedFloat32Atomics),          /*default*/
		shaderSharedFloat32AtomicAdd: translateInternal_Bool32(s.ShaderSharedFloat32AtomicAdd),        /*default*/
		shaderSharedFloat64Atomics:   translateInternal_Bool32(s.ShaderSharedFloat64Atomics),          /*default*/
		shaderSharedFloat64AtomicAdd: translateInternal_Bool32(s.ShaderSharedFloat64AtomicAdd),        /*default*/
		shaderImageFloat32Atomics:    translateInternal_Bool32(s.ShaderImageFloat32Atomics),           /*default*/
		shaderImageFloat32AtomicAdd:  translateInternal_Bool32(s.ShaderImageFloat32AtomicAdd),         /*default*/
		sparseImageFloat32Atomics:    translateInternal_Bool32(s.SparseImageFloat32Atomics),           /*default*/
		sparseImageFloat32AtomicAdd:  translateInternal_Bool32(s.SparseImageFloat32AtomicAdd),         /*default*/
	}
	return rval
}

// PhysicalDeviceShaderAtomicInt64Features: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html
type PhysicalDeviceShaderAtomicInt64Features struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES
	PNext                    unsafe.Pointer
	ShaderBufferInt64Atomics bool
	ShaderSharedInt64Atomics bool
}

type _vkPhysicalDeviceShaderAtomicInt64Features struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	shaderBufferInt64Atomics Bool32
	shaderSharedInt64Atomics Bool32
}

func (s *_vkPhysicalDeviceShaderAtomicInt64Features) Goify() *PhysicalDeviceShaderAtomicInt64Features {
	rval := &PhysicalDeviceShaderAtomicInt64Features{
		PNext:                    (unsafe.Pointer)(s.pNext),
		ShaderBufferInt64Atomics: translatePublic_Bool32(s.shaderBufferInt64Atomics), /*default*/
		ShaderSharedInt64Atomics: translatePublic_Bool32(s.shaderSharedInt64Atomics), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderAtomicInt64Features) Vulkanize() *_vkPhysicalDeviceShaderAtomicInt64Features {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderAtomicInt64Features{
		sType:                    STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                   /*cb*/
		shaderBufferInt64Atomics: translateInternal_Bool32(s.ShaderBufferInt64Atomics),        /*default*/
		shaderSharedInt64Atomics: translateInternal_Bool32(s.ShaderSharedInt64Atomics),        /*default*/
	}
	return rval
}

// PhysicalDeviceShaderAtomicInt64FeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicInt64FeaturesKHR.html
type PhysicalDeviceShaderAtomicInt64FeaturesKHR struct {
}

type _vkPhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64FeaturesKHR

func (s *_vkPhysicalDeviceShaderAtomicInt64FeaturesKHR) Goify() *PhysicalDeviceShaderAtomicInt64FeaturesKHR {
	rval := (*PhysicalDeviceShaderAtomicInt64FeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceShaderAtomicInt64FeaturesKHR) Vulkanize() *_vkPhysicalDeviceShaderAtomicInt64FeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceShaderAtomicInt64FeaturesKHR)(s)
	return rval
}

// PhysicalDeviceShaderClockFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html
type PhysicalDeviceShaderClockFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR
	PNext               unsafe.Pointer
	ShaderSubgroupClock bool
	ShaderDeviceClock   bool
}

type _vkPhysicalDeviceShaderClockFeaturesKHR struct {
	sType               StructureType
	pNext               unsafe.Pointer
	shaderSubgroupClock Bool32
	shaderDeviceClock   Bool32
}

func (s *_vkPhysicalDeviceShaderClockFeaturesKHR) Goify() *PhysicalDeviceShaderClockFeaturesKHR {
	rval := &PhysicalDeviceShaderClockFeaturesKHR{
		PNext:               (unsafe.Pointer)(s.pNext),
		ShaderSubgroupClock: translatePublic_Bool32(s.shaderSubgroupClock), /*default*/
		ShaderDeviceClock:   translatePublic_Bool32(s.shaderDeviceClock),   /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderClockFeaturesKHR) Vulkanize() *_vkPhysicalDeviceShaderClockFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderClockFeaturesKHR{
		sType:               STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                /*cb*/
		shaderSubgroupClock: translateInternal_Bool32(s.ShaderSubgroupClock),          /*default*/
		shaderDeviceClock:   translateInternal_Bool32(s.ShaderDeviceClock),            /*default*/
	}
	return rval
}

// PhysicalDeviceShaderCoreBuiltinsFeaturesARM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.html
type PhysicalDeviceShaderCoreBuiltinsFeaturesARM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM
	PNext              unsafe.Pointer
	ShaderCoreBuiltins bool
}

type _vkPhysicalDeviceShaderCoreBuiltinsFeaturesARM struct {
	sType              StructureType
	pNext              unsafe.Pointer
	shaderCoreBuiltins Bool32
}

func (s *_vkPhysicalDeviceShaderCoreBuiltinsFeaturesARM) Goify() *PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
	rval := &PhysicalDeviceShaderCoreBuiltinsFeaturesARM{
		PNext:              (unsafe.Pointer)(s.pNext),
		ShaderCoreBuiltins: translatePublic_Bool32(s.shaderCoreBuiltins), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderCoreBuiltinsFeaturesARM) Vulkanize() *_vkPhysicalDeviceShaderCoreBuiltinsFeaturesARM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderCoreBuiltinsFeaturesARM{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                        /*cb*/
		shaderCoreBuiltins: translateInternal_Bool32(s.ShaderCoreBuiltins),                   /*default*/
	}
	return rval
}

// PhysicalDeviceShaderCoreBuiltinsPropertiesARM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.html
type PhysicalDeviceShaderCoreBuiltinsPropertiesARM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM
	PNext              unsafe.Pointer
	ShaderCoreMask     uint64
	ShaderCoreCount    uint32
	ShaderWarpsPerCore uint32
}

// WARNING - struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceShaderCoreBuiltinsPropertiesARM struct {
	sType              StructureType
	pNext              unsafe.Pointer
	shaderCoreMask     uint64
	shaderCoreCount    uint32
	shaderWarpsPerCore uint32
}

func (s *_vkPhysicalDeviceShaderCoreBuiltinsPropertiesARM) Goify() *PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
	rval := &PhysicalDeviceShaderCoreBuiltinsPropertiesARM{
		PNext:              (unsafe.Pointer)(s.pNext),
		ShaderCoreMask:     (uint64)(s.shaderCoreMask),
		ShaderCoreCount:    (uint32)(s.shaderCoreCount),
		ShaderWarpsPerCore: (uint32)(s.shaderWarpsPerCore),
	}
	return rval
}
func (s *PhysicalDeviceShaderCoreBuiltinsPropertiesARM) Vulkanize() *_vkPhysicalDeviceShaderCoreBuiltinsPropertiesARM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderCoreBuiltinsPropertiesARM{
		sType:              STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                          /*cb*/
		shaderCoreMask:     (uint64)(s.ShaderCoreMask),                                         /*cb*/
		shaderCoreCount:    (uint32)(s.ShaderCoreCount),                                        /*cb*/
		shaderWarpsPerCore: (uint32)(s.ShaderWarpsPerCore),                                     /*cb*/
	}
	return rval
}

// PhysicalDeviceShaderCoreProperties2AMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html
type PhysicalDeviceShaderCoreProperties2AMD struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD
	//  Pointer to next structure;
	PNext unsafe.Pointer
	//  features supported by the shader core;
	ShaderCoreFeatures ShaderCorePropertiesFlagsAMD
	//  number of active compute units across all shader engines/arrays;
	ActiveComputeUnitCount uint32
}

// WARNING - struct PhysicalDeviceShaderCoreProperties2AMD is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceShaderCoreProperties2AMD struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	shaderCoreFeatures     ShaderCorePropertiesFlagsAMD
	activeComputeUnitCount uint32
}

func (s *_vkPhysicalDeviceShaderCoreProperties2AMD) Goify() *PhysicalDeviceShaderCoreProperties2AMD {
	rval := &PhysicalDeviceShaderCoreProperties2AMD{
		PNext:                  (unsafe.Pointer)(s.pNext),
		ShaderCoreFeatures:     (ShaderCorePropertiesFlagsAMD)(s.shaderCoreFeatures),
		ActiveComputeUnitCount: (uint32)(s.activeComputeUnitCount),
	}
	return rval
}
func (s *PhysicalDeviceShaderCoreProperties2AMD) Vulkanize() *_vkPhysicalDeviceShaderCoreProperties2AMD {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderCoreProperties2AMD{
		sType:                  STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                   /*cb*/
		shaderCoreFeatures:     (ShaderCorePropertiesFlagsAMD)(s.ShaderCoreFeatures),        /*cb*/
		activeComputeUnitCount: (uint32)(s.ActiveComputeUnitCount),                          /*cb*/
	}
	return rval
}

// PhysicalDeviceShaderCorePropertiesAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html
type PhysicalDeviceShaderCorePropertiesAMD struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD
	PNext unsafe.Pointer
	//  number of shader engines;
	ShaderEngineCount uint32
	//  number of shader arrays;
	ShaderArraysPerEngineCount uint32
	//  number of physical CUs per shader array;
	ComputeUnitsPerShaderArray uint32
	//  number of SIMDs per compute unit;
	SimdPerComputeUnit uint32
	//  number of wavefront slots in each SIMD;
	WavefrontsPerSimd uint32
	//  maximum number of threads per wavefront;
	WavefrontSize uint32
	//  number of physical SGPRs per SIMD;
	SgprsPerSimd uint32
	//  minimum number of SGPRs that can be allocated by a wave;
	MinSgprAllocation uint32
	//  number of available SGPRs;
	MaxSgprAllocation uint32
	//  SGPRs are allocated in groups of this size;
	SgprAllocationGranularity uint32
	//  number of physical VGPRs per SIMD;
	VgprsPerSimd uint32
	//  minimum number of VGPRs that can be allocated by a wave;
	MinVgprAllocation uint32
	//  number of available VGPRs;
	MaxVgprAllocation uint32
	//  VGPRs are allocated in groups of this size;
	VgprAllocationGranularity uint32
}

// WARNING - struct PhysicalDeviceShaderCorePropertiesAMD is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceShaderCorePropertiesAMD struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	shaderEngineCount          uint32
	shaderArraysPerEngineCount uint32
	computeUnitsPerShaderArray uint32
	simdPerComputeUnit         uint32
	wavefrontsPerSimd          uint32
	wavefrontSize              uint32
	sgprsPerSimd               uint32
	minSgprAllocation          uint32
	maxSgprAllocation          uint32
	sgprAllocationGranularity  uint32
	vgprsPerSimd               uint32
	minVgprAllocation          uint32
	maxVgprAllocation          uint32
	vgprAllocationGranularity  uint32
}

func (s *_vkPhysicalDeviceShaderCorePropertiesAMD) Goify() *PhysicalDeviceShaderCorePropertiesAMD {
	rval := &PhysicalDeviceShaderCorePropertiesAMD{
		PNext:                      (unsafe.Pointer)(s.pNext),
		ShaderEngineCount:          (uint32)(s.shaderEngineCount),
		ShaderArraysPerEngineCount: (uint32)(s.shaderArraysPerEngineCount),
		ComputeUnitsPerShaderArray: (uint32)(s.computeUnitsPerShaderArray),
		SimdPerComputeUnit:         (uint32)(s.simdPerComputeUnit),
		WavefrontsPerSimd:          (uint32)(s.wavefrontsPerSimd),
		WavefrontSize:              (uint32)(s.wavefrontSize),
		SgprsPerSimd:               (uint32)(s.sgprsPerSimd),
		MinSgprAllocation:          (uint32)(s.minSgprAllocation),
		MaxSgprAllocation:          (uint32)(s.maxSgprAllocation),
		SgprAllocationGranularity:  (uint32)(s.sgprAllocationGranularity),
		VgprsPerSimd:               (uint32)(s.vgprsPerSimd),
		MinVgprAllocation:          (uint32)(s.minVgprAllocation),
		MaxVgprAllocation:          (uint32)(s.maxVgprAllocation),
		VgprAllocationGranularity:  (uint32)(s.vgprAllocationGranularity),
	}
	return rval
}
func (s *PhysicalDeviceShaderCorePropertiesAMD) Vulkanize() *_vkPhysicalDeviceShaderCorePropertiesAMD {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderCorePropertiesAMD{
		sType:                      STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                 /*cb*/
		shaderEngineCount:          (uint32)(s.ShaderEngineCount),                             /*cb*/
		shaderArraysPerEngineCount: (uint32)(s.ShaderArraysPerEngineCount),                    /*cb*/
		computeUnitsPerShaderArray: (uint32)(s.ComputeUnitsPerShaderArray),                    /*cb*/
		simdPerComputeUnit:         (uint32)(s.SimdPerComputeUnit),                            /*cb*/
		wavefrontsPerSimd:          (uint32)(s.WavefrontsPerSimd),                             /*cb*/
		wavefrontSize:              (uint32)(s.WavefrontSize),                                 /*cb*/
		sgprsPerSimd:               (uint32)(s.SgprsPerSimd),                                  /*cb*/
		minSgprAllocation:          (uint32)(s.MinSgprAllocation),                             /*cb*/
		maxSgprAllocation:          (uint32)(s.MaxSgprAllocation),                             /*cb*/
		sgprAllocationGranularity:  (uint32)(s.SgprAllocationGranularity),                     /*cb*/
		vgprsPerSimd:               (uint32)(s.VgprsPerSimd),                                  /*cb*/
		minVgprAllocation:          (uint32)(s.MinVgprAllocation),                             /*cb*/
		maxVgprAllocation:          (uint32)(s.MaxVgprAllocation),                             /*cb*/
		vgprAllocationGranularity:  (uint32)(s.VgprAllocationGranularity),                     /*cb*/
	}
	return rval
}

// PhysicalDeviceShaderCorePropertiesARM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesARM.html
type PhysicalDeviceShaderCorePropertiesARM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM
	PNext     unsafe.Pointer
	PixelRate uint32
	TexelRate uint32
	FmaRate   uint32
}

// WARNING - struct PhysicalDeviceShaderCorePropertiesARM is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceShaderCorePropertiesARM struct {
	sType     StructureType
	pNext     unsafe.Pointer
	pixelRate uint32
	texelRate uint32
	fmaRate   uint32
}

func (s *_vkPhysicalDeviceShaderCorePropertiesARM) Goify() *PhysicalDeviceShaderCorePropertiesARM {
	rval := &PhysicalDeviceShaderCorePropertiesARM{
		PNext:     (unsafe.Pointer)(s.pNext),
		PixelRate: (uint32)(s.pixelRate),
		TexelRate: (uint32)(s.texelRate),
		FmaRate:   (uint32)(s.fmaRate),
	}
	return rval
}
func (s *PhysicalDeviceShaderCorePropertiesARM) Vulkanize() *_vkPhysicalDeviceShaderCorePropertiesARM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderCorePropertiesARM{
		sType:     STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                                 /*cb*/
		pixelRate: (uint32)(s.PixelRate),                                     /*cb*/
		texelRate: (uint32)(s.TexelRate),                                     /*cb*/
		fmaRate:   (uint32)(s.FmaRate),                                       /*cb*/
	}
	return rval
}

// PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.html
type PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT struct {
}

type _vkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT

func (s *_vkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT) Goify() *PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
	rval := (*PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT) Vulkanize() *_vkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceShaderDrawParameterFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDrawParameterFeatures.html
type PhysicalDeviceShaderDrawParameterFeatures struct {
}

type _vkPhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParameterFeatures

func (s *_vkPhysicalDeviceShaderDrawParameterFeatures) Goify() *PhysicalDeviceShaderDrawParameterFeatures {
	rval := (*PhysicalDeviceShaderDrawParameterFeatures)(s)
	return rval
}
func (s *PhysicalDeviceShaderDrawParameterFeatures) Vulkanize() *_vkPhysicalDeviceShaderDrawParameterFeatures {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceShaderDrawParameterFeatures)(s)
	return rval
}

// PhysicalDeviceShaderDrawParametersFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html
type PhysicalDeviceShaderDrawParametersFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES
	PNext                unsafe.Pointer
	ShaderDrawParameters bool
}

type _vkPhysicalDeviceShaderDrawParametersFeatures struct {
	sType                StructureType
	pNext                unsafe.Pointer
	shaderDrawParameters Bool32
}

func (s *_vkPhysicalDeviceShaderDrawParametersFeatures) Goify() *PhysicalDeviceShaderDrawParametersFeatures {
	rval := &PhysicalDeviceShaderDrawParametersFeatures{
		PNext:                (unsafe.Pointer)(s.pNext),
		ShaderDrawParameters: translatePublic_Bool32(s.shaderDrawParameters), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderDrawParametersFeatures) Vulkanize() *_vkPhysicalDeviceShaderDrawParametersFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderDrawParametersFeatures{
		sType:                STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                      /*cb*/
		shaderDrawParameters: translateInternal_Bool32(s.ShaderDrawParameters),               /*default*/
	}
	return rval
}

// PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.html
type PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD
	PNext                           unsafe.Pointer
	ShaderEarlyAndLateFragmentTests bool
}

type _vkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD struct {
	sType                           StructureType
	pNext                           unsafe.Pointer
	shaderEarlyAndLateFragmentTests Bool32
}

func (s *_vkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD) Goify() *PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
	rval := &PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD{
		PNext:                           (unsafe.Pointer)(s.pNext),
		ShaderEarlyAndLateFragmentTests: translatePublic_Bool32(s.shaderEarlyAndLateFragmentTests), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD) Vulkanize() *_vkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD{
		sType:                           STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, /*c1*/
		pNext:                           (unsafe.Pointer)(s.PNext),                                                        /*cb*/
		shaderEarlyAndLateFragmentTests: translateInternal_Bool32(s.ShaderEarlyAndLateFragmentTests),                      /*default*/
	}
	return rval
}

// PhysicalDeviceShaderFloat16Int8Features: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html
type PhysicalDeviceShaderFloat16Int8Features struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES
	PNext unsafe.Pointer
	//  16-bit floats (halfs) in shaders;
	ShaderFloat16 bool
	//  8-bit integers in shaders;
	ShaderInt8 bool
}

type _vkPhysicalDeviceShaderFloat16Int8Features struct {
	sType         StructureType
	pNext         unsafe.Pointer
	shaderFloat16 Bool32
	shaderInt8    Bool32
}

func (s *_vkPhysicalDeviceShaderFloat16Int8Features) Goify() *PhysicalDeviceShaderFloat16Int8Features {
	rval := &PhysicalDeviceShaderFloat16Int8Features{
		PNext:         (unsafe.Pointer)(s.pNext),
		ShaderFloat16: translatePublic_Bool32(s.shaderFloat16), /*default*/
		ShaderInt8:    translatePublic_Bool32(s.shaderInt8),    /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderFloat16Int8Features) Vulkanize() *_vkPhysicalDeviceShaderFloat16Int8Features {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderFloat16Int8Features{
		sType:         STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                   /*cb*/
		shaderFloat16: translateInternal_Bool32(s.ShaderFloat16),                   /*default*/
		shaderInt8:    translateInternal_Bool32(s.ShaderInt8),                      /*default*/
	}
	return rval
}

// PhysicalDeviceShaderFloat16Int8FeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderFloat16Int8FeaturesKHR.html
type PhysicalDeviceShaderFloat16Int8FeaturesKHR struct {
}

type _vkPhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8FeaturesKHR

func (s *_vkPhysicalDeviceShaderFloat16Int8FeaturesKHR) Goify() *PhysicalDeviceShaderFloat16Int8FeaturesKHR {
	rval := (*PhysicalDeviceShaderFloat16Int8FeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceShaderFloat16Int8FeaturesKHR) Vulkanize() *_vkPhysicalDeviceShaderFloat16Int8FeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceShaderFloat16Int8FeaturesKHR)(s)
	return rval
}

// PhysicalDeviceShaderImageAtomicInt64FeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html
type PhysicalDeviceShaderImageAtomicInt64FeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT
	PNext                   unsafe.Pointer
	ShaderImageInt64Atomics bool
	SparseImageInt64Atomics bool
}

type _vkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	shaderImageInt64Atomics Bool32
	sparseImageInt64Atomics Bool32
}

func (s *_vkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT) Goify() *PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
	rval := &PhysicalDeviceShaderImageAtomicInt64FeaturesEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		ShaderImageInt64Atomics: translatePublic_Bool32(s.shaderImageInt64Atomics), /*default*/
		SparseImageInt64Atomics: translatePublic_Bool32(s.sparseImageInt64Atomics), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderImageAtomicInt64FeaturesEXT) Vulkanize() *_vkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                             /*cb*/
		shaderImageInt64Atomics: translateInternal_Bool32(s.ShaderImageInt64Atomics),                   /*default*/
		sparseImageInt64Atomics: translateInternal_Bool32(s.SparseImageInt64Atomics),                   /*default*/
	}
	return rval
}

// PhysicalDeviceShaderImageFootprintFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html
type PhysicalDeviceShaderImageFootprintFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV
	PNext          unsafe.Pointer
	ImageFootprint bool
}

type _vkPhysicalDeviceShaderImageFootprintFeaturesNV struct {
	sType          StructureType
	pNext          unsafe.Pointer
	imageFootprint Bool32
}

func (s *_vkPhysicalDeviceShaderImageFootprintFeaturesNV) Goify() *PhysicalDeviceShaderImageFootprintFeaturesNV {
	rval := &PhysicalDeviceShaderImageFootprintFeaturesNV{
		PNext:          (unsafe.Pointer)(s.pNext),
		ImageFootprint: translatePublic_Bool32(s.imageFootprint), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderImageFootprintFeaturesNV) Vulkanize() *_vkPhysicalDeviceShaderImageFootprintFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderImageFootprintFeaturesNV{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                         /*cb*/
		imageFootprint: translateInternal_Bool32(s.ImageFootprint),                        /*default*/
	}
	return rval
}

// PhysicalDeviceShaderIntegerDotProductFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR.html
type PhysicalDeviceShaderIntegerDotProductFeaturesKHR struct {
}

type _vkPhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeaturesKHR

func (s *_vkPhysicalDeviceShaderIntegerDotProductFeaturesKHR) Goify() *PhysicalDeviceShaderIntegerDotProductFeaturesKHR {
	rval := (*PhysicalDeviceShaderIntegerDotProductFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceShaderIntegerDotProductFeaturesKHR) Vulkanize() *_vkPhysicalDeviceShaderIntegerDotProductFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceShaderIntegerDotProductPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR.html
type PhysicalDeviceShaderIntegerDotProductPropertiesKHR struct {
}

type _vkPhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductPropertiesKHR

func (s *_vkPhysicalDeviceShaderIntegerDotProductPropertiesKHR) Goify() *PhysicalDeviceShaderIntegerDotProductPropertiesKHR {
	rval := (*PhysicalDeviceShaderIntegerDotProductPropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceShaderIntegerDotProductPropertiesKHR) Vulkanize() *_vkPhysicalDeviceShaderIntegerDotProductPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)(s)
	return rval
}

// PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html
type PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL
	PNext                   unsafe.Pointer
	ShaderIntegerFunctions2 bool
}

type _vkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	shaderIntegerFunctions2 Bool32
}

func (s *_vkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL) Goify() *PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
	rval := &PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL{
		PNext:                   (unsafe.Pointer)(s.pNext),
		ShaderIntegerFunctions2: translatePublic_Bool32(s.shaderIntegerFunctions2), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL) Vulkanize() *_vkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                                /*cb*/
		shaderIntegerFunctions2: translateInternal_Bool32(s.ShaderIntegerFunctions2),                      /*default*/
	}
	return rval
}

// PhysicalDeviceShaderModuleIdentifierFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.html
type PhysicalDeviceShaderModuleIdentifierFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT
	PNext                  unsafe.Pointer
	ShaderModuleIdentifier bool
}

type _vkPhysicalDeviceShaderModuleIdentifierFeaturesEXT struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	shaderModuleIdentifier Bool32
}

func (s *_vkPhysicalDeviceShaderModuleIdentifierFeaturesEXT) Goify() *PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
	rval := &PhysicalDeviceShaderModuleIdentifierFeaturesEXT{
		PNext:                  (unsafe.Pointer)(s.pNext),
		ShaderModuleIdentifier: translatePublic_Bool32(s.shaderModuleIdentifier), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderModuleIdentifierFeaturesEXT) Vulkanize() *_vkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderModuleIdentifierFeaturesEXT{
		sType:                  STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                            /*cb*/
		shaderModuleIdentifier: translateInternal_Bool32(s.ShaderModuleIdentifier),                   /*default*/
	}
	return rval
}

// PhysicalDeviceShaderModuleIdentifierPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.html
type PhysicalDeviceShaderModuleIdentifierPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT
	PNext                               unsafe.Pointer
	ShaderModuleIdentifierAlgorithmUUID [UUID_SIZE]uint8
}

// WARNING - struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceShaderModuleIdentifierPropertiesEXT struct {
	sType                               StructureType
	pNext                               unsafe.Pointer
	shaderModuleIdentifierAlgorithmUUID [UUID_SIZE]uint8
}

func (s *_vkPhysicalDeviceShaderModuleIdentifierPropertiesEXT) Goify() *PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
	rval := &PhysicalDeviceShaderModuleIdentifierPropertiesEXT{
		PNext:                               (unsafe.Pointer)(s.pNext),
		ShaderModuleIdentifierAlgorithmUUID: ([UUID_SIZE]uint8)(s.shaderModuleIdentifierAlgorithmUUID),
	}
	return rval
}
func (s *PhysicalDeviceShaderModuleIdentifierPropertiesEXT) Vulkanize() *_vkPhysicalDeviceShaderModuleIdentifierPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderModuleIdentifierPropertiesEXT{
		sType:                               STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT, /*c1*/
		pNext:                               (unsafe.Pointer)(s.PNext),                                              /*cb*/
		shaderModuleIdentifierAlgorithmUUID: ([UUID_SIZE]uint8)(s.ShaderModuleIdentifierAlgorithmUUID),              /*cb*/
	}
	return rval
}

// PhysicalDeviceShaderObjectFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderObjectFeaturesEXT.html
type PhysicalDeviceShaderObjectFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT
	PNext        unsafe.Pointer
	ShaderObject bool
}

type _vkPhysicalDeviceShaderObjectFeaturesEXT struct {
	sType        StructureType
	pNext        unsafe.Pointer
	shaderObject Bool32
}

func (s *_vkPhysicalDeviceShaderObjectFeaturesEXT) Goify() *PhysicalDeviceShaderObjectFeaturesEXT {
	rval := &PhysicalDeviceShaderObjectFeaturesEXT{
		PNext:        (unsafe.Pointer)(s.pNext),
		ShaderObject: translatePublic_Bool32(s.shaderObject), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderObjectFeaturesEXT) Vulkanize() *_vkPhysicalDeviceShaderObjectFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderObjectFeaturesEXT{
		sType:        STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                                 /*cb*/
		shaderObject: translateInternal_Bool32(s.ShaderObject),                  /*default*/
	}
	return rval
}

// PhysicalDeviceShaderObjectPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderObjectPropertiesEXT.html
type PhysicalDeviceShaderObjectPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT
	PNext               unsafe.Pointer
	ShaderBinaryUUID    [UUID_SIZE]uint8
	ShaderBinaryVersion uint32
}

// WARNING - struct PhysicalDeviceShaderObjectPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceShaderObjectPropertiesEXT struct {
	sType               StructureType
	pNext               unsafe.Pointer
	shaderBinaryUUID    [UUID_SIZE]uint8
	shaderBinaryVersion uint32
}

func (s *_vkPhysicalDeviceShaderObjectPropertiesEXT) Goify() *PhysicalDeviceShaderObjectPropertiesEXT {
	rval := &PhysicalDeviceShaderObjectPropertiesEXT{
		PNext:               (unsafe.Pointer)(s.pNext),
		ShaderBinaryUUID:    ([UUID_SIZE]uint8)(s.shaderBinaryUUID),
		ShaderBinaryVersion: (uint32)(s.shaderBinaryVersion),
	}
	return rval
}
func (s *PhysicalDeviceShaderObjectPropertiesEXT) Vulkanize() *_vkPhysicalDeviceShaderObjectPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderObjectPropertiesEXT{
		sType:               STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                   /*cb*/
		shaderBinaryUUID:    ([UUID_SIZE]uint8)(s.ShaderBinaryUUID),                      /*cb*/
		shaderBinaryVersion: (uint32)(s.ShaderBinaryVersion),                             /*cb*/
	}
	return rval
}

// PhysicalDeviceShaderSMBuiltinsFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html
type PhysicalDeviceShaderSMBuiltinsFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV
	PNext            unsafe.Pointer
	ShaderSMBuiltins bool
}

type _vkPhysicalDeviceShaderSMBuiltinsFeaturesNV struct {
	sType            StructureType
	pNext            unsafe.Pointer
	shaderSMBuiltins Bool32
}

func (s *_vkPhysicalDeviceShaderSMBuiltinsFeaturesNV) Goify() *PhysicalDeviceShaderSMBuiltinsFeaturesNV {
	rval := &PhysicalDeviceShaderSMBuiltinsFeaturesNV{
		PNext:            (unsafe.Pointer)(s.pNext),
		ShaderSMBuiltins: translatePublic_Bool32(s.shaderSMBuiltins), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderSMBuiltinsFeaturesNV) Vulkanize() *_vkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderSMBuiltinsFeaturesNV{
		sType:            STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                     /*cb*/
		shaderSMBuiltins: translateInternal_Bool32(s.ShaderSMBuiltins),                  /*default*/
	}
	return rval
}

// PhysicalDeviceShaderSMBuiltinsPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html
type PhysicalDeviceShaderSMBuiltinsPropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV
	PNext            unsafe.Pointer
	ShaderSMCount    uint32
	ShaderWarpsPerSM uint32
}

// WARNING - struct PhysicalDeviceShaderSMBuiltinsPropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceShaderSMBuiltinsPropertiesNV struct {
	sType            StructureType
	pNext            unsafe.Pointer
	shaderSMCount    uint32
	shaderWarpsPerSM uint32
}

func (s *_vkPhysicalDeviceShaderSMBuiltinsPropertiesNV) Goify() *PhysicalDeviceShaderSMBuiltinsPropertiesNV {
	rval := &PhysicalDeviceShaderSMBuiltinsPropertiesNV{
		PNext:            (unsafe.Pointer)(s.pNext),
		ShaderSMCount:    (uint32)(s.shaderSMCount),
		ShaderWarpsPerSM: (uint32)(s.shaderWarpsPerSM),
	}
	return rval
}
func (s *PhysicalDeviceShaderSMBuiltinsPropertiesNV) Vulkanize() *_vkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderSMBuiltinsPropertiesNV{
		sType:            STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                       /*cb*/
		shaderSMCount:    (uint32)(s.ShaderSMCount),                                       /*cb*/
		shaderWarpsPerSM: (uint32)(s.ShaderWarpsPerSM),                                    /*cb*/
	}
	return rval
}

// PhysicalDeviceShaderSubgroupExtendedTypesFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html
type PhysicalDeviceShaderSubgroupExtendedTypesFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES
	PNext unsafe.Pointer
	//  Flag to specify whether subgroup operations with extended types are supported;
	ShaderSubgroupExtendedTypes bool
}

type _vkPhysicalDeviceShaderSubgroupExtendedTypesFeatures struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	shaderSubgroupExtendedTypes Bool32
}

func (s *_vkPhysicalDeviceShaderSubgroupExtendedTypesFeatures) Goify() *PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
	rval := &PhysicalDeviceShaderSubgroupExtendedTypesFeatures{
		PNext:                       (unsafe.Pointer)(s.pNext),
		ShaderSubgroupExtendedTypes: translatePublic_Bool32(s.shaderSubgroupExtendedTypes), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderSubgroupExtendedTypesFeatures) Vulkanize() *_vkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderSubgroupExtendedTypesFeatures{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                              /*cb*/
		shaderSubgroupExtendedTypes: translateInternal_Bool32(s.ShaderSubgroupExtendedTypes),                /*default*/
	}
	return rval
}

// PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR.html
type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR struct {
}

type _vkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR

func (s *_vkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR) Goify() *PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR {
	rval := (*PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR) Vulkanize() *_vkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html
type PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR
	PNext                            unsafe.Pointer
	ShaderSubgroupUniformControlFlow bool
}

type _vkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	shaderSubgroupUniformControlFlow Bool32
}

func (s *_vkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR) Goify() *PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
	rval := &PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{
		PNext:                            (unsafe.Pointer)(s.pNext),
		ShaderSubgroupUniformControlFlow: translatePublic_Bool32(s.shaderSubgroupUniformControlFlow), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR) Vulkanize() *_vkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                                        /*cb*/
		shaderSubgroupUniformControlFlow: translateInternal_Bool32(s.ShaderSubgroupUniformControlFlow),                     /*default*/
	}
	return rval
}

// PhysicalDeviceShaderTerminateInvocationFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR.html
type PhysicalDeviceShaderTerminateInvocationFeaturesKHR struct {
}

type _vkPhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeaturesKHR

func (s *_vkPhysicalDeviceShaderTerminateInvocationFeaturesKHR) Goify() *PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
	rval := (*PhysicalDeviceShaderTerminateInvocationFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceShaderTerminateInvocationFeaturesKHR) Vulkanize() *_vkPhysicalDeviceShaderTerminateInvocationFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceShaderTileImageFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTileImageFeaturesEXT.html
type PhysicalDeviceShaderTileImageFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT
	PNext                            unsafe.Pointer
	ShaderTileImageColorReadAccess   bool
	ShaderTileImageDepthReadAccess   bool
	ShaderTileImageStencilReadAccess bool
}

type _vkPhysicalDeviceShaderTileImageFeaturesEXT struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	shaderTileImageColorReadAccess   Bool32
	shaderTileImageDepthReadAccess   Bool32
	shaderTileImageStencilReadAccess Bool32
}

func (s *_vkPhysicalDeviceShaderTileImageFeaturesEXT) Goify() *PhysicalDeviceShaderTileImageFeaturesEXT {
	rval := &PhysicalDeviceShaderTileImageFeaturesEXT{
		PNext:                            (unsafe.Pointer)(s.pNext),
		ShaderTileImageColorReadAccess:   translatePublic_Bool32(s.shaderTileImageColorReadAccess),   /*default*/
		ShaderTileImageDepthReadAccess:   translatePublic_Bool32(s.shaderTileImageDepthReadAccess),   /*default*/
		ShaderTileImageStencilReadAccess: translatePublic_Bool32(s.shaderTileImageStencilReadAccess), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderTileImageFeaturesEXT) Vulkanize() *_vkPhysicalDeviceShaderTileImageFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderTileImageFeaturesEXT{
		sType:                            STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                     /*cb*/
		shaderTileImageColorReadAccess:   translateInternal_Bool32(s.ShaderTileImageColorReadAccess),    /*default*/
		shaderTileImageDepthReadAccess:   translateInternal_Bool32(s.ShaderTileImageDepthReadAccess),    /*default*/
		shaderTileImageStencilReadAccess: translateInternal_Bool32(s.ShaderTileImageStencilReadAccess),  /*default*/
	}
	return rval
}

// PhysicalDeviceShaderTileImagePropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTileImagePropertiesEXT.html
type PhysicalDeviceShaderTileImagePropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT
	PNext                                            unsafe.Pointer
	ShaderTileImageCoherentReadAccelerated           bool
	ShaderTileImageReadSampleFromPixelRateInvocation bool
	ShaderTileImageReadFromHelperInvocation          bool
}

// WARNING - struct PhysicalDeviceShaderTileImagePropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceShaderTileImagePropertiesEXT struct {
	sType                                            StructureType
	pNext                                            unsafe.Pointer
	shaderTileImageCoherentReadAccelerated           Bool32
	shaderTileImageReadSampleFromPixelRateInvocation Bool32
	shaderTileImageReadFromHelperInvocation          Bool32
}

func (s *_vkPhysicalDeviceShaderTileImagePropertiesEXT) Goify() *PhysicalDeviceShaderTileImagePropertiesEXT {
	rval := &PhysicalDeviceShaderTileImagePropertiesEXT{
		PNext:                                  (unsafe.Pointer)(s.pNext),
		ShaderTileImageCoherentReadAccelerated: translatePublic_Bool32(s.shaderTileImageCoherentReadAccelerated), /*default*/
		ShaderTileImageReadSampleFromPixelRateInvocation: translatePublic_Bool32(s.shaderTileImageReadSampleFromPixelRateInvocation), /*default*/
		ShaderTileImageReadFromHelperInvocation:          translatePublic_Bool32(s.shaderTileImageReadFromHelperInvocation),          /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShaderTileImagePropertiesEXT) Vulkanize() *_vkPhysicalDeviceShaderTileImagePropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShaderTileImagePropertiesEXT{
		sType:                                  STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT,    /*c1*/
		pNext:                                  (unsafe.Pointer)(s.PNext),                                          /*cb*/
		shaderTileImageCoherentReadAccelerated: translateInternal_Bool32(s.ShaderTileImageCoherentReadAccelerated), /*default*/
		shaderTileImageReadSampleFromPixelRateInvocation: translateInternal_Bool32(s.ShaderTileImageReadSampleFromPixelRateInvocation), /*default*/
		shaderTileImageReadFromHelperInvocation:          translateInternal_Bool32(s.ShaderTileImageReadFromHelperInvocation),          /*default*/
	}
	return rval
}

// PhysicalDeviceShadingRateImageFeaturesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html
type PhysicalDeviceShadingRateImageFeaturesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV
	PNext                        unsafe.Pointer
	ShadingRateImage             bool
	ShadingRateCoarseSampleOrder bool
}

type _vkPhysicalDeviceShadingRateImageFeaturesNV struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	shadingRateImage             Bool32
	shadingRateCoarseSampleOrder Bool32
}

func (s *_vkPhysicalDeviceShadingRateImageFeaturesNV) Goify() *PhysicalDeviceShadingRateImageFeaturesNV {
	rval := &PhysicalDeviceShadingRateImageFeaturesNV{
		PNext:                        (unsafe.Pointer)(s.pNext),
		ShadingRateImage:             translatePublic_Bool32(s.shadingRateImage),             /*default*/
		ShadingRateCoarseSampleOrder: translatePublic_Bool32(s.shadingRateCoarseSampleOrder), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceShadingRateImageFeaturesNV) Vulkanize() *_vkPhysicalDeviceShadingRateImageFeaturesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShadingRateImageFeaturesNV{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                     /*cb*/
		shadingRateImage:             translateInternal_Bool32(s.ShadingRateImage),                  /*default*/
		shadingRateCoarseSampleOrder: translateInternal_Bool32(s.ShadingRateCoarseSampleOrder),      /*default*/
	}
	return rval
}

// PhysicalDeviceShadingRateImagePropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html
type PhysicalDeviceShadingRateImagePropertiesNV struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV
	PNext                       unsafe.Pointer
	ShadingRateTexelSize        Extent2D
	ShadingRatePaletteSize      uint32
	ShadingRateMaxCoarseSamples uint32
}

// WARNING - struct PhysicalDeviceShadingRateImagePropertiesNV is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceShadingRateImagePropertiesNV struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	shadingRateTexelSize        _vkExtent2D
	shadingRatePaletteSize      uint32
	shadingRateMaxCoarseSamples uint32
}

func (s *_vkPhysicalDeviceShadingRateImagePropertiesNV) Goify() *PhysicalDeviceShadingRateImagePropertiesNV {
	rval := &PhysicalDeviceShadingRateImagePropertiesNV{
		PNext:                       (unsafe.Pointer)(s.pNext),
		ShadingRateTexelSize:        (Extent2D)(s.shadingRateTexelSize),
		ShadingRatePaletteSize:      (uint32)(s.shadingRatePaletteSize),
		ShadingRateMaxCoarseSamples: (uint32)(s.shadingRateMaxCoarseSamples),
	}
	return rval
}
func (s *PhysicalDeviceShadingRateImagePropertiesNV) Vulkanize() *_vkPhysicalDeviceShadingRateImagePropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceShadingRateImagePropertiesNV{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                       /*cb*/
		shadingRateTexelSize:        (_vkExtent2D)(s.ShadingRateTexelSize),                           /*cb*/
		shadingRatePaletteSize:      (uint32)(s.ShadingRatePaletteSize),                              /*cb*/
		shadingRateMaxCoarseSamples: (uint32)(s.ShadingRateMaxCoarseSamples),                         /*cb*/
	}
	return rval
}

// PhysicalDeviceSparseImageFormatInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html
type PhysicalDeviceSparseImageFormatInfo2 struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2
	PNext   unsafe.Pointer
	Format  Format
	Typ     ImageType
	Samples SampleCountFlagBits
	Usage   ImageUsageFlags
	Tiling  ImageTiling
}

type _vkPhysicalDeviceSparseImageFormatInfo2 struct {
	sType   StructureType
	pNext   unsafe.Pointer
	format  Format
	typ     ImageType
	samples SampleCountFlagBits
	usage   ImageUsageFlags
	tiling  ImageTiling
}

func (s *_vkPhysicalDeviceSparseImageFormatInfo2) Goify() *PhysicalDeviceSparseImageFormatInfo2 {
	rval := &PhysicalDeviceSparseImageFormatInfo2{
		PNext:   (unsafe.Pointer)(s.pNext),
		Format:  (Format)(s.format),
		Typ:     (ImageType)(s.typ),
		Samples: (SampleCountFlagBits)(s.samples),
		Usage:   (ImageUsageFlags)(s.usage),
		Tiling:  (ImageTiling)(s.tiling),
	}
	return rval
}
func (s *PhysicalDeviceSparseImageFormatInfo2) Vulkanize() *_vkPhysicalDeviceSparseImageFormatInfo2 {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSparseImageFormatInfo2{
		sType:   STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, /*c1*/
		pNext:   (unsafe.Pointer)(s.PNext),                                 /*cb*/
		format:  (Format)(s.Format),                                        /*cb*/
		typ:     (ImageType)(s.Typ),                                        /*cb*/
		samples: (SampleCountFlagBits)(s.Samples),                          /*cb*/
		usage:   (ImageUsageFlags)(s.Usage),                                /*cb*/
		tiling:  (ImageTiling)(s.Tiling),                                   /*cb*/
	}
	return rval
}

// PhysicalDeviceSparseImageFormatInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseImageFormatInfo2KHR.html
type PhysicalDeviceSparseImageFormatInfo2KHR struct {
}

type _vkPhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2KHR

func (s *_vkPhysicalDeviceSparseImageFormatInfo2KHR) Goify() *PhysicalDeviceSparseImageFormatInfo2KHR {
	rval := (*PhysicalDeviceSparseImageFormatInfo2KHR)(s)
	return rval
}
func (s *PhysicalDeviceSparseImageFormatInfo2KHR) Vulkanize() *_vkPhysicalDeviceSparseImageFormatInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceSparseImageFormatInfo2KHR)(s)
	return rval
}

// PhysicalDeviceSparseProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseProperties.html
type PhysicalDeviceSparseProperties struct {
	//  Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format);
	ResidencyStandard2DBlockShape bool
	//  Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format);
	ResidencyStandard2DMultisampleBlockShape bool
	//  Sparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format);
	ResidencyStandard3DBlockShape bool
	//  Sparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail;
	ResidencyAlignedMipSize bool
	//  Sparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded;
	ResidencyNonResidentStrict bool
}

// WARNING - struct PhysicalDeviceSparseProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceSparseProperties struct {
	residencyStandard2DBlockShape            Bool32
	residencyStandard2DMultisampleBlockShape Bool32
	residencyStandard3DBlockShape            Bool32
	residencyAlignedMipSize                  Bool32
	residencyNonResidentStrict               Bool32
}

func (s *_vkPhysicalDeviceSparseProperties) Goify() *PhysicalDeviceSparseProperties {
	rval := &PhysicalDeviceSparseProperties{
		ResidencyStandard2DBlockShape:            translatePublic_Bool32(s.residencyStandard2DBlockShape),            /*default*/
		ResidencyStandard2DMultisampleBlockShape: translatePublic_Bool32(s.residencyStandard2DMultisampleBlockShape), /*default*/
		ResidencyStandard3DBlockShape:            translatePublic_Bool32(s.residencyStandard3DBlockShape),            /*default*/
		ResidencyAlignedMipSize:                  translatePublic_Bool32(s.residencyAlignedMipSize),                  /*default*/
		ResidencyNonResidentStrict:               translatePublic_Bool32(s.residencyNonResidentStrict),               /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSparseProperties) Vulkanize() *_vkPhysicalDeviceSparseProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSparseProperties{
		residencyStandard2DBlockShape:            translateInternal_Bool32(s.ResidencyStandard2DBlockShape),            /*default*/
		residencyStandard2DMultisampleBlockShape: translateInternal_Bool32(s.ResidencyStandard2DMultisampleBlockShape), /*default*/
		residencyStandard3DBlockShape:            translateInternal_Bool32(s.ResidencyStandard3DBlockShape),            /*default*/
		residencyAlignedMipSize:                  translateInternal_Bool32(s.ResidencyAlignedMipSize),                  /*default*/
		residencyNonResidentStrict:               translateInternal_Bool32(s.ResidencyNonResidentStrict),               /*default*/
	}
	return rval
}

// PhysicalDeviceSubgroupProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html
type PhysicalDeviceSubgroupProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES
	PNext unsafe.Pointer
	//  The size of a subgroup for this queue.;
	SubgroupSize uint32
	//  Bitfield of what shader stages support subgroup operations;
	SupportedStages ShaderStageFlags
	//  Bitfield of what subgroup operations are supported.;
	SupportedOperations SubgroupFeatureFlags
	//  Flag to specify whether quad operations are available in all stages.;
	QuadOperationsInAllStages bool
}

// WARNING - struct PhysicalDeviceSubgroupProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceSubgroupProperties struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	subgroupSize              uint32
	supportedStages           ShaderStageFlags
	supportedOperations       SubgroupFeatureFlags
	quadOperationsInAllStages Bool32
}

func (s *_vkPhysicalDeviceSubgroupProperties) Goify() *PhysicalDeviceSubgroupProperties {
	rval := &PhysicalDeviceSubgroupProperties{
		PNext:                     (unsafe.Pointer)(s.pNext),
		SubgroupSize:              (uint32)(s.subgroupSize),
		SupportedStages:           (ShaderStageFlags)(s.supportedStages),
		SupportedOperations:       (SubgroupFeatureFlags)(s.supportedOperations),
		QuadOperationsInAllStages: translatePublic_Bool32(s.quadOperationsInAllStages), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSubgroupProperties) Vulkanize() *_vkPhysicalDeviceSubgroupProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSubgroupProperties{
		sType:                     STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,    /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                             /*cb*/
		subgroupSize:              (uint32)(s.SubgroupSize),                              /*cb*/
		supportedStages:           (ShaderStageFlags)(s.SupportedStages),                 /*cb*/
		supportedOperations:       (SubgroupFeatureFlags)(s.SupportedOperations),         /*cb*/
		quadOperationsInAllStages: translateInternal_Bool32(s.QuadOperationsInAllStages), /*default*/
	}
	return rval
}

// PhysicalDeviceSubgroupSizeControlFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.html
type PhysicalDeviceSubgroupSizeControlFeaturesEXT struct {
}

type _vkPhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeaturesEXT

func (s *_vkPhysicalDeviceSubgroupSizeControlFeaturesEXT) Goify() *PhysicalDeviceSubgroupSizeControlFeaturesEXT {
	rval := (*PhysicalDeviceSubgroupSizeControlFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceSubgroupSizeControlFeaturesEXT) Vulkanize() *_vkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceSubgroupSizeControlFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceSubgroupSizeControlPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlPropertiesEXT.html
type PhysicalDeviceSubgroupSizeControlPropertiesEXT struct {
}

type _vkPhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlPropertiesEXT

func (s *_vkPhysicalDeviceSubgroupSizeControlPropertiesEXT) Goify() *PhysicalDeviceSubgroupSizeControlPropertiesEXT {
	rval := (*PhysicalDeviceSubgroupSizeControlPropertiesEXT)(s)
	return rval
}
func (s *PhysicalDeviceSubgroupSizeControlPropertiesEXT) Vulkanize() *_vkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceSubgroupSizeControlPropertiesEXT)(s)
	return rval
}

// PhysicalDeviceSubpassMergeFeedbackFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.html
type PhysicalDeviceSubpassMergeFeedbackFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT
	PNext                unsafe.Pointer
	SubpassMergeFeedback bool
}

type _vkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT struct {
	sType                StructureType
	pNext                unsafe.Pointer
	subpassMergeFeedback Bool32
}

func (s *_vkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT) Goify() *PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
	rval := &PhysicalDeviceSubpassMergeFeedbackFeaturesEXT{
		PNext:                (unsafe.Pointer)(s.pNext),
		SubpassMergeFeedback: translatePublic_Bool32(s.subpassMergeFeedback), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSubpassMergeFeedbackFeaturesEXT) Vulkanize() *_vkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT{
		sType:                STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                          /*cb*/
		subpassMergeFeedback: translateInternal_Bool32(s.SubpassMergeFeedback),                   /*default*/
	}
	return rval
}

// PhysicalDeviceSubpassShadingFeaturesHUAWEI: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html
type PhysicalDeviceSubpassShadingFeaturesHUAWEI struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI
	PNext          unsafe.Pointer
	SubpassShading bool
}

type _vkPhysicalDeviceSubpassShadingFeaturesHUAWEI struct {
	sType          StructureType
	pNext          unsafe.Pointer
	subpassShading Bool32
}

func (s *_vkPhysicalDeviceSubpassShadingFeaturesHUAWEI) Goify() *PhysicalDeviceSubpassShadingFeaturesHUAWEI {
	rval := &PhysicalDeviceSubpassShadingFeaturesHUAWEI{
		PNext:          (unsafe.Pointer)(s.pNext),
		SubpassShading: translatePublic_Bool32(s.subpassShading), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSubpassShadingFeaturesHUAWEI) Vulkanize() *_vkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSubpassShadingFeaturesHUAWEI{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                      /*cb*/
		subpassShading: translateInternal_Bool32(s.SubpassShading),                     /*default*/
	}
	return rval
}

// PhysicalDeviceSubpassShadingPropertiesHUAWEI: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html
type PhysicalDeviceSubpassShadingPropertiesHUAWEI struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI
	PNext                                     unsafe.Pointer
	MaxSubpassShadingWorkgroupSizeAspectRatio uint32
}

// WARNING - struct PhysicalDeviceSubpassShadingPropertiesHUAWEI is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceSubpassShadingPropertiesHUAWEI struct {
	sType                                     StructureType
	pNext                                     unsafe.Pointer
	maxSubpassShadingWorkgroupSizeAspectRatio uint32
}

func (s *_vkPhysicalDeviceSubpassShadingPropertiesHUAWEI) Goify() *PhysicalDeviceSubpassShadingPropertiesHUAWEI {
	rval := &PhysicalDeviceSubpassShadingPropertiesHUAWEI{
		PNext: (unsafe.Pointer)(s.pNext),
		MaxSubpassShadingWorkgroupSizeAspectRatio: (uint32)(s.maxSubpassShadingWorkgroupSizeAspectRatio),
	}
	return rval
}
func (s *PhysicalDeviceSubpassShadingPropertiesHUAWEI) Vulkanize() *_vkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSubpassShadingPropertiesHUAWEI{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                        /*cb*/
		maxSubpassShadingWorkgroupSizeAspectRatio: (uint32)(s.MaxSubpassShadingWorkgroupSizeAspectRatio), /*cb*/
	}
	return rval
}

// PhysicalDeviceSurfaceInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html
type PhysicalDeviceSurfaceInfo2KHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR
	PNext   unsafe.Pointer
	Surface SurfaceKHR
}

type _vkPhysicalDeviceSurfaceInfo2KHR struct {
	sType   StructureType
	pNext   unsafe.Pointer
	surface SurfaceKHR
}

func (s *_vkPhysicalDeviceSurfaceInfo2KHR) Goify() *PhysicalDeviceSurfaceInfo2KHR {
	rval := &PhysicalDeviceSurfaceInfo2KHR{
		PNext:   (unsafe.Pointer)(s.pNext),
		Surface: (SurfaceKHR)(s.surface),
	}
	return rval
}
func (s *PhysicalDeviceSurfaceInfo2KHR) Vulkanize() *_vkPhysicalDeviceSurfaceInfo2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSurfaceInfo2KHR{
		sType:   STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, /*c1*/
		pNext:   (unsafe.Pointer)(s.PNext),                         /*cb*/
		surface: (SurfaceKHR)(s.Surface),                           /*cb*/
	}
	return rval
}

// PhysicalDeviceSwapchainMaintenance1FeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.html
type PhysicalDeviceSwapchainMaintenance1FeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT
	PNext                 unsafe.Pointer
	SwapchainMaintenance1 bool
}

type _vkPhysicalDeviceSwapchainMaintenance1FeaturesEXT struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	swapchainMaintenance1 Bool32
}

func (s *_vkPhysicalDeviceSwapchainMaintenance1FeaturesEXT) Goify() *PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
	rval := &PhysicalDeviceSwapchainMaintenance1FeaturesEXT{
		PNext:                 (unsafe.Pointer)(s.pNext),
		SwapchainMaintenance1: translatePublic_Bool32(s.swapchainMaintenance1), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceSwapchainMaintenance1FeaturesEXT) Vulkanize() *_vkPhysicalDeviceSwapchainMaintenance1FeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceSwapchainMaintenance1FeaturesEXT{
		sType:                 STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                           /*cb*/
		swapchainMaintenance1: translateInternal_Bool32(s.SwapchainMaintenance1),                   /*default*/
	}
	return rval
}

// PhysicalDeviceSynchronization2FeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSynchronization2FeaturesKHR.html
type PhysicalDeviceSynchronization2FeaturesKHR struct {
}

type _vkPhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2FeaturesKHR

func (s *_vkPhysicalDeviceSynchronization2FeaturesKHR) Goify() *PhysicalDeviceSynchronization2FeaturesKHR {
	rval := (*PhysicalDeviceSynchronization2FeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceSynchronization2FeaturesKHR) Vulkanize() *_vkPhysicalDeviceSynchronization2FeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceSynchronization2FeaturesKHR)(s)
	return rval
}

// PhysicalDeviceTexelBufferAlignmentFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html
type PhysicalDeviceTexelBufferAlignmentFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT
	PNext                unsafe.Pointer
	TexelBufferAlignment bool
}

type _vkPhysicalDeviceTexelBufferAlignmentFeaturesEXT struct {
	sType                StructureType
	pNext                unsafe.Pointer
	texelBufferAlignment Bool32
}

func (s *_vkPhysicalDeviceTexelBufferAlignmentFeaturesEXT) Goify() *PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
	rval := &PhysicalDeviceTexelBufferAlignmentFeaturesEXT{
		PNext:                (unsafe.Pointer)(s.pNext),
		TexelBufferAlignment: translatePublic_Bool32(s.texelBufferAlignment), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceTexelBufferAlignmentFeaturesEXT) Vulkanize() *_vkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceTexelBufferAlignmentFeaturesEXT{
		sType:                STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                          /*cb*/
		texelBufferAlignment: translateInternal_Bool32(s.TexelBufferAlignment),                   /*default*/
	}
	return rval
}

// PhysicalDeviceTexelBufferAlignmentPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT.html
type PhysicalDeviceTexelBufferAlignmentPropertiesEXT struct {
}

type _vkPhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentPropertiesEXT

func (s *_vkPhysicalDeviceTexelBufferAlignmentPropertiesEXT) Goify() *PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
	rval := (*PhysicalDeviceTexelBufferAlignmentPropertiesEXT)(s)
	return rval
}
func (s *PhysicalDeviceTexelBufferAlignmentPropertiesEXT) Vulkanize() *_vkPhysicalDeviceTexelBufferAlignmentPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)(s)
	return rval
}

// PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT.html
type PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT struct {
}

type _vkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT

func (s *_vkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT) Goify() *PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
	rval := (*PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)(s)
	return rval
}
func (s *PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT) Vulkanize() *_vkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)(s)
	return rval
}

// PhysicalDeviceTilePropertiesFeaturesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTilePropertiesFeaturesQCOM.html
type PhysicalDeviceTilePropertiesFeaturesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM
	PNext          unsafe.Pointer
	TileProperties bool
}

type _vkPhysicalDeviceTilePropertiesFeaturesQCOM struct {
	sType          StructureType
	pNext          unsafe.Pointer
	tileProperties Bool32
}

func (s *_vkPhysicalDeviceTilePropertiesFeaturesQCOM) Goify() *PhysicalDeviceTilePropertiesFeaturesQCOM {
	rval := &PhysicalDeviceTilePropertiesFeaturesQCOM{
		PNext:          (unsafe.Pointer)(s.pNext),
		TileProperties: translatePublic_Bool32(s.tileProperties), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceTilePropertiesFeaturesQCOM) Vulkanize() *_vkPhysicalDeviceTilePropertiesFeaturesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceTilePropertiesFeaturesQCOM{
		sType:          STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                    /*cb*/
		tileProperties: translateInternal_Bool32(s.TileProperties),                   /*default*/
	}
	return rval
}

// PhysicalDeviceTimelineSemaphoreFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html
type PhysicalDeviceTimelineSemaphoreFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES
	PNext             unsafe.Pointer
	TimelineSemaphore bool
}

type _vkPhysicalDeviceTimelineSemaphoreFeatures struct {
	sType             StructureType
	pNext             unsafe.Pointer
	timelineSemaphore Bool32
}

func (s *_vkPhysicalDeviceTimelineSemaphoreFeatures) Goify() *PhysicalDeviceTimelineSemaphoreFeatures {
	rval := &PhysicalDeviceTimelineSemaphoreFeatures{
		PNext:             (unsafe.Pointer)(s.pNext),
		TimelineSemaphore: translatePublic_Bool32(s.timelineSemaphore), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceTimelineSemaphoreFeatures) Vulkanize() *_vkPhysicalDeviceTimelineSemaphoreFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceTimelineSemaphoreFeatures{
		sType:             STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                  /*cb*/
		timelineSemaphore: translateInternal_Bool32(s.TimelineSemaphore),              /*default*/
	}
	return rval
}

// PhysicalDeviceTimelineSemaphoreFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreFeaturesKHR.html
type PhysicalDeviceTimelineSemaphoreFeaturesKHR struct {
}

type _vkPhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeaturesKHR

func (s *_vkPhysicalDeviceTimelineSemaphoreFeaturesKHR) Goify() *PhysicalDeviceTimelineSemaphoreFeaturesKHR {
	rval := (*PhysicalDeviceTimelineSemaphoreFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceTimelineSemaphoreFeaturesKHR) Vulkanize() *_vkPhysicalDeviceTimelineSemaphoreFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceTimelineSemaphoreFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceTimelineSemaphoreProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html
type PhysicalDeviceTimelineSemaphoreProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES
	PNext                               unsafe.Pointer
	MaxTimelineSemaphoreValueDifference uint64
}

// WARNING - struct PhysicalDeviceTimelineSemaphoreProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceTimelineSemaphoreProperties struct {
	sType                               StructureType
	pNext                               unsafe.Pointer
	maxTimelineSemaphoreValueDifference uint64
}

func (s *_vkPhysicalDeviceTimelineSemaphoreProperties) Goify() *PhysicalDeviceTimelineSemaphoreProperties {
	rval := &PhysicalDeviceTimelineSemaphoreProperties{
		PNext:                               (unsafe.Pointer)(s.pNext),
		MaxTimelineSemaphoreValueDifference: (uint64)(s.maxTimelineSemaphoreValueDifference),
	}
	return rval
}
func (s *PhysicalDeviceTimelineSemaphoreProperties) Vulkanize() *_vkPhysicalDeviceTimelineSemaphoreProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceTimelineSemaphoreProperties{
		sType:                               STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, /*c1*/
		pNext:                               (unsafe.Pointer)(s.PNext),                                    /*cb*/
		maxTimelineSemaphoreValueDifference: (uint64)(s.MaxTimelineSemaphoreValueDifference),              /*cb*/
	}
	return rval
}

// PhysicalDeviceTimelineSemaphorePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphorePropertiesKHR.html
type PhysicalDeviceTimelineSemaphorePropertiesKHR struct {
}

type _vkPhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphorePropertiesKHR

func (s *_vkPhysicalDeviceTimelineSemaphorePropertiesKHR) Goify() *PhysicalDeviceTimelineSemaphorePropertiesKHR {
	rval := (*PhysicalDeviceTimelineSemaphorePropertiesKHR)(s)
	return rval
}
func (s *PhysicalDeviceTimelineSemaphorePropertiesKHR) Vulkanize() *_vkPhysicalDeviceTimelineSemaphorePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceTimelineSemaphorePropertiesKHR)(s)
	return rval
}

// PhysicalDeviceToolProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceToolProperties.html
type PhysicalDeviceToolProperties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES
	PNext       unsafe.Pointer
	Name        string
	Version     string
	Purposes    ToolPurposeFlags
	Description string
	Layer       string
}

// WARNING - struct PhysicalDeviceToolProperties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceToolProperties struct {
	sType       StructureType
	pNext       unsafe.Pointer
	name        [MAX_EXTENSION_NAME_SIZE]byte
	version     [MAX_EXTENSION_NAME_SIZE]byte
	purposes    ToolPurposeFlags
	description [MAX_DESCRIPTION_SIZE]byte
	layer       [MAX_EXTENSION_NAME_SIZE]byte
}

func (s *_vkPhysicalDeviceToolProperties) Goify() *PhysicalDeviceToolProperties {
	rval := &PhysicalDeviceToolProperties{
		PNext:       (unsafe.Pointer)(s.pNext),
		Name:        nullTermBytesToString(s.name[:]),    /*c arr*/
		Version:     nullTermBytesToString(s.version[:]), /*c arr*/
		Purposes:    (ToolPurposeFlags)(s.purposes),
		Description: nullTermBytesToString(s.description[:]), /*c arr*/
		Layer:       nullTermBytesToString(s.layer[:]),       /*c arr*/
	}
	return rval
}
func (s *PhysicalDeviceToolProperties) Vulkanize() *_vkPhysicalDeviceToolProperties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceToolProperties{
		sType: STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                      /*cb*/
		// name : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		// version : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		purposes: (ToolPurposeFlags)(s.Purposes), /*cb*/
		// description : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		// layer : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
	}
	return rval
}

// PhysicalDeviceToolPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceToolPropertiesEXT.html
type PhysicalDeviceToolPropertiesEXT struct {
}

type _vkPhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolPropertiesEXT

func (s *_vkPhysicalDeviceToolPropertiesEXT) Goify() *PhysicalDeviceToolPropertiesEXT {
	rval := (*PhysicalDeviceToolPropertiesEXT)(s)
	return rval
}
func (s *PhysicalDeviceToolPropertiesEXT) Vulkanize() *_vkPhysicalDeviceToolPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceToolPropertiesEXT)(s)
	return rval
}

// PhysicalDeviceTransformFeedbackFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html
type PhysicalDeviceTransformFeedbackFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT
	PNext             unsafe.Pointer
	TransformFeedback bool
	GeometryStreams   bool
}

type _vkPhysicalDeviceTransformFeedbackFeaturesEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	transformFeedback Bool32
	geometryStreams   Bool32
}

func (s *_vkPhysicalDeviceTransformFeedbackFeaturesEXT) Goify() *PhysicalDeviceTransformFeedbackFeaturesEXT {
	rval := &PhysicalDeviceTransformFeedbackFeaturesEXT{
		PNext:             (unsafe.Pointer)(s.pNext),
		TransformFeedback: translatePublic_Bool32(s.transformFeedback), /*default*/
		GeometryStreams:   translatePublic_Bool32(s.geometryStreams),   /*default*/
	}
	return rval
}
func (s *PhysicalDeviceTransformFeedbackFeaturesEXT) Vulkanize() *_vkPhysicalDeviceTransformFeedbackFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceTransformFeedbackFeaturesEXT{
		sType:             STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                      /*cb*/
		transformFeedback: translateInternal_Bool32(s.TransformFeedback),                  /*default*/
		geometryStreams:   translateInternal_Bool32(s.GeometryStreams),                    /*default*/
	}
	return rval
}

// PhysicalDeviceTransformFeedbackPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html
type PhysicalDeviceTransformFeedbackPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT
	PNext                                      unsafe.Pointer
	MaxTransformFeedbackStreams                uint32
	MaxTransformFeedbackBuffers                uint32
	MaxTransformFeedbackBufferSize             DeviceSize
	MaxTransformFeedbackStreamDataSize         uint32
	MaxTransformFeedbackBufferDataSize         uint32
	MaxTransformFeedbackBufferDataStride       uint32
	TransformFeedbackQueries                   bool
	TransformFeedbackStreamsLinesTriangles     bool
	TransformFeedbackRasterizationStreamSelect bool
	TransformFeedbackDraw                      bool
}

// WARNING - struct PhysicalDeviceTransformFeedbackPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceTransformFeedbackPropertiesEXT struct {
	sType                                      StructureType
	pNext                                      unsafe.Pointer
	maxTransformFeedbackStreams                uint32
	maxTransformFeedbackBuffers                uint32
	maxTransformFeedbackBufferSize             DeviceSize
	maxTransformFeedbackStreamDataSize         uint32
	maxTransformFeedbackBufferDataSize         uint32
	maxTransformFeedbackBufferDataStride       uint32
	transformFeedbackQueries                   Bool32
	transformFeedbackStreamsLinesTriangles     Bool32
	transformFeedbackRasterizationStreamSelect Bool32
	transformFeedbackDraw                      Bool32
}

func (s *_vkPhysicalDeviceTransformFeedbackPropertiesEXT) Goify() *PhysicalDeviceTransformFeedbackPropertiesEXT {
	rval := &PhysicalDeviceTransformFeedbackPropertiesEXT{
		PNext:                                      (unsafe.Pointer)(s.pNext),
		MaxTransformFeedbackStreams:                (uint32)(s.maxTransformFeedbackStreams),
		MaxTransformFeedbackBuffers:                (uint32)(s.maxTransformFeedbackBuffers),
		MaxTransformFeedbackBufferSize:             (DeviceSize)(s.maxTransformFeedbackBufferSize),
		MaxTransformFeedbackStreamDataSize:         (uint32)(s.maxTransformFeedbackStreamDataSize),
		MaxTransformFeedbackBufferDataSize:         (uint32)(s.maxTransformFeedbackBufferDataSize),
		MaxTransformFeedbackBufferDataStride:       (uint32)(s.maxTransformFeedbackBufferDataStride),
		TransformFeedbackQueries:                   translatePublic_Bool32(s.transformFeedbackQueries),                   /*default*/
		TransformFeedbackStreamsLinesTriangles:     translatePublic_Bool32(s.transformFeedbackStreamsLinesTriangles),     /*default*/
		TransformFeedbackRasterizationStreamSelect: translatePublic_Bool32(s.transformFeedbackRasterizationStreamSelect), /*default*/
		TransformFeedbackDraw:                      translatePublic_Bool32(s.transformFeedbackDraw),                      /*default*/
	}
	return rval
}
func (s *PhysicalDeviceTransformFeedbackPropertiesEXT) Vulkanize() *_vkPhysicalDeviceTransformFeedbackPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceTransformFeedbackPropertiesEXT{
		sType:                                      STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,       /*c1*/
		pNext:                                      (unsafe.Pointer)(s.PNext),                                              /*cb*/
		maxTransformFeedbackStreams:                (uint32)(s.MaxTransformFeedbackStreams),                                /*cb*/
		maxTransformFeedbackBuffers:                (uint32)(s.MaxTransformFeedbackBuffers),                                /*cb*/
		maxTransformFeedbackBufferSize:             (DeviceSize)(s.MaxTransformFeedbackBufferSize),                         /*cb*/
		maxTransformFeedbackStreamDataSize:         (uint32)(s.MaxTransformFeedbackStreamDataSize),                         /*cb*/
		maxTransformFeedbackBufferDataSize:         (uint32)(s.MaxTransformFeedbackBufferDataSize),                         /*cb*/
		maxTransformFeedbackBufferDataStride:       (uint32)(s.MaxTransformFeedbackBufferDataStride),                       /*cb*/
		transformFeedbackQueries:                   translateInternal_Bool32(s.TransformFeedbackQueries),                   /*default*/
		transformFeedbackStreamsLinesTriangles:     translateInternal_Bool32(s.TransformFeedbackStreamsLinesTriangles),     /*default*/
		transformFeedbackRasterizationStreamSelect: translateInternal_Bool32(s.TransformFeedbackRasterizationStreamSelect), /*default*/
		transformFeedbackDraw:                      translateInternal_Bool32(s.TransformFeedbackDraw),                      /*default*/
	}
	return rval
}

// PhysicalDeviceUniformBufferStandardLayoutFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html
type PhysicalDeviceUniformBufferStandardLayoutFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES
	PNext                       unsafe.Pointer
	UniformBufferStandardLayout bool
}

type _vkPhysicalDeviceUniformBufferStandardLayoutFeatures struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	uniformBufferStandardLayout Bool32
}

func (s *_vkPhysicalDeviceUniformBufferStandardLayoutFeatures) Goify() *PhysicalDeviceUniformBufferStandardLayoutFeatures {
	rval := &PhysicalDeviceUniformBufferStandardLayoutFeatures{
		PNext:                       (unsafe.Pointer)(s.pNext),
		UniformBufferStandardLayout: translatePublic_Bool32(s.uniformBufferStandardLayout), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceUniformBufferStandardLayoutFeatures) Vulkanize() *_vkPhysicalDeviceUniformBufferStandardLayoutFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceUniformBufferStandardLayoutFeatures{
		sType:                       STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                              /*cb*/
		uniformBufferStandardLayout: translateInternal_Bool32(s.UniformBufferStandardLayout),                /*default*/
	}
	return rval
}

// PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR.html
type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR struct {
}

type _vkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR

func (s *_vkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR) Goify() *PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR {
	rval := (*PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR) Vulkanize() *_vkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceVariablePointerFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVariablePointerFeatures.html
type PhysicalDeviceVariablePointerFeatures struct {
}

type _vkPhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointerFeatures

func (s *_vkPhysicalDeviceVariablePointerFeatures) Goify() *PhysicalDeviceVariablePointerFeatures {
	rval := (*PhysicalDeviceVariablePointerFeatures)(s)
	return rval
}
func (s *PhysicalDeviceVariablePointerFeatures) Vulkanize() *_vkPhysicalDeviceVariablePointerFeatures {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceVariablePointerFeatures)(s)
	return rval
}

// PhysicalDeviceVariablePointerFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVariablePointerFeaturesKHR.html
type PhysicalDeviceVariablePointerFeaturesKHR struct {
}

type _vkPhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointerFeaturesKHR

func (s *_vkPhysicalDeviceVariablePointerFeaturesKHR) Goify() *PhysicalDeviceVariablePointerFeaturesKHR {
	rval := (*PhysicalDeviceVariablePointerFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceVariablePointerFeaturesKHR) Vulkanize() *_vkPhysicalDeviceVariablePointerFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceVariablePointerFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceVariablePointersFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVariablePointersFeatures.html
type PhysicalDeviceVariablePointersFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES
	PNext                         unsafe.Pointer
	VariablePointersStorageBuffer bool
	VariablePointers              bool
}

type _vkPhysicalDeviceVariablePointersFeatures struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	variablePointersStorageBuffer Bool32
	variablePointers              Bool32
}

func (s *_vkPhysicalDeviceVariablePointersFeatures) Goify() *PhysicalDeviceVariablePointersFeatures {
	rval := &PhysicalDeviceVariablePointersFeatures{
		PNext:                         (unsafe.Pointer)(s.pNext),
		VariablePointersStorageBuffer: translatePublic_Bool32(s.variablePointersStorageBuffer), /*default*/
		VariablePointers:              translatePublic_Bool32(s.variablePointers),              /*default*/
	}
	return rval
}
func (s *PhysicalDeviceVariablePointersFeatures) Vulkanize() *_vkPhysicalDeviceVariablePointersFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVariablePointersFeatures{
		sType:                         STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                 /*cb*/
		variablePointersStorageBuffer: translateInternal_Bool32(s.VariablePointersStorageBuffer), /*default*/
		variablePointers:              translateInternal_Bool32(s.VariablePointers),              /*default*/
	}
	return rval
}

// PhysicalDeviceVariablePointersFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVariablePointersFeaturesKHR.html
type PhysicalDeviceVariablePointersFeaturesKHR struct {
}

type _vkPhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeaturesKHR

func (s *_vkPhysicalDeviceVariablePointersFeaturesKHR) Goify() *PhysicalDeviceVariablePointersFeaturesKHR {
	rval := (*PhysicalDeviceVariablePointersFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceVariablePointersFeaturesKHR) Vulkanize() *_vkPhysicalDeviceVariablePointersFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceVariablePointersFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceVertexAttributeDivisorFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html
type PhysicalDeviceVertexAttributeDivisorFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT
	PNext                                  unsafe.Pointer
	VertexAttributeInstanceRateDivisor     bool
	VertexAttributeInstanceRateZeroDivisor bool
}

type _vkPhysicalDeviceVertexAttributeDivisorFeaturesEXT struct {
	sType                                  StructureType
	pNext                                  unsafe.Pointer
	vertexAttributeInstanceRateDivisor     Bool32
	vertexAttributeInstanceRateZeroDivisor Bool32
}

func (s *_vkPhysicalDeviceVertexAttributeDivisorFeaturesEXT) Goify() *PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
	rval := &PhysicalDeviceVertexAttributeDivisorFeaturesEXT{
		PNext:                                  (unsafe.Pointer)(s.pNext),
		VertexAttributeInstanceRateDivisor:     translatePublic_Bool32(s.vertexAttributeInstanceRateDivisor),     /*default*/
		VertexAttributeInstanceRateZeroDivisor: translatePublic_Bool32(s.vertexAttributeInstanceRateZeroDivisor), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceVertexAttributeDivisorFeaturesEXT) Vulkanize() *_vkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVertexAttributeDivisorFeaturesEXT{
		sType:                                  STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, /*c1*/
		pNext:                                  (unsafe.Pointer)(s.PNext),                                            /*cb*/
		vertexAttributeInstanceRateDivisor:     translateInternal_Bool32(s.VertexAttributeInstanceRateDivisor),       /*default*/
		vertexAttributeInstanceRateZeroDivisor: translateInternal_Bool32(s.VertexAttributeInstanceRateZeroDivisor),   /*default*/
	}
	return rval
}

// PhysicalDeviceVertexAttributeDivisorPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html
type PhysicalDeviceVertexAttributeDivisorPropertiesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT
	PNext unsafe.Pointer
	//  max value of vertex attribute divisor;
	MaxVertexAttribDivisor uint32
}

// WARNING - struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceVertexAttributeDivisorPropertiesEXT struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	maxVertexAttribDivisor uint32
}

func (s *_vkPhysicalDeviceVertexAttributeDivisorPropertiesEXT) Goify() *PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
	rval := &PhysicalDeviceVertexAttributeDivisorPropertiesEXT{
		PNext:                  (unsafe.Pointer)(s.pNext),
		MaxVertexAttribDivisor: (uint32)(s.maxVertexAttribDivisor),
	}
	return rval
}
func (s *PhysicalDeviceVertexAttributeDivisorPropertiesEXT) Vulkanize() *_vkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVertexAttributeDivisorPropertiesEXT{
		sType:                  STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                              /*cb*/
		maxVertexAttribDivisor: (uint32)(s.MaxVertexAttribDivisor),                                     /*cb*/
	}
	return rval
}

// PhysicalDeviceVertexInputDynamicStateFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html
type PhysicalDeviceVertexInputDynamicStateFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT
	PNext                   unsafe.Pointer
	VertexInputDynamicState bool
}

type _vkPhysicalDeviceVertexInputDynamicStateFeaturesEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	vertexInputDynamicState Bool32
}

func (s *_vkPhysicalDeviceVertexInputDynamicStateFeaturesEXT) Goify() *PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
	rval := &PhysicalDeviceVertexInputDynamicStateFeaturesEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		VertexInputDynamicState: translatePublic_Bool32(s.vertexInputDynamicState), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceVertexInputDynamicStateFeaturesEXT) Vulkanize() *_vkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVertexInputDynamicStateFeaturesEXT{
		sType:                   STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                              /*cb*/
		vertexInputDynamicState: translateInternal_Bool32(s.VertexInputDynamicState),                    /*default*/
	}
	return rval
}

// PhysicalDeviceVideoFormatInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html
type PhysicalDeviceVideoFormatInfoKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR
	PNext      unsafe.Pointer
	ImageUsage ImageUsageFlags
}

type _vkPhysicalDeviceVideoFormatInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	imageUsage ImageUsageFlags
}

func (s *_vkPhysicalDeviceVideoFormatInfoKHR) Goify() *PhysicalDeviceVideoFormatInfoKHR {
	rval := &PhysicalDeviceVideoFormatInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		ImageUsage: (ImageUsageFlags)(s.imageUsage),
	}
	return rval
}
func (s *PhysicalDeviceVideoFormatInfoKHR) Vulkanize() *_vkPhysicalDeviceVideoFormatInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVideoFormatInfoKHR{
		sType:      STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                            /*cb*/
		imageUsage: (ImageUsageFlags)(s.ImageUsage),                      /*cb*/
	}
	return rval
}

// PhysicalDeviceVulkan11Features: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Features.html
type PhysicalDeviceVulkan11Features struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES
	PNext unsafe.Pointer
	//  16-bit integer/floating-point variables supported in BufferBlock;
	StorageBuffer16BitAccess bool
	//  16-bit integer/floating-point variables supported in BufferBlock and Block;
	UniformAndStorageBuffer16BitAccess bool
	//  16-bit integer/floating-point variables supported in PushConstant;
	StoragePushConstant16 bool
	//  16-bit integer/floating-point variables supported in shader inputs and outputs;
	StorageInputOutput16 bool
	//  Multiple views in a renderpass;
	Multiview bool
	//  Multiple views in a renderpass w/ geometry shader;
	MultiviewGeometryShader bool
	//  Multiple views in a renderpass w/ tessellation shader;
	MultiviewTessellationShader   bool
	VariablePointersStorageBuffer bool
	VariablePointers              bool
	ProtectedMemory               bool
	//  Sampler color conversion supported;
	SamplerYcbcrConversion bool
	ShaderDrawParameters   bool
}

type _vkPhysicalDeviceVulkan11Features struct {
	sType                              StructureType
	pNext                              unsafe.Pointer
	storageBuffer16BitAccess           Bool32
	uniformAndStorageBuffer16BitAccess Bool32
	storagePushConstant16              Bool32
	storageInputOutput16               Bool32
	multiview                          Bool32
	multiviewGeometryShader            Bool32
	multiviewTessellationShader        Bool32
	variablePointersStorageBuffer      Bool32
	variablePointers                   Bool32
	protectedMemory                    Bool32
	samplerYcbcrConversion             Bool32
	shaderDrawParameters               Bool32
}

func (s *_vkPhysicalDeviceVulkan11Features) Goify() *PhysicalDeviceVulkan11Features {
	rval := &PhysicalDeviceVulkan11Features{
		PNext:                              (unsafe.Pointer)(s.pNext),
		StorageBuffer16BitAccess:           translatePublic_Bool32(s.storageBuffer16BitAccess),           /*default*/
		UniformAndStorageBuffer16BitAccess: translatePublic_Bool32(s.uniformAndStorageBuffer16BitAccess), /*default*/
		StoragePushConstant16:              translatePublic_Bool32(s.storagePushConstant16),              /*default*/
		StorageInputOutput16:               translatePublic_Bool32(s.storageInputOutput16),               /*default*/
		Multiview:                          translatePublic_Bool32(s.multiview),                          /*default*/
		MultiviewGeometryShader:            translatePublic_Bool32(s.multiviewGeometryShader),            /*default*/
		MultiviewTessellationShader:        translatePublic_Bool32(s.multiviewTessellationShader),        /*default*/
		VariablePointersStorageBuffer:      translatePublic_Bool32(s.variablePointersStorageBuffer),      /*default*/
		VariablePointers:                   translatePublic_Bool32(s.variablePointers),                   /*default*/
		ProtectedMemory:                    translatePublic_Bool32(s.protectedMemory),                    /*default*/
		SamplerYcbcrConversion:             translatePublic_Bool32(s.samplerYcbcrConversion),             /*default*/
		ShaderDrawParameters:               translatePublic_Bool32(s.shaderDrawParameters),               /*default*/
	}
	return rval
}
func (s *PhysicalDeviceVulkan11Features) Vulkanize() *_vkPhysicalDeviceVulkan11Features {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVulkan11Features{
		sType:                              STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,             /*c1*/
		pNext:                              (unsafe.Pointer)(s.PNext),                                      /*cb*/
		storageBuffer16BitAccess:           translateInternal_Bool32(s.StorageBuffer16BitAccess),           /*default*/
		uniformAndStorageBuffer16BitAccess: translateInternal_Bool32(s.UniformAndStorageBuffer16BitAccess), /*default*/
		storagePushConstant16:              translateInternal_Bool32(s.StoragePushConstant16),              /*default*/
		storageInputOutput16:               translateInternal_Bool32(s.StorageInputOutput16),               /*default*/
		multiview:                          translateInternal_Bool32(s.Multiview),                          /*default*/
		multiviewGeometryShader:            translateInternal_Bool32(s.MultiviewGeometryShader),            /*default*/
		multiviewTessellationShader:        translateInternal_Bool32(s.MultiviewTessellationShader),        /*default*/
		variablePointersStorageBuffer:      translateInternal_Bool32(s.VariablePointersStorageBuffer),      /*default*/
		variablePointers:                   translateInternal_Bool32(s.VariablePointers),                   /*default*/
		protectedMemory:                    translateInternal_Bool32(s.ProtectedMemory),                    /*default*/
		samplerYcbcrConversion:             translateInternal_Bool32(s.SamplerYcbcrConversion),             /*default*/
		shaderDrawParameters:               translateInternal_Bool32(s.ShaderDrawParameters),               /*default*/
	}
	return rval
}

// PhysicalDeviceVulkan11Properties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html
type PhysicalDeviceVulkan11Properties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES
	PNext           unsafe.Pointer
	DeviceUUID      [UUID_SIZE]uint8
	DriverUUID      [UUID_SIZE]uint8
	DeviceLUID      [LUID_SIZE]uint8
	DeviceNodeMask  uint32
	DeviceLUIDValid bool
	//  The size of a subgroup for this queue.;
	SubgroupSize uint32
	//  Bitfield of what shader stages support subgroup operations;
	SubgroupSupportedStages ShaderStageFlags
	//  Bitfield of what subgroup operations are supported.;
	SubgroupSupportedOperations SubgroupFeatureFlags
	//  Flag to specify whether quad operations are available in all stages.;
	SubgroupQuadOperationsInAllStages bool
	PointClippingBehavior             PointClippingBehavior
	//  max number of views in a subpass;
	MaxMultiviewViewCount uint32
	//  max instance index for a draw in a multiview subpass;
	MaxMultiviewInstanceIndex uint32
	ProtectedNoFault          bool
	MaxPerSetDescriptors      uint32
	MaxMemoryAllocationSize   DeviceSize
}

// WARNING - struct PhysicalDeviceVulkan11Properties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceVulkan11Properties struct {
	sType                             StructureType
	pNext                             unsafe.Pointer
	deviceUUID                        [UUID_SIZE]uint8
	driverUUID                        [UUID_SIZE]uint8
	deviceLUID                        [LUID_SIZE]uint8
	deviceNodeMask                    uint32
	deviceLUIDValid                   Bool32
	subgroupSize                      uint32
	subgroupSupportedStages           ShaderStageFlags
	subgroupSupportedOperations       SubgroupFeatureFlags
	subgroupQuadOperationsInAllStages Bool32
	pointClippingBehavior             PointClippingBehavior
	maxMultiviewViewCount             uint32
	maxMultiviewInstanceIndex         uint32
	protectedNoFault                  Bool32
	maxPerSetDescriptors              uint32
	maxMemoryAllocationSize           DeviceSize
}

func (s *_vkPhysicalDeviceVulkan11Properties) Goify() *PhysicalDeviceVulkan11Properties {
	rval := &PhysicalDeviceVulkan11Properties{
		PNext:                             (unsafe.Pointer)(s.pNext),
		DeviceUUID:                        ([UUID_SIZE]uint8)(s.deviceUUID),
		DriverUUID:                        ([UUID_SIZE]uint8)(s.driverUUID),
		DeviceLUID:                        ([LUID_SIZE]uint8)(s.deviceLUID),
		DeviceNodeMask:                    (uint32)(s.deviceNodeMask),
		DeviceLUIDValid:                   translatePublic_Bool32(s.deviceLUIDValid), /*default*/
		SubgroupSize:                      (uint32)(s.subgroupSize),
		SubgroupSupportedStages:           (ShaderStageFlags)(s.subgroupSupportedStages),
		SubgroupSupportedOperations:       (SubgroupFeatureFlags)(s.subgroupSupportedOperations),
		SubgroupQuadOperationsInAllStages: translatePublic_Bool32(s.subgroupQuadOperationsInAllStages), /*default*/
		PointClippingBehavior:             (PointClippingBehavior)(s.pointClippingBehavior),
		MaxMultiviewViewCount:             (uint32)(s.maxMultiviewViewCount),
		MaxMultiviewInstanceIndex:         (uint32)(s.maxMultiviewInstanceIndex),
		ProtectedNoFault:                  translatePublic_Bool32(s.protectedNoFault), /*default*/
		MaxPerSetDescriptors:              (uint32)(s.maxPerSetDescriptors),
		MaxMemoryAllocationSize:           (DeviceSize)(s.maxMemoryAllocationSize),
	}
	return rval
}
func (s *PhysicalDeviceVulkan11Properties) Vulkanize() *_vkPhysicalDeviceVulkan11Properties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVulkan11Properties{
		sType:                             STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,          /*c1*/
		pNext:                             (unsafe.Pointer)(s.PNext),                                     /*cb*/
		deviceUUID:                        ([UUID_SIZE]uint8)(s.DeviceUUID),                              /*cb*/
		driverUUID:                        ([UUID_SIZE]uint8)(s.DriverUUID),                              /*cb*/
		deviceLUID:                        ([LUID_SIZE]uint8)(s.DeviceLUID),                              /*cb*/
		deviceNodeMask:                    (uint32)(s.DeviceNodeMask),                                    /*cb*/
		deviceLUIDValid:                   translateInternal_Bool32(s.DeviceLUIDValid),                   /*default*/
		subgroupSize:                      (uint32)(s.SubgroupSize),                                      /*cb*/
		subgroupSupportedStages:           (ShaderStageFlags)(s.SubgroupSupportedStages),                 /*cb*/
		subgroupSupportedOperations:       (SubgroupFeatureFlags)(s.SubgroupSupportedOperations),         /*cb*/
		subgroupQuadOperationsInAllStages: translateInternal_Bool32(s.SubgroupQuadOperationsInAllStages), /*default*/
		pointClippingBehavior:             (PointClippingBehavior)(s.PointClippingBehavior),              /*cb*/
		maxMultiviewViewCount:             (uint32)(s.MaxMultiviewViewCount),                             /*cb*/
		maxMultiviewInstanceIndex:         (uint32)(s.MaxMultiviewInstanceIndex),                         /*cb*/
		protectedNoFault:                  translateInternal_Bool32(s.ProtectedNoFault),                  /*default*/
		maxPerSetDescriptors:              (uint32)(s.MaxPerSetDescriptors),                              /*cb*/
		maxMemoryAllocationSize:           (DeviceSize)(s.MaxMemoryAllocationSize),                       /*cb*/
	}
	return rval
}

// PhysicalDeviceVulkan12Features: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Features.html
type PhysicalDeviceVulkan12Features struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES
	PNext                    unsafe.Pointer
	SamplerMirrorClampToEdge bool
	DrawIndirectCount        bool
	//  8-bit integer variables supported in StorageBuffer;
	StorageBuffer8BitAccess bool
	//  8-bit integer variables supported in StorageBuffer and Uniform;
	UniformAndStorageBuffer8BitAccess bool
	//  8-bit integer variables supported in PushConstant;
	StoragePushConstant8     bool
	ShaderBufferInt64Atomics bool
	ShaderSharedInt64Atomics bool
	//  16-bit floats (halfs) in shaders;
	ShaderFloat16 bool
	//  8-bit integers in shaders;
	ShaderInt8                                         bool
	DescriptorIndexing                                 bool
	ShaderInputAttachmentArrayDynamicIndexing          bool
	ShaderUniformTexelBufferArrayDynamicIndexing       bool
	ShaderStorageTexelBufferArrayDynamicIndexing       bool
	ShaderUniformBufferArrayNonUniformIndexing         bool
	ShaderSampledImageArrayNonUniformIndexing          bool
	ShaderStorageBufferArrayNonUniformIndexing         bool
	ShaderStorageImageArrayNonUniformIndexing          bool
	ShaderInputAttachmentArrayNonUniformIndexing       bool
	ShaderUniformTexelBufferArrayNonUniformIndexing    bool
	ShaderStorageTexelBufferArrayNonUniformIndexing    bool
	DescriptorBindingUniformBufferUpdateAfterBind      bool
	DescriptorBindingSampledImageUpdateAfterBind       bool
	DescriptorBindingStorageImageUpdateAfterBind       bool
	DescriptorBindingStorageBufferUpdateAfterBind      bool
	DescriptorBindingUniformTexelBufferUpdateAfterBind bool
	DescriptorBindingStorageTexelBufferUpdateAfterBind bool
	DescriptorBindingUpdateUnusedWhilePending          bool
	DescriptorBindingPartiallyBound                    bool
	DescriptorBindingVariableDescriptorCount           bool
	RuntimeDescriptorArray                             bool
	SamplerFilterMinmax                                bool
	ScalarBlockLayout                                  bool
	ImagelessFramebuffer                               bool
	UniformBufferStandardLayout                        bool
	ShaderSubgroupExtendedTypes                        bool
	SeparateDepthStencilLayouts                        bool
	HostQueryReset                                     bool
	TimelineSemaphore                                  bool
	BufferDeviceAddress                                bool
	BufferDeviceAddressCaptureReplay                   bool
	BufferDeviceAddressMultiDevice                     bool
	VulkanMemoryModel                                  bool
	VulkanMemoryModelDeviceScope                       bool
	VulkanMemoryModelAvailabilityVisibilityChains      bool
	ShaderOutputViewportIndex                          bool
	ShaderOutputLayer                                  bool
	SubgroupBroadcastDynamicId                         bool
}

type _vkPhysicalDeviceVulkan12Features struct {
	sType                                              StructureType
	pNext                                              unsafe.Pointer
	samplerMirrorClampToEdge                           Bool32
	drawIndirectCount                                  Bool32
	storageBuffer8BitAccess                            Bool32
	uniformAndStorageBuffer8BitAccess                  Bool32
	storagePushConstant8                               Bool32
	shaderBufferInt64Atomics                           Bool32
	shaderSharedInt64Atomics                           Bool32
	shaderFloat16                                      Bool32
	shaderInt8                                         Bool32
	descriptorIndexing                                 Bool32
	shaderInputAttachmentArrayDynamicIndexing          Bool32
	shaderUniformTexelBufferArrayDynamicIndexing       Bool32
	shaderStorageTexelBufferArrayDynamicIndexing       Bool32
	shaderUniformBufferArrayNonUniformIndexing         Bool32
	shaderSampledImageArrayNonUniformIndexing          Bool32
	shaderStorageBufferArrayNonUniformIndexing         Bool32
	shaderStorageImageArrayNonUniformIndexing          Bool32
	shaderInputAttachmentArrayNonUniformIndexing       Bool32
	shaderUniformTexelBufferArrayNonUniformIndexing    Bool32
	shaderStorageTexelBufferArrayNonUniformIndexing    Bool32
	descriptorBindingUniformBufferUpdateAfterBind      Bool32
	descriptorBindingSampledImageUpdateAfterBind       Bool32
	descriptorBindingStorageImageUpdateAfterBind       Bool32
	descriptorBindingStorageBufferUpdateAfterBind      Bool32
	descriptorBindingUniformTexelBufferUpdateAfterBind Bool32
	descriptorBindingStorageTexelBufferUpdateAfterBind Bool32
	descriptorBindingUpdateUnusedWhilePending          Bool32
	descriptorBindingPartiallyBound                    Bool32
	descriptorBindingVariableDescriptorCount           Bool32
	runtimeDescriptorArray                             Bool32
	samplerFilterMinmax                                Bool32
	scalarBlockLayout                                  Bool32
	imagelessFramebuffer                               Bool32
	uniformBufferStandardLayout                        Bool32
	shaderSubgroupExtendedTypes                        Bool32
	separateDepthStencilLayouts                        Bool32
	hostQueryReset                                     Bool32
	timelineSemaphore                                  Bool32
	bufferDeviceAddress                                Bool32
	bufferDeviceAddressCaptureReplay                   Bool32
	bufferDeviceAddressMultiDevice                     Bool32
	vulkanMemoryModel                                  Bool32
	vulkanMemoryModelDeviceScope                       Bool32
	vulkanMemoryModelAvailabilityVisibilityChains      Bool32
	shaderOutputViewportIndex                          Bool32
	shaderOutputLayer                                  Bool32
	subgroupBroadcastDynamicId                         Bool32
}

func (s *_vkPhysicalDeviceVulkan12Features) Goify() *PhysicalDeviceVulkan12Features {
	rval := &PhysicalDeviceVulkan12Features{
		PNext:                                              (unsafe.Pointer)(s.pNext),
		SamplerMirrorClampToEdge:                           translatePublic_Bool32(s.samplerMirrorClampToEdge),                           /*default*/
		DrawIndirectCount:                                  translatePublic_Bool32(s.drawIndirectCount),                                  /*default*/
		StorageBuffer8BitAccess:                            translatePublic_Bool32(s.storageBuffer8BitAccess),                            /*default*/
		UniformAndStorageBuffer8BitAccess:                  translatePublic_Bool32(s.uniformAndStorageBuffer8BitAccess),                  /*default*/
		StoragePushConstant8:                               translatePublic_Bool32(s.storagePushConstant8),                               /*default*/
		ShaderBufferInt64Atomics:                           translatePublic_Bool32(s.shaderBufferInt64Atomics),                           /*default*/
		ShaderSharedInt64Atomics:                           translatePublic_Bool32(s.shaderSharedInt64Atomics),                           /*default*/
		ShaderFloat16:                                      translatePublic_Bool32(s.shaderFloat16),                                      /*default*/
		ShaderInt8:                                         translatePublic_Bool32(s.shaderInt8),                                         /*default*/
		DescriptorIndexing:                                 translatePublic_Bool32(s.descriptorIndexing),                                 /*default*/
		ShaderInputAttachmentArrayDynamicIndexing:          translatePublic_Bool32(s.shaderInputAttachmentArrayDynamicIndexing),          /*default*/
		ShaderUniformTexelBufferArrayDynamicIndexing:       translatePublic_Bool32(s.shaderUniformTexelBufferArrayDynamicIndexing),       /*default*/
		ShaderStorageTexelBufferArrayDynamicIndexing:       translatePublic_Bool32(s.shaderStorageTexelBufferArrayDynamicIndexing),       /*default*/
		ShaderUniformBufferArrayNonUniformIndexing:         translatePublic_Bool32(s.shaderUniformBufferArrayNonUniformIndexing),         /*default*/
		ShaderSampledImageArrayNonUniformIndexing:          translatePublic_Bool32(s.shaderSampledImageArrayNonUniformIndexing),          /*default*/
		ShaderStorageBufferArrayNonUniformIndexing:         translatePublic_Bool32(s.shaderStorageBufferArrayNonUniformIndexing),         /*default*/
		ShaderStorageImageArrayNonUniformIndexing:          translatePublic_Bool32(s.shaderStorageImageArrayNonUniformIndexing),          /*default*/
		ShaderInputAttachmentArrayNonUniformIndexing:       translatePublic_Bool32(s.shaderInputAttachmentArrayNonUniformIndexing),       /*default*/
		ShaderUniformTexelBufferArrayNonUniformIndexing:    translatePublic_Bool32(s.shaderUniformTexelBufferArrayNonUniformIndexing),    /*default*/
		ShaderStorageTexelBufferArrayNonUniformIndexing:    translatePublic_Bool32(s.shaderStorageTexelBufferArrayNonUniformIndexing),    /*default*/
		DescriptorBindingUniformBufferUpdateAfterBind:      translatePublic_Bool32(s.descriptorBindingUniformBufferUpdateAfterBind),      /*default*/
		DescriptorBindingSampledImageUpdateAfterBind:       translatePublic_Bool32(s.descriptorBindingSampledImageUpdateAfterBind),       /*default*/
		DescriptorBindingStorageImageUpdateAfterBind:       translatePublic_Bool32(s.descriptorBindingStorageImageUpdateAfterBind),       /*default*/
		DescriptorBindingStorageBufferUpdateAfterBind:      translatePublic_Bool32(s.descriptorBindingStorageBufferUpdateAfterBind),      /*default*/
		DescriptorBindingUniformTexelBufferUpdateAfterBind: translatePublic_Bool32(s.descriptorBindingUniformTexelBufferUpdateAfterBind), /*default*/
		DescriptorBindingStorageTexelBufferUpdateAfterBind: translatePublic_Bool32(s.descriptorBindingStorageTexelBufferUpdateAfterBind), /*default*/
		DescriptorBindingUpdateUnusedWhilePending:          translatePublic_Bool32(s.descriptorBindingUpdateUnusedWhilePending),          /*default*/
		DescriptorBindingPartiallyBound:                    translatePublic_Bool32(s.descriptorBindingPartiallyBound),                    /*default*/
		DescriptorBindingVariableDescriptorCount:           translatePublic_Bool32(s.descriptorBindingVariableDescriptorCount),           /*default*/
		RuntimeDescriptorArray:                             translatePublic_Bool32(s.runtimeDescriptorArray),                             /*default*/
		SamplerFilterMinmax:                                translatePublic_Bool32(s.samplerFilterMinmax),                                /*default*/
		ScalarBlockLayout:                                  translatePublic_Bool32(s.scalarBlockLayout),                                  /*default*/
		ImagelessFramebuffer:                               translatePublic_Bool32(s.imagelessFramebuffer),                               /*default*/
		UniformBufferStandardLayout:                        translatePublic_Bool32(s.uniformBufferStandardLayout),                        /*default*/
		ShaderSubgroupExtendedTypes:                        translatePublic_Bool32(s.shaderSubgroupExtendedTypes),                        /*default*/
		SeparateDepthStencilLayouts:                        translatePublic_Bool32(s.separateDepthStencilLayouts),                        /*default*/
		HostQueryReset:                                     translatePublic_Bool32(s.hostQueryReset),                                     /*default*/
		TimelineSemaphore:                                  translatePublic_Bool32(s.timelineSemaphore),                                  /*default*/
		BufferDeviceAddress:                                translatePublic_Bool32(s.bufferDeviceAddress),                                /*default*/
		BufferDeviceAddressCaptureReplay:                   translatePublic_Bool32(s.bufferDeviceAddressCaptureReplay),                   /*default*/
		BufferDeviceAddressMultiDevice:                     translatePublic_Bool32(s.bufferDeviceAddressMultiDevice),                     /*default*/
		VulkanMemoryModel:                                  translatePublic_Bool32(s.vulkanMemoryModel),                                  /*default*/
		VulkanMemoryModelDeviceScope:                       translatePublic_Bool32(s.vulkanMemoryModelDeviceScope),                       /*default*/
		VulkanMemoryModelAvailabilityVisibilityChains:      translatePublic_Bool32(s.vulkanMemoryModelAvailabilityVisibilityChains),      /*default*/
		ShaderOutputViewportIndex:                          translatePublic_Bool32(s.shaderOutputViewportIndex),                          /*default*/
		ShaderOutputLayer:                                  translatePublic_Bool32(s.shaderOutputLayer),                                  /*default*/
		SubgroupBroadcastDynamicId:                         translatePublic_Bool32(s.subgroupBroadcastDynamicId),                         /*default*/
	}
	return rval
}
func (s *PhysicalDeviceVulkan12Features) Vulkanize() *_vkPhysicalDeviceVulkan12Features {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVulkan12Features{
		sType:                             STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,            /*c1*/
		pNext:                             (unsafe.Pointer)(s.PNext),                                     /*cb*/
		samplerMirrorClampToEdge:          translateInternal_Bool32(s.SamplerMirrorClampToEdge),          /*default*/
		drawIndirectCount:                 translateInternal_Bool32(s.DrawIndirectCount),                 /*default*/
		storageBuffer8BitAccess:           translateInternal_Bool32(s.StorageBuffer8BitAccess),           /*default*/
		uniformAndStorageBuffer8BitAccess: translateInternal_Bool32(s.UniformAndStorageBuffer8BitAccess), /*default*/
		storagePushConstant8:              translateInternal_Bool32(s.StoragePushConstant8),              /*default*/
		shaderBufferInt64Atomics:          translateInternal_Bool32(s.ShaderBufferInt64Atomics),          /*default*/
		shaderSharedInt64Atomics:          translateInternal_Bool32(s.ShaderSharedInt64Atomics),          /*default*/
		shaderFloat16:                     translateInternal_Bool32(s.ShaderFloat16),                     /*default*/
		shaderInt8:                        translateInternal_Bool32(s.ShaderInt8),                        /*default*/
		descriptorIndexing:                translateInternal_Bool32(s.DescriptorIndexing),                /*default*/
		shaderInputAttachmentArrayDynamicIndexing:          translateInternal_Bool32(s.ShaderInputAttachmentArrayDynamicIndexing),          /*default*/
		shaderUniformTexelBufferArrayDynamicIndexing:       translateInternal_Bool32(s.ShaderUniformTexelBufferArrayDynamicIndexing),       /*default*/
		shaderStorageTexelBufferArrayDynamicIndexing:       translateInternal_Bool32(s.ShaderStorageTexelBufferArrayDynamicIndexing),       /*default*/
		shaderUniformBufferArrayNonUniformIndexing:         translateInternal_Bool32(s.ShaderUniformBufferArrayNonUniformIndexing),         /*default*/
		shaderSampledImageArrayNonUniformIndexing:          translateInternal_Bool32(s.ShaderSampledImageArrayNonUniformIndexing),          /*default*/
		shaderStorageBufferArrayNonUniformIndexing:         translateInternal_Bool32(s.ShaderStorageBufferArrayNonUniformIndexing),         /*default*/
		shaderStorageImageArrayNonUniformIndexing:          translateInternal_Bool32(s.ShaderStorageImageArrayNonUniformIndexing),          /*default*/
		shaderInputAttachmentArrayNonUniformIndexing:       translateInternal_Bool32(s.ShaderInputAttachmentArrayNonUniformIndexing),       /*default*/
		shaderUniformTexelBufferArrayNonUniformIndexing:    translateInternal_Bool32(s.ShaderUniformTexelBufferArrayNonUniformIndexing),    /*default*/
		shaderStorageTexelBufferArrayNonUniformIndexing:    translateInternal_Bool32(s.ShaderStorageTexelBufferArrayNonUniformIndexing),    /*default*/
		descriptorBindingUniformBufferUpdateAfterBind:      translateInternal_Bool32(s.DescriptorBindingUniformBufferUpdateAfterBind),      /*default*/
		descriptorBindingSampledImageUpdateAfterBind:       translateInternal_Bool32(s.DescriptorBindingSampledImageUpdateAfterBind),       /*default*/
		descriptorBindingStorageImageUpdateAfterBind:       translateInternal_Bool32(s.DescriptorBindingStorageImageUpdateAfterBind),       /*default*/
		descriptorBindingStorageBufferUpdateAfterBind:      translateInternal_Bool32(s.DescriptorBindingStorageBufferUpdateAfterBind),      /*default*/
		descriptorBindingUniformTexelBufferUpdateAfterBind: translateInternal_Bool32(s.DescriptorBindingUniformTexelBufferUpdateAfterBind), /*default*/
		descriptorBindingStorageTexelBufferUpdateAfterBind: translateInternal_Bool32(s.DescriptorBindingStorageTexelBufferUpdateAfterBind), /*default*/
		descriptorBindingUpdateUnusedWhilePending:          translateInternal_Bool32(s.DescriptorBindingUpdateUnusedWhilePending),          /*default*/
		descriptorBindingPartiallyBound:                    translateInternal_Bool32(s.DescriptorBindingPartiallyBound),                    /*default*/
		descriptorBindingVariableDescriptorCount:           translateInternal_Bool32(s.DescriptorBindingVariableDescriptorCount),           /*default*/
		runtimeDescriptorArray:                             translateInternal_Bool32(s.RuntimeDescriptorArray),                             /*default*/
		samplerFilterMinmax:                                translateInternal_Bool32(s.SamplerFilterMinmax),                                /*default*/
		scalarBlockLayout:                                  translateInternal_Bool32(s.ScalarBlockLayout),                                  /*default*/
		imagelessFramebuffer:                               translateInternal_Bool32(s.ImagelessFramebuffer),                               /*default*/
		uniformBufferStandardLayout:                        translateInternal_Bool32(s.UniformBufferStandardLayout),                        /*default*/
		shaderSubgroupExtendedTypes:                        translateInternal_Bool32(s.ShaderSubgroupExtendedTypes),                        /*default*/
		separateDepthStencilLayouts:                        translateInternal_Bool32(s.SeparateDepthStencilLayouts),                        /*default*/
		hostQueryReset:                                     translateInternal_Bool32(s.HostQueryReset),                                     /*default*/
		timelineSemaphore:                                  translateInternal_Bool32(s.TimelineSemaphore),                                  /*default*/
		bufferDeviceAddress:                                translateInternal_Bool32(s.BufferDeviceAddress),                                /*default*/
		bufferDeviceAddressCaptureReplay:                   translateInternal_Bool32(s.BufferDeviceAddressCaptureReplay),                   /*default*/
		bufferDeviceAddressMultiDevice:                     translateInternal_Bool32(s.BufferDeviceAddressMultiDevice),                     /*default*/
		vulkanMemoryModel:                                  translateInternal_Bool32(s.VulkanMemoryModel),                                  /*default*/
		vulkanMemoryModelDeviceScope:                       translateInternal_Bool32(s.VulkanMemoryModelDeviceScope),                       /*default*/
		vulkanMemoryModelAvailabilityVisibilityChains:      translateInternal_Bool32(s.VulkanMemoryModelAvailabilityVisibilityChains),      /*default*/
		shaderOutputViewportIndex:                          translateInternal_Bool32(s.ShaderOutputViewportIndex),                          /*default*/
		shaderOutputLayer:                                  translateInternal_Bool32(s.ShaderOutputLayer),                                  /*default*/
		subgroupBroadcastDynamicId:                         translateInternal_Bool32(s.SubgroupBroadcastDynamicId),                         /*default*/
	}
	return rval
}

// PhysicalDeviceVulkan12Properties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html
type PhysicalDeviceVulkan12Properties struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES
	PNext                      unsafe.Pointer
	DriverID                   DriverId
	DriverName                 string
	DriverInfo                 string
	ConformanceVersion         ConformanceVersion
	DenormBehaviorIndependence ShaderFloatControlsIndependence
	RoundingModeIndependence   ShaderFloatControlsIndependence
	//  An implementation can preserve signed zero, nan, inf;
	ShaderSignedZeroInfNanPreserveFloat16 bool
	//  An implementation can preserve signed zero, nan, inf;
	ShaderSignedZeroInfNanPreserveFloat32 bool
	//  An implementation can preserve signed zero, nan, inf;
	ShaderSignedZeroInfNanPreserveFloat64 bool
	//  An implementation can preserve  denormals;
	ShaderDenormPreserveFloat16 bool
	//  An implementation can preserve  denormals;
	ShaderDenormPreserveFloat32 bool
	//  An implementation can preserve  denormals;
	ShaderDenormPreserveFloat64 bool
	//  An implementation can flush to zero  denormals;
	ShaderDenormFlushToZeroFloat16 bool
	//  An implementation can flush to zero  denormals;
	ShaderDenormFlushToZeroFloat32 bool
	//  An implementation can flush to zero  denormals;
	ShaderDenormFlushToZeroFloat64 bool
	//  An implementation can support RTE;
	ShaderRoundingModeRTEFloat16 bool
	//  An implementation can support RTE;
	ShaderRoundingModeRTEFloat32 bool
	//  An implementation can support RTE;
	ShaderRoundingModeRTEFloat64 bool
	//  An implementation can support RTZ;
	ShaderRoundingModeRTZFloat16 bool
	//  An implementation can support RTZ;
	ShaderRoundingModeRTZFloat32 bool
	//  An implementation can support RTZ;
	ShaderRoundingModeRTZFloat64                         bool
	MaxUpdateAfterBindDescriptorsInAllPools              uint32
	ShaderUniformBufferArrayNonUniformIndexingNative     bool
	ShaderSampledImageArrayNonUniformIndexingNative      bool
	ShaderStorageBufferArrayNonUniformIndexingNative     bool
	ShaderStorageImageArrayNonUniformIndexingNative      bool
	ShaderInputAttachmentArrayNonUniformIndexingNative   bool
	RobustBufferAccessUpdateAfterBind                    bool
	QuadDivergentImplicitLod                             bool
	MaxPerStageDescriptorUpdateAfterBindSamplers         uint32
	MaxPerStageDescriptorUpdateAfterBindUniformBuffers   uint32
	MaxPerStageDescriptorUpdateAfterBindStorageBuffers   uint32
	MaxPerStageDescriptorUpdateAfterBindSampledImages    uint32
	MaxPerStageDescriptorUpdateAfterBindStorageImages    uint32
	MaxPerStageDescriptorUpdateAfterBindInputAttachments uint32
	MaxPerStageUpdateAfterBindResources                  uint32
	MaxDescriptorSetUpdateAfterBindSamplers              uint32
	MaxDescriptorSetUpdateAfterBindUniformBuffers        uint32
	MaxDescriptorSetUpdateAfterBindUniformBuffersDynamic uint32
	MaxDescriptorSetUpdateAfterBindStorageBuffers        uint32
	MaxDescriptorSetUpdateAfterBindStorageBuffersDynamic uint32
	MaxDescriptorSetUpdateAfterBindSampledImages         uint32
	MaxDescriptorSetUpdateAfterBindStorageImages         uint32
	MaxDescriptorSetUpdateAfterBindInputAttachments      uint32
	//  supported depth resolve modes;
	SupportedDepthResolveModes ResolveModeFlags
	//  supported stencil resolve modes;
	SupportedStencilResolveModes ResolveModeFlags
	//  depth and stencil resolve modes can be set independently if one of them is none;
	IndependentResolveNone bool
	//  depth and stencil resolve modes can be set independently;
	IndependentResolve                  bool
	FilterMinmaxSingleComponentFormats  bool
	FilterMinmaxImageComponentMapping   bool
	MaxTimelineSemaphoreValueDifference uint64
	FramebufferIntegerColorSampleCounts SampleCountFlags
}

// WARNING - struct PhysicalDeviceVulkan12Properties is returned only, which is not yet handled in the binding
type _vkPhysicalDeviceVulkan12Properties struct {
	sType                                                StructureType
	pNext                                                unsafe.Pointer
	driverID                                             DriverId
	driverName                                           [MAX_DRIVER_NAME_SIZE]byte
	driverInfo                                           [MAX_DRIVER_INFO_SIZE]byte
	conformanceVersion                                   _vkConformanceVersion
	denormBehaviorIndependence                           ShaderFloatControlsIndependence
	roundingModeIndependence                             ShaderFloatControlsIndependence
	shaderSignedZeroInfNanPreserveFloat16                Bool32
	shaderSignedZeroInfNanPreserveFloat32                Bool32
	shaderSignedZeroInfNanPreserveFloat64                Bool32
	shaderDenormPreserveFloat16                          Bool32
	shaderDenormPreserveFloat32                          Bool32
	shaderDenormPreserveFloat64                          Bool32
	shaderDenormFlushToZeroFloat16                       Bool32
	shaderDenormFlushToZeroFloat32                       Bool32
	shaderDenormFlushToZeroFloat64                       Bool32
	shaderRoundingModeRTEFloat16                         Bool32
	shaderRoundingModeRTEFloat32                         Bool32
	shaderRoundingModeRTEFloat64                         Bool32
	shaderRoundingModeRTZFloat16                         Bool32
	shaderRoundingModeRTZFloat32                         Bool32
	shaderRoundingModeRTZFloat64                         Bool32
	maxUpdateAfterBindDescriptorsInAllPools              uint32
	shaderUniformBufferArrayNonUniformIndexingNative     Bool32
	shaderSampledImageArrayNonUniformIndexingNative      Bool32
	shaderStorageBufferArrayNonUniformIndexingNative     Bool32
	shaderStorageImageArrayNonUniformIndexingNative      Bool32
	shaderInputAttachmentArrayNonUniformIndexingNative   Bool32
	robustBufferAccessUpdateAfterBind                    Bool32
	quadDivergentImplicitLod                             Bool32
	maxPerStageDescriptorUpdateAfterBindSamplers         uint32
	maxPerStageDescriptorUpdateAfterBindUniformBuffers   uint32
	maxPerStageDescriptorUpdateAfterBindStorageBuffers   uint32
	maxPerStageDescriptorUpdateAfterBindSampledImages    uint32
	maxPerStageDescriptorUpdateAfterBindStorageImages    uint32
	maxPerStageDescriptorUpdateAfterBindInputAttachments uint32
	maxPerStageUpdateAfterBindResources                  uint32
	maxDescriptorSetUpdateAfterBindSamplers              uint32
	maxDescriptorSetUpdateAfterBindUniformBuffers        uint32
	maxDescriptorSetUpdateAfterBindUniformBuffersDynamic uint32
	maxDescriptorSetUpdateAfterBindStorageBuffers        uint32
	maxDescriptorSetUpdateAfterBindStorageBuffersDynamic uint32
	maxDescriptorSetUpdateAfterBindSampledImages         uint32
	maxDescriptorSetUpdateAfterBindStorageImages         uint32
	maxDescriptorSetUpdateAfterBindInputAttachments      uint32
	supportedDepthResolveModes                           ResolveModeFlags
	supportedStencilResolveModes                         ResolveModeFlags
	independentResolveNone                               Bool32
	independentResolve                                   Bool32
	filterMinmaxSingleComponentFormats                   Bool32
	filterMinmaxImageComponentMapping                    Bool32
	maxTimelineSemaphoreValueDifference                  uint64
	framebufferIntegerColorSampleCounts                  SampleCountFlags
}

func (s *_vkPhysicalDeviceVulkan12Properties) Goify() *PhysicalDeviceVulkan12Properties {
	rval := &PhysicalDeviceVulkan12Properties{
		PNext:                                                (unsafe.Pointer)(s.pNext),
		DriverID:                                             (DriverId)(s.driverID),
		DriverName:                                           nullTermBytesToString(s.driverName[:]), /*c arr*/
		DriverInfo:                                           nullTermBytesToString(s.driverInfo[:]), /*c arr*/
		ConformanceVersion:                                   (ConformanceVersion)(s.conformanceVersion),
		DenormBehaviorIndependence:                           (ShaderFloatControlsIndependence)(s.denormBehaviorIndependence),
		RoundingModeIndependence:                             (ShaderFloatControlsIndependence)(s.roundingModeIndependence),
		ShaderSignedZeroInfNanPreserveFloat16:                translatePublic_Bool32(s.shaderSignedZeroInfNanPreserveFloat16), /*default*/
		ShaderSignedZeroInfNanPreserveFloat32:                translatePublic_Bool32(s.shaderSignedZeroInfNanPreserveFloat32), /*default*/
		ShaderSignedZeroInfNanPreserveFloat64:                translatePublic_Bool32(s.shaderSignedZeroInfNanPreserveFloat64), /*default*/
		ShaderDenormPreserveFloat16:                          translatePublic_Bool32(s.shaderDenormPreserveFloat16),           /*default*/
		ShaderDenormPreserveFloat32:                          translatePublic_Bool32(s.shaderDenormPreserveFloat32),           /*default*/
		ShaderDenormPreserveFloat64:                          translatePublic_Bool32(s.shaderDenormPreserveFloat64),           /*default*/
		ShaderDenormFlushToZeroFloat16:                       translatePublic_Bool32(s.shaderDenormFlushToZeroFloat16),        /*default*/
		ShaderDenormFlushToZeroFloat32:                       translatePublic_Bool32(s.shaderDenormFlushToZeroFloat32),        /*default*/
		ShaderDenormFlushToZeroFloat64:                       translatePublic_Bool32(s.shaderDenormFlushToZeroFloat64),        /*default*/
		ShaderRoundingModeRTEFloat16:                         translatePublic_Bool32(s.shaderRoundingModeRTEFloat16),          /*default*/
		ShaderRoundingModeRTEFloat32:                         translatePublic_Bool32(s.shaderRoundingModeRTEFloat32),          /*default*/
		ShaderRoundingModeRTEFloat64:                         translatePublic_Bool32(s.shaderRoundingModeRTEFloat64),          /*default*/
		ShaderRoundingModeRTZFloat16:                         translatePublic_Bool32(s.shaderRoundingModeRTZFloat16),          /*default*/
		ShaderRoundingModeRTZFloat32:                         translatePublic_Bool32(s.shaderRoundingModeRTZFloat32),          /*default*/
		ShaderRoundingModeRTZFloat64:                         translatePublic_Bool32(s.shaderRoundingModeRTZFloat64),          /*default*/
		MaxUpdateAfterBindDescriptorsInAllPools:              (uint32)(s.maxUpdateAfterBindDescriptorsInAllPools),
		ShaderUniformBufferArrayNonUniformIndexingNative:     translatePublic_Bool32(s.shaderUniformBufferArrayNonUniformIndexingNative),   /*default*/
		ShaderSampledImageArrayNonUniformIndexingNative:      translatePublic_Bool32(s.shaderSampledImageArrayNonUniformIndexingNative),    /*default*/
		ShaderStorageBufferArrayNonUniformIndexingNative:     translatePublic_Bool32(s.shaderStorageBufferArrayNonUniformIndexingNative),   /*default*/
		ShaderStorageImageArrayNonUniformIndexingNative:      translatePublic_Bool32(s.shaderStorageImageArrayNonUniformIndexingNative),    /*default*/
		ShaderInputAttachmentArrayNonUniformIndexingNative:   translatePublic_Bool32(s.shaderInputAttachmentArrayNonUniformIndexingNative), /*default*/
		RobustBufferAccessUpdateAfterBind:                    translatePublic_Bool32(s.robustBufferAccessUpdateAfterBind),                  /*default*/
		QuadDivergentImplicitLod:                             translatePublic_Bool32(s.quadDivergentImplicitLod),                           /*default*/
		MaxPerStageDescriptorUpdateAfterBindSamplers:         (uint32)(s.maxPerStageDescriptorUpdateAfterBindSamplers),
		MaxPerStageDescriptorUpdateAfterBindUniformBuffers:   (uint32)(s.maxPerStageDescriptorUpdateAfterBindUniformBuffers),
		MaxPerStageDescriptorUpdateAfterBindStorageBuffers:   (uint32)(s.maxPerStageDescriptorUpdateAfterBindStorageBuffers),
		MaxPerStageDescriptorUpdateAfterBindSampledImages:    (uint32)(s.maxPerStageDescriptorUpdateAfterBindSampledImages),
		MaxPerStageDescriptorUpdateAfterBindStorageImages:    (uint32)(s.maxPerStageDescriptorUpdateAfterBindStorageImages),
		MaxPerStageDescriptorUpdateAfterBindInputAttachments: (uint32)(s.maxPerStageDescriptorUpdateAfterBindInputAttachments),
		MaxPerStageUpdateAfterBindResources:                  (uint32)(s.maxPerStageUpdateAfterBindResources),
		MaxDescriptorSetUpdateAfterBindSamplers:              (uint32)(s.maxDescriptorSetUpdateAfterBindSamplers),
		MaxDescriptorSetUpdateAfterBindUniformBuffers:        (uint32)(s.maxDescriptorSetUpdateAfterBindUniformBuffers),
		MaxDescriptorSetUpdateAfterBindUniformBuffersDynamic: (uint32)(s.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),
		MaxDescriptorSetUpdateAfterBindStorageBuffers:        (uint32)(s.maxDescriptorSetUpdateAfterBindStorageBuffers),
		MaxDescriptorSetUpdateAfterBindStorageBuffersDynamic: (uint32)(s.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),
		MaxDescriptorSetUpdateAfterBindSampledImages:         (uint32)(s.maxDescriptorSetUpdateAfterBindSampledImages),
		MaxDescriptorSetUpdateAfterBindStorageImages:         (uint32)(s.maxDescriptorSetUpdateAfterBindStorageImages),
		MaxDescriptorSetUpdateAfterBindInputAttachments:      (uint32)(s.maxDescriptorSetUpdateAfterBindInputAttachments),
		SupportedDepthResolveModes:                           (ResolveModeFlags)(s.supportedDepthResolveModes),
		SupportedStencilResolveModes:                         (ResolveModeFlags)(s.supportedStencilResolveModes),
		IndependentResolveNone:                               translatePublic_Bool32(s.independentResolveNone),             /*default*/
		IndependentResolve:                                   translatePublic_Bool32(s.independentResolve),                 /*default*/
		FilterMinmaxSingleComponentFormats:                   translatePublic_Bool32(s.filterMinmaxSingleComponentFormats), /*default*/
		FilterMinmaxImageComponentMapping:                    translatePublic_Bool32(s.filterMinmaxImageComponentMapping),  /*default*/
		MaxTimelineSemaphoreValueDifference:                  (uint64)(s.maxTimelineSemaphoreValueDifference),
		FramebufferIntegerColorSampleCounts:                  (SampleCountFlags)(s.framebufferIntegerColorSampleCounts),
	}
	return rval
}
func (s *PhysicalDeviceVulkan12Properties) Vulkanize() *_vkPhysicalDeviceVulkan12Properties {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVulkan12Properties{
		sType:    STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                            /*cb*/
		driverID: (DriverId)(s.DriverID),                               /*cb*/
		// driverName : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		// driverInfo : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		conformanceVersion:                                   (_vkConformanceVersion)(s.ConformanceVersion),                                  /*cb*/
		denormBehaviorIndependence:                           (ShaderFloatControlsIndependence)(s.DenormBehaviorIndependence),                /*cb*/
		roundingModeIndependence:                             (ShaderFloatControlsIndependence)(s.RoundingModeIndependence),                  /*cb*/
		shaderSignedZeroInfNanPreserveFloat16:                translateInternal_Bool32(s.ShaderSignedZeroInfNanPreserveFloat16),              /*default*/
		shaderSignedZeroInfNanPreserveFloat32:                translateInternal_Bool32(s.ShaderSignedZeroInfNanPreserveFloat32),              /*default*/
		shaderSignedZeroInfNanPreserveFloat64:                translateInternal_Bool32(s.ShaderSignedZeroInfNanPreserveFloat64),              /*default*/
		shaderDenormPreserveFloat16:                          translateInternal_Bool32(s.ShaderDenormPreserveFloat16),                        /*default*/
		shaderDenormPreserveFloat32:                          translateInternal_Bool32(s.ShaderDenormPreserveFloat32),                        /*default*/
		shaderDenormPreserveFloat64:                          translateInternal_Bool32(s.ShaderDenormPreserveFloat64),                        /*default*/
		shaderDenormFlushToZeroFloat16:                       translateInternal_Bool32(s.ShaderDenormFlushToZeroFloat16),                     /*default*/
		shaderDenormFlushToZeroFloat32:                       translateInternal_Bool32(s.ShaderDenormFlushToZeroFloat32),                     /*default*/
		shaderDenormFlushToZeroFloat64:                       translateInternal_Bool32(s.ShaderDenormFlushToZeroFloat64),                     /*default*/
		shaderRoundingModeRTEFloat16:                         translateInternal_Bool32(s.ShaderRoundingModeRTEFloat16),                       /*default*/
		shaderRoundingModeRTEFloat32:                         translateInternal_Bool32(s.ShaderRoundingModeRTEFloat32),                       /*default*/
		shaderRoundingModeRTEFloat64:                         translateInternal_Bool32(s.ShaderRoundingModeRTEFloat64),                       /*default*/
		shaderRoundingModeRTZFloat16:                         translateInternal_Bool32(s.ShaderRoundingModeRTZFloat16),                       /*default*/
		shaderRoundingModeRTZFloat32:                         translateInternal_Bool32(s.ShaderRoundingModeRTZFloat32),                       /*default*/
		shaderRoundingModeRTZFloat64:                         translateInternal_Bool32(s.ShaderRoundingModeRTZFloat64),                       /*default*/
		maxUpdateAfterBindDescriptorsInAllPools:              (uint32)(s.MaxUpdateAfterBindDescriptorsInAllPools),                            /*cb*/
		shaderUniformBufferArrayNonUniformIndexingNative:     translateInternal_Bool32(s.ShaderUniformBufferArrayNonUniformIndexingNative),   /*default*/
		shaderSampledImageArrayNonUniformIndexingNative:      translateInternal_Bool32(s.ShaderSampledImageArrayNonUniformIndexingNative),    /*default*/
		shaderStorageBufferArrayNonUniformIndexingNative:     translateInternal_Bool32(s.ShaderStorageBufferArrayNonUniformIndexingNative),   /*default*/
		shaderStorageImageArrayNonUniformIndexingNative:      translateInternal_Bool32(s.ShaderStorageImageArrayNonUniformIndexingNative),    /*default*/
		shaderInputAttachmentArrayNonUniformIndexingNative:   translateInternal_Bool32(s.ShaderInputAttachmentArrayNonUniformIndexingNative), /*default*/
		robustBufferAccessUpdateAfterBind:                    translateInternal_Bool32(s.RobustBufferAccessUpdateAfterBind),                  /*default*/
		quadDivergentImplicitLod:                             translateInternal_Bool32(s.QuadDivergentImplicitLod),                           /*default*/
		maxPerStageDescriptorUpdateAfterBindSamplers:         (uint32)(s.MaxPerStageDescriptorUpdateAfterBindSamplers),                       /*cb*/
		maxPerStageDescriptorUpdateAfterBindUniformBuffers:   (uint32)(s.MaxPerStageDescriptorUpdateAfterBindUniformBuffers),                 /*cb*/
		maxPerStageDescriptorUpdateAfterBindStorageBuffers:   (uint32)(s.MaxPerStageDescriptorUpdateAfterBindStorageBuffers),                 /*cb*/
		maxPerStageDescriptorUpdateAfterBindSampledImages:    (uint32)(s.MaxPerStageDescriptorUpdateAfterBindSampledImages),                  /*cb*/
		maxPerStageDescriptorUpdateAfterBindStorageImages:    (uint32)(s.MaxPerStageDescriptorUpdateAfterBindStorageImages),                  /*cb*/
		maxPerStageDescriptorUpdateAfterBindInputAttachments: (uint32)(s.MaxPerStageDescriptorUpdateAfterBindInputAttachments),               /*cb*/
		maxPerStageUpdateAfterBindResources:                  (uint32)(s.MaxPerStageUpdateAfterBindResources),                                /*cb*/
		maxDescriptorSetUpdateAfterBindSamplers:              (uint32)(s.MaxDescriptorSetUpdateAfterBindSamplers),                            /*cb*/
		maxDescriptorSetUpdateAfterBindUniformBuffers:        (uint32)(s.MaxDescriptorSetUpdateAfterBindUniformBuffers),                      /*cb*/
		maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: (uint32)(s.MaxDescriptorSetUpdateAfterBindUniformBuffersDynamic),               /*cb*/
		maxDescriptorSetUpdateAfterBindStorageBuffers:        (uint32)(s.MaxDescriptorSetUpdateAfterBindStorageBuffers),                      /*cb*/
		maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: (uint32)(s.MaxDescriptorSetUpdateAfterBindStorageBuffersDynamic),               /*cb*/
		maxDescriptorSetUpdateAfterBindSampledImages:         (uint32)(s.MaxDescriptorSetUpdateAfterBindSampledImages),                       /*cb*/
		maxDescriptorSetUpdateAfterBindStorageImages:         (uint32)(s.MaxDescriptorSetUpdateAfterBindStorageImages),                       /*cb*/
		maxDescriptorSetUpdateAfterBindInputAttachments:      (uint32)(s.MaxDescriptorSetUpdateAfterBindInputAttachments),                    /*cb*/
		supportedDepthResolveModes:                           (ResolveModeFlags)(s.SupportedDepthResolveModes),                               /*cb*/
		supportedStencilResolveModes:                         (ResolveModeFlags)(s.SupportedStencilResolveModes),                             /*cb*/
		independentResolveNone:                               translateInternal_Bool32(s.IndependentResolveNone),                             /*default*/
		independentResolve:                                   translateInternal_Bool32(s.IndependentResolve),                                 /*default*/
		filterMinmaxSingleComponentFormats:                   translateInternal_Bool32(s.FilterMinmaxSingleComponentFormats),                 /*default*/
		filterMinmaxImageComponentMapping:                    translateInternal_Bool32(s.FilterMinmaxImageComponentMapping),                  /*default*/
		maxTimelineSemaphoreValueDifference:                  (uint64)(s.MaxTimelineSemaphoreValueDifference),                                /*cb*/
		framebufferIntegerColorSampleCounts:                  (SampleCountFlags)(s.FramebufferIntegerColorSampleCounts),                      /*cb*/
	}
	return rval
}

// PhysicalDeviceVulkanMemoryModelFeatures: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html
type PhysicalDeviceVulkanMemoryModelFeatures struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES
	PNext                                         unsafe.Pointer
	VulkanMemoryModel                             bool
	VulkanMemoryModelDeviceScope                  bool
	VulkanMemoryModelAvailabilityVisibilityChains bool
}

type _vkPhysicalDeviceVulkanMemoryModelFeatures struct {
	sType                                         StructureType
	pNext                                         unsafe.Pointer
	vulkanMemoryModel                             Bool32
	vulkanMemoryModelDeviceScope                  Bool32
	vulkanMemoryModelAvailabilityVisibilityChains Bool32
}

func (s *_vkPhysicalDeviceVulkanMemoryModelFeatures) Goify() *PhysicalDeviceVulkanMemoryModelFeatures {
	rval := &PhysicalDeviceVulkanMemoryModelFeatures{
		PNext:                        (unsafe.Pointer)(s.pNext),
		VulkanMemoryModel:            translatePublic_Bool32(s.vulkanMemoryModel),            /*default*/
		VulkanMemoryModelDeviceScope: translatePublic_Bool32(s.vulkanMemoryModelDeviceScope), /*default*/
		VulkanMemoryModelAvailabilityVisibilityChains: translatePublic_Bool32(s.vulkanMemoryModelAvailabilityVisibilityChains), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceVulkanMemoryModelFeatures) Vulkanize() *_vkPhysicalDeviceVulkanMemoryModelFeatures {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceVulkanMemoryModelFeatures{
		sType:                        STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                   /*cb*/
		vulkanMemoryModel:            translateInternal_Bool32(s.VulkanMemoryModel),               /*default*/
		vulkanMemoryModelDeviceScope: translateInternal_Bool32(s.VulkanMemoryModelDeviceScope),    /*default*/
		vulkanMemoryModelAvailabilityVisibilityChains: translateInternal_Bool32(s.VulkanMemoryModelAvailabilityVisibilityChains), /*default*/
	}
	return rval
}

// PhysicalDeviceVulkanMemoryModelFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkanMemoryModelFeaturesKHR.html
type PhysicalDeviceVulkanMemoryModelFeaturesKHR struct {
}

type _vkPhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeaturesKHR

func (s *_vkPhysicalDeviceVulkanMemoryModelFeaturesKHR) Goify() *PhysicalDeviceVulkanMemoryModelFeaturesKHR {
	rval := (*PhysicalDeviceVulkanMemoryModelFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceVulkanMemoryModelFeaturesKHR) Vulkanize() *_vkPhysicalDeviceVulkanMemoryModelFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceVulkanMemoryModelFeaturesKHR)(s)
	return rval
}

// PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html
type PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR
	PNext                                          unsafe.Pointer
	WorkgroupMemoryExplicitLayout                  bool
	WorkgroupMemoryExplicitLayoutScalarBlockLayout bool
	WorkgroupMemoryExplicitLayout8BitAccess        bool
	WorkgroupMemoryExplicitLayout16BitAccess       bool
}

type _vkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR struct {
	sType                                          StructureType
	pNext                                          unsafe.Pointer
	workgroupMemoryExplicitLayout                  Bool32
	workgroupMemoryExplicitLayoutScalarBlockLayout Bool32
	workgroupMemoryExplicitLayout8BitAccess        Bool32
	workgroupMemoryExplicitLayout16BitAccess       Bool32
}

func (s *_vkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR) Goify() *PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
	rval := &PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR{
		PNext:                         (unsafe.Pointer)(s.pNext),
		WorkgroupMemoryExplicitLayout: translatePublic_Bool32(s.workgroupMemoryExplicitLayout), /*default*/
		WorkgroupMemoryExplicitLayoutScalarBlockLayout: translatePublic_Bool32(s.workgroupMemoryExplicitLayoutScalarBlockLayout), /*default*/
		WorkgroupMemoryExplicitLayout8BitAccess:        translatePublic_Bool32(s.workgroupMemoryExplicitLayout8BitAccess),        /*default*/
		WorkgroupMemoryExplicitLayout16BitAccess:       translatePublic_Bool32(s.workgroupMemoryExplicitLayout16BitAccess),       /*default*/
	}
	return rval
}
func (s *PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR) Vulkanize() *_vkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR{
		sType:                         STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                                    /*cb*/
		workgroupMemoryExplicitLayout: translateInternal_Bool32(s.WorkgroupMemoryExplicitLayout),                    /*default*/
		workgroupMemoryExplicitLayoutScalarBlockLayout: translateInternal_Bool32(s.WorkgroupMemoryExplicitLayoutScalarBlockLayout), /*default*/
		workgroupMemoryExplicitLayout8BitAccess:        translateInternal_Bool32(s.WorkgroupMemoryExplicitLayout8BitAccess),        /*default*/
		workgroupMemoryExplicitLayout16BitAccess:       translateInternal_Bool32(s.WorkgroupMemoryExplicitLayout16BitAccess),       /*default*/
	}
	return rval
}

// PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html
type PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT
	PNext                 unsafe.Pointer
	Ycbcr2plane444Formats bool
}

type _vkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	ycbcr2plane444Formats Bool32
}

func (s *_vkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT) Goify() *PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
	rval := &PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT{
		PNext:                 (unsafe.Pointer)(s.pNext),
		Ycbcr2plane444Formats: translatePublic_Bool32(s.ycbcr2plane444Formats), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT) Vulkanize() *_vkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT{
		sType:                 STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                             /*cb*/
		ycbcr2plane444Formats: translateInternal_Bool32(s.Ycbcr2plane444Formats),                     /*default*/
	}
	return rval
}

// PhysicalDeviceYcbcrDegammaFeaturesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.html
type PhysicalDeviceYcbcrDegammaFeaturesQCOM struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM
	PNext        unsafe.Pointer
	YcbcrDegamma bool
}

type _vkPhysicalDeviceYcbcrDegammaFeaturesQCOM struct {
	sType        StructureType
	pNext        unsafe.Pointer
	ycbcrDegamma Bool32
}

func (s *_vkPhysicalDeviceYcbcrDegammaFeaturesQCOM) Goify() *PhysicalDeviceYcbcrDegammaFeaturesQCOM {
	rval := &PhysicalDeviceYcbcrDegammaFeaturesQCOM{
		PNext:        (unsafe.Pointer)(s.pNext),
		YcbcrDegamma: translatePublic_Bool32(s.ycbcrDegamma), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceYcbcrDegammaFeaturesQCOM) Vulkanize() *_vkPhysicalDeviceYcbcrDegammaFeaturesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceYcbcrDegammaFeaturesQCOM{
		sType:        STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                                  /*cb*/
		ycbcrDegamma: translateInternal_Bool32(s.YcbcrDegamma),                   /*default*/
	}
	return rval
}

// PhysicalDeviceYcbcrImageArraysFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html
type PhysicalDeviceYcbcrImageArraysFeaturesEXT struct {
	// SType = STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT
	PNext            unsafe.Pointer
	YcbcrImageArrays bool
}

type _vkPhysicalDeviceYcbcrImageArraysFeaturesEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	ycbcrImageArrays Bool32
}

func (s *_vkPhysicalDeviceYcbcrImageArraysFeaturesEXT) Goify() *PhysicalDeviceYcbcrImageArraysFeaturesEXT {
	rval := &PhysicalDeviceYcbcrImageArraysFeaturesEXT{
		PNext:            (unsafe.Pointer)(s.pNext),
		YcbcrImageArrays: translatePublic_Bool32(s.ycbcrImageArrays), /*default*/
	}
	return rval
}
func (s *PhysicalDeviceYcbcrImageArraysFeaturesEXT) Vulkanize() *_vkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPhysicalDeviceYcbcrImageArraysFeaturesEXT{
		sType:            STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                      /*cb*/
		ycbcrImageArrays: translateInternal_Bool32(s.YcbcrImageArrays),                   /*default*/
	}
	return rval
}

// PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.html
type PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR struct {
}

type _vkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR

func (s *_vkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR) Goify() *PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
	rval := (*PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)(s)
	return rval
}
func (s *PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR) Vulkanize() *_vkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)(s)
	return rval
}

// PipelineCacheCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheCreateInfo.html
type PipelineCacheCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
	PNext unsafe.Pointer
	Flags PipelineCacheCreateFlags
	//  Size of initial data to populate cache, in bytes;
	InitialDataSize uintptr
	//  Initial data to populate cache;
	PInitialData unsafe.Pointer
}

type _vkPipelineCacheCreateInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           PipelineCacheCreateFlags
	initialDataSize uintptr
	pInitialData    unsafe.Pointer
}

func (s *_vkPipelineCacheCreateInfo) Goify() *PipelineCacheCreateInfo {
	rval := &PipelineCacheCreateInfo{
		PNext:           (unsafe.Pointer)(s.pNext),
		Flags:           (PipelineCacheCreateFlags)(s.flags),
		InitialDataSize: (uintptr)(s.initialDataSize),
		PInitialData:    (unsafe.Pointer)(s.pInitialData),
	}
	return rval
}
func (s *PipelineCacheCreateInfo) Vulkanize() *_vkPipelineCacheCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineCacheCreateInfo{
		sType:           STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                 /*cb*/
		flags:           (PipelineCacheCreateFlags)(s.Flags),       /*cb*/
		initialDataSize: (uintptr)(s.InitialDataSize),              /*cb*/
		pInitialData:    (unsafe.Pointer)(s.PInitialData),          /*cb*/
	}
	return rval
}

// PipelineCacheHeaderVersionOne: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheHeaderVersionOne.html
type PipelineCacheHeaderVersionOne struct {
	HeaderSize        uint32
	HeaderVersion     PipelineCacheHeaderVersion
	VendorID          uint32
	DeviceID          uint32
	PipelineCacheUUID [UUID_SIZE]uint8
}

type _vkPipelineCacheHeaderVersionOne = PipelineCacheHeaderVersionOne

func (s *_vkPipelineCacheHeaderVersionOne) Goify() *PipelineCacheHeaderVersionOne {
	rval := (*PipelineCacheHeaderVersionOne)(s)
	return rval
}
func (s *PipelineCacheHeaderVersionOne) Vulkanize() *_vkPipelineCacheHeaderVersionOne {
	if s == nil {
		return nil
	}
	rval := (*_vkPipelineCacheHeaderVersionOne)(s)
	return rval
}

// PipelineColorBlendAdvancedStateCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html
type PipelineColorBlendAdvancedStateCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT
	PNext            unsafe.Pointer
	SrcPremultiplied bool
	DstPremultiplied bool
	BlendOverlap     BlendOverlapEXT
}

type _vkPipelineColorBlendAdvancedStateCreateInfoEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	srcPremultiplied Bool32
	dstPremultiplied Bool32
	blendOverlap     BlendOverlapEXT
}

func (s *_vkPipelineColorBlendAdvancedStateCreateInfoEXT) Goify() *PipelineColorBlendAdvancedStateCreateInfoEXT {
	rval := &PipelineColorBlendAdvancedStateCreateInfoEXT{
		PNext:            (unsafe.Pointer)(s.pNext),
		SrcPremultiplied: translatePublic_Bool32(s.srcPremultiplied), /*default*/
		DstPremultiplied: translatePublic_Bool32(s.dstPremultiplied), /*default*/
		BlendOverlap:     (BlendOverlapEXT)(s.blendOverlap),
	}
	return rval
}
func (s *PipelineColorBlendAdvancedStateCreateInfoEXT) Vulkanize() *_vkPipelineColorBlendAdvancedStateCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineColorBlendAdvancedStateCreateInfoEXT{
		sType:            STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                          /*cb*/
		srcPremultiplied: translateInternal_Bool32(s.SrcPremultiplied),                       /*default*/
		dstPremultiplied: translateInternal_Bool32(s.DstPremultiplied),                       /*default*/
		blendOverlap:     (BlendOverlapEXT)(s.BlendOverlap),                                  /*cb*/
	}
	return rval
}

// PipelineColorBlendAttachmentState: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAttachmentState.html
type PipelineColorBlendAttachmentState struct {
	BlendEnable         bool
	SrcColorBlendFactor BlendFactor
	DstColorBlendFactor BlendFactor
	ColorBlendOp        BlendOp
	SrcAlphaBlendFactor BlendFactor
	DstAlphaBlendFactor BlendFactor
	AlphaBlendOp        BlendOp
	ColorWriteMask      ColorComponentFlags
}

type _vkPipelineColorBlendAttachmentState struct {
	blendEnable         Bool32
	srcColorBlendFactor BlendFactor
	dstColorBlendFactor BlendFactor
	colorBlendOp        BlendOp
	srcAlphaBlendFactor BlendFactor
	dstAlphaBlendFactor BlendFactor
	alphaBlendOp        BlendOp
	colorWriteMask      ColorComponentFlags
}

func (s *_vkPipelineColorBlendAttachmentState) Goify() *PipelineColorBlendAttachmentState {
	rval := &PipelineColorBlendAttachmentState{
		BlendEnable:         translatePublic_Bool32(s.blendEnable), /*default*/
		SrcColorBlendFactor: (BlendFactor)(s.srcColorBlendFactor),
		DstColorBlendFactor: (BlendFactor)(s.dstColorBlendFactor),
		ColorBlendOp:        (BlendOp)(s.colorBlendOp),
		SrcAlphaBlendFactor: (BlendFactor)(s.srcAlphaBlendFactor),
		DstAlphaBlendFactor: (BlendFactor)(s.dstAlphaBlendFactor),
		AlphaBlendOp:        (BlendOp)(s.alphaBlendOp),
		ColorWriteMask:      (ColorComponentFlags)(s.colorWriteMask),
	}
	return rval
}
func (s *PipelineColorBlendAttachmentState) Vulkanize() *_vkPipelineColorBlendAttachmentState {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineColorBlendAttachmentState{
		blendEnable:         translateInternal_Bool32(s.BlendEnable), /*default*/
		srcColorBlendFactor: (BlendFactor)(s.SrcColorBlendFactor),    /*cb*/
		dstColorBlendFactor: (BlendFactor)(s.DstColorBlendFactor),    /*cb*/
		colorBlendOp:        (BlendOp)(s.ColorBlendOp),               /*cb*/
		srcAlphaBlendFactor: (BlendFactor)(s.SrcAlphaBlendFactor),    /*cb*/
		dstAlphaBlendFactor: (BlendFactor)(s.DstAlphaBlendFactor),    /*cb*/
		alphaBlendOp:        (BlendOp)(s.AlphaBlendOp),               /*cb*/
		colorWriteMask:      (ColorComponentFlags)(s.ColorWriteMask), /*cb*/
	}
	return rval
}

// PipelineColorBlendStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendStateCreateInfo.html
type PipelineColorBlendStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
	PNext         unsafe.Pointer
	Flags         PipelineColorBlendStateCreateFlags
	LogicOpEnable bool
	LogicOp       LogicOp
	//  # of pAttachments;
	// attachmentCount
	PAttachments   []PipelineColorBlendAttachmentState
	BlendConstants [4]float32
}

type _vkPipelineColorBlendStateCreateInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           PipelineColorBlendStateCreateFlags
	logicOpEnable   Bool32
	logicOp         LogicOp
	attachmentCount uint32
	pAttachments    *_vkPipelineColorBlendAttachmentState
	blendConstants  [4]float32
}

func (s *_vkPipelineColorBlendStateCreateInfo) Goify() *PipelineColorBlendStateCreateInfo {
	rval := &PipelineColorBlendStateCreateInfo{
		PNext:         (unsafe.Pointer)(s.pNext),
		Flags:         (PipelineColorBlendStateCreateFlags)(s.flags),
		LogicOpEnable: translatePublic_Bool32(s.logicOpEnable), /*default*/
		LogicOp:       (LogicOp)(s.logicOp),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAttachments in returned struct
		BlendConstants: ([4]float32)(s.blendConstants),
	}
	return rval
}
func (s *PipelineColorBlendStateCreateInfo) Vulkanize() *_vkPipelineColorBlendStateCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pAttachments *_vkPipelineColorBlendAttachmentState
	if len(s.PAttachments) > 0 {
		sl_pAttachments := make([]_vkPipelineColorBlendAttachmentState, len(s.PAttachments))
		for i, v := range s.PAttachments {
			sl_pAttachments[i] = *(v.Vulkanize())
		}
		psl_pAttachments = &sl_pAttachments[0]
	}
	rval := &_vkPipelineColorBlendStateCreateInfo{
		sType:           STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                             /*cb*/
		flags:           (PipelineColorBlendStateCreateFlags)(s.Flags),         /*cb*/
		logicOpEnable:   translateInternal_Bool32(s.LogicOpEnable),             /*default*/
		logicOp:         (LogicOp)(s.LogicOp),                                  /*cb*/
		attachmentCount: uint32(len(s.PAttachments)),                           /*c6-a*/
		pAttachments:    psl_pAttachments,                                      /*c rem*/
		blendConstants:  ([4]float32)(s.BlendConstants),                        /*cb*/
	}
	return rval
}

// PipelineColorWriteCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorWriteCreateInfoEXT.html
type PipelineColorWriteCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT
	PNext unsafe.Pointer
	//  # of pAttachments;
	// attachmentCount
	PColorWriteEnables []bool
}

type _vkPipelineColorWriteCreateInfoEXT struct {
	sType              StructureType
	pNext              unsafe.Pointer
	attachmentCount    uint32
	pColorWriteEnables *Bool32
}

func (s *_vkPipelineColorWriteCreateInfoEXT) Goify() *PipelineColorWriteCreateInfoEXT {
	rval := &PipelineColorWriteCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pColorWriteEnables in returned struct
	}
	return rval
}
func (s *PipelineColorWriteCreateInfoEXT) Vulkanize() *_vkPipelineColorWriteCreateInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pColorWriteEnables *Bool32
	if len(s.PColorWriteEnables) > 0 {
		sl_pColorWriteEnables := make([]Bool32, len(s.PColorWriteEnables))
		for i, v := range s.PColorWriteEnables {
			sl_pColorWriteEnables[i] = translateInternal_Bool32(v)
		}
		psl_pColorWriteEnables = &sl_pColorWriteEnables[0]
	}
	rval := &_vkPipelineColorWriteCreateInfoEXT{
		sType:              STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                           /*cb*/
		attachmentCount:    uint32(len(s.PColorWriteEnables)),                   /*c6-a*/
		pColorWriteEnables: psl_pColorWriteEnables,                              /*c rem*/
	}
	return rval
}

// PipelineCompilerControlCreateInfoAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCompilerControlCreateInfoAMD.html
type PipelineCompilerControlCreateInfoAMD struct {
	// SType = STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD
	PNext                unsafe.Pointer
	CompilerControlFlags PipelineCompilerControlFlagsAMD
}

type _vkPipelineCompilerControlCreateInfoAMD struct {
	sType                StructureType
	pNext                unsafe.Pointer
	compilerControlFlags PipelineCompilerControlFlagsAMD
}

func (s *_vkPipelineCompilerControlCreateInfoAMD) Goify() *PipelineCompilerControlCreateInfoAMD {
	rval := &PipelineCompilerControlCreateInfoAMD{
		PNext:                (unsafe.Pointer)(s.pNext),
		CompilerControlFlags: (PipelineCompilerControlFlagsAMD)(s.compilerControlFlags),
	}
	return rval
}
func (s *PipelineCompilerControlCreateInfoAMD) Vulkanize() *_vkPipelineCompilerControlCreateInfoAMD {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineCompilerControlCreateInfoAMD{
		sType:                STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,  /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                 /*cb*/
		compilerControlFlags: (PipelineCompilerControlFlagsAMD)(s.CompilerControlFlags), /*cb*/
	}
	return rval
}

// PipelineCoverageModulationStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html
type PipelineCoverageModulationStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV
	PNext                         unsafe.Pointer
	Flags                         PipelineCoverageModulationStateCreateFlagsNV
	CoverageModulationMode        CoverageModulationModeNV
	CoverageModulationTableEnable bool
	// coverageModulationTableCount
	PCoverageModulationTable []float32
}

type _vkPipelineCoverageModulationStateCreateInfoNV struct {
	sType                         StructureType
	pNext                         unsafe.Pointer
	flags                         PipelineCoverageModulationStateCreateFlagsNV
	coverageModulationMode        CoverageModulationModeNV
	coverageModulationTableEnable Bool32
	coverageModulationTableCount  uint32
	pCoverageModulationTable      *float32
}

func (s *_vkPipelineCoverageModulationStateCreateInfoNV) Goify() *PipelineCoverageModulationStateCreateInfoNV {
	rval := &PipelineCoverageModulationStateCreateInfoNV{
		PNext:                         (unsafe.Pointer)(s.pNext),
		Flags:                         (PipelineCoverageModulationStateCreateFlagsNV)(s.flags),
		CoverageModulationMode:        (CoverageModulationModeNV)(s.coverageModulationMode),
		CoverageModulationTableEnable: translatePublic_Bool32(s.coverageModulationTableEnable), /*default*/
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCoverageModulationTable in returned struct
	}
	return rval
}
func (s *PipelineCoverageModulationStateCreateInfoNV) Vulkanize() *_vkPipelineCoverageModulationStateCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pCoverageModulationTable *float32
	if len(s.PCoverageModulationTable) > 0 {
		psl_pCoverageModulationTable = &s.PCoverageModulationTable[0]
	}
	rval := &_vkPipelineCoverageModulationStateCreateInfoNV{
		sType:                         STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, /*c1*/
		pNext:                         (unsafe.Pointer)(s.PNext),                                        /*cb*/
		flags:                         (PipelineCoverageModulationStateCreateFlagsNV)(s.Flags),          /*cb*/
		coverageModulationMode:        (CoverageModulationModeNV)(s.CoverageModulationMode),             /*cb*/
		coverageModulationTableEnable: translateInternal_Bool32(s.CoverageModulationTableEnable),        /*default*/
		coverageModulationTableCount:  uint32(len(s.PCoverageModulationTable)),                          /*c6-a*/
		pCoverageModulationTable:      psl_pCoverageModulationTable,                                     /*c rem*/
	}
	return rval
}

// PipelineCoverageReductionStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html
type PipelineCoverageReductionStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV
	PNext                 unsafe.Pointer
	Flags                 PipelineCoverageReductionStateCreateFlagsNV
	CoverageReductionMode CoverageReductionModeNV
}

type _vkPipelineCoverageReductionStateCreateInfoNV struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	flags                 PipelineCoverageReductionStateCreateFlagsNV
	coverageReductionMode CoverageReductionModeNV
}

func (s *_vkPipelineCoverageReductionStateCreateInfoNV) Goify() *PipelineCoverageReductionStateCreateInfoNV {
	rval := &PipelineCoverageReductionStateCreateInfoNV{
		PNext:                 (unsafe.Pointer)(s.pNext),
		Flags:                 (PipelineCoverageReductionStateCreateFlagsNV)(s.flags),
		CoverageReductionMode: (CoverageReductionModeNV)(s.coverageReductionMode),
	}
	return rval
}
func (s *PipelineCoverageReductionStateCreateInfoNV) Vulkanize() *_vkPipelineCoverageReductionStateCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineCoverageReductionStateCreateInfoNV{
		sType:                 STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                       /*cb*/
		flags:                 (PipelineCoverageReductionStateCreateFlagsNV)(s.Flags),          /*cb*/
		coverageReductionMode: (CoverageReductionModeNV)(s.CoverageReductionMode),              /*cb*/
	}
	return rval
}

// PipelineCoverageToColorStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html
type PipelineCoverageToColorStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV
	PNext                   unsafe.Pointer
	Flags                   PipelineCoverageToColorStateCreateFlagsNV
	CoverageToColorEnable   bool
	CoverageToColorLocation uint32
}

type _vkPipelineCoverageToColorStateCreateInfoNV struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	flags                   PipelineCoverageToColorStateCreateFlagsNV
	coverageToColorEnable   Bool32
	coverageToColorLocation uint32
}

func (s *_vkPipelineCoverageToColorStateCreateInfoNV) Goify() *PipelineCoverageToColorStateCreateInfoNV {
	rval := &PipelineCoverageToColorStateCreateInfoNV{
		PNext:                   (unsafe.Pointer)(s.pNext),
		Flags:                   (PipelineCoverageToColorStateCreateFlagsNV)(s.flags),
		CoverageToColorEnable:   translatePublic_Bool32(s.coverageToColorEnable), /*default*/
		CoverageToColorLocation: (uint32)(s.coverageToColorLocation),
	}
	return rval
}
func (s *PipelineCoverageToColorStateCreateInfoNV) Vulkanize() *_vkPipelineCoverageToColorStateCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineCoverageToColorStateCreateInfoNV{
		sType:                   STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                                      /*cb*/
		flags:                   (PipelineCoverageToColorStateCreateFlagsNV)(s.Flags),           /*cb*/
		coverageToColorEnable:   translateInternal_Bool32(s.CoverageToColorEnable),              /*default*/
		coverageToColorLocation: (uint32)(s.CoverageToColorLocation),                            /*cb*/
	}
	return rval
}

// PipelineCreateFlags2CreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreateFlags2CreateInfoKHR.html
type PipelineCreateFlags2CreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR
	PNext unsafe.Pointer
	Flags PipelineCreateFlags2KHR
}

type _vkPipelineCreateFlags2CreateInfoKHR struct {
	sType StructureType
	pNext unsafe.Pointer
	flags PipelineCreateFlags2KHR
}

func (s *_vkPipelineCreateFlags2CreateInfoKHR) Goify() *PipelineCreateFlags2CreateInfoKHR {
	rval := &PipelineCreateFlags2CreateInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PipelineCreateFlags2KHR)(s.flags),
	}
	return rval
}
func (s *PipelineCreateFlags2CreateInfoKHR) Vulkanize() *_vkPipelineCreateFlags2CreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineCreateFlags2CreateInfoKHR{
		sType: STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                              /*cb*/
		flags: (PipelineCreateFlags2KHR)(s.Flags),                     /*cb*/
	}
	return rval
}

// PipelineCreationFeedbackCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackCreateInfoEXT.html
type PipelineCreationFeedbackCreateInfoEXT struct {
}

type _vkPipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfoEXT

func (s *_vkPipelineCreationFeedbackCreateInfoEXT) Goify() *PipelineCreationFeedbackCreateInfoEXT {
	rval := (*PipelineCreationFeedbackCreateInfoEXT)(s)
	return rval
}
func (s *PipelineCreationFeedbackCreateInfoEXT) Vulkanize() *_vkPipelineCreationFeedbackCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPipelineCreationFeedbackCreateInfoEXT)(s)
	return rval
}

// PipelineCreationFeedbackEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackEXT.html
type PipelineCreationFeedbackEXT struct {
}

type _vkPipelineCreationFeedbackEXT = PipelineCreationFeedbackEXT

func (s *_vkPipelineCreationFeedbackEXT) Goify() *PipelineCreationFeedbackEXT {
	rval := (*PipelineCreationFeedbackEXT)(s)
	return rval
}
func (s *PipelineCreationFeedbackEXT) Vulkanize() *_vkPipelineCreationFeedbackEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPipelineCreationFeedbackEXT)(s)
	return rval
}

// PipelineDepthStencilStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDepthStencilStateCreateInfo.html
type PipelineDepthStencilStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
	PNext            unsafe.Pointer
	Flags            PipelineDepthStencilStateCreateFlags
	DepthTestEnable  bool
	DepthWriteEnable bool
	DepthCompareOp   CompareOp
	//  optional (depth_bounds_test);
	DepthBoundsTestEnable bool
	StencilTestEnable     bool
	Front                 StencilOpState
	Back                  StencilOpState
	MinDepthBounds        float32
	MaxDepthBounds        float32
}

type _vkPipelineDepthStencilStateCreateInfo struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	flags                 PipelineDepthStencilStateCreateFlags
	depthTestEnable       Bool32
	depthWriteEnable      Bool32
	depthCompareOp        CompareOp
	depthBoundsTestEnable Bool32
	stencilTestEnable     Bool32
	front                 _vkStencilOpState
	back                  _vkStencilOpState
	minDepthBounds        float32
	maxDepthBounds        float32
}

func (s *_vkPipelineDepthStencilStateCreateInfo) Goify() *PipelineDepthStencilStateCreateInfo {
	rval := &PipelineDepthStencilStateCreateInfo{
		PNext:                 (unsafe.Pointer)(s.pNext),
		Flags:                 (PipelineDepthStencilStateCreateFlags)(s.flags),
		DepthTestEnable:       translatePublic_Bool32(s.depthTestEnable),  /*default*/
		DepthWriteEnable:      translatePublic_Bool32(s.depthWriteEnable), /*default*/
		DepthCompareOp:        (CompareOp)(s.depthCompareOp),
		DepthBoundsTestEnable: translatePublic_Bool32(s.depthBoundsTestEnable), /*default*/
		StencilTestEnable:     translatePublic_Bool32(s.stencilTestEnable),     /*default*/
		Front:                 (StencilOpState)(s.front),
		Back:                  (StencilOpState)(s.back),
		MinDepthBounds:        (float32)(s.minDepthBounds),
		MaxDepthBounds:        (float32)(s.maxDepthBounds),
	}
	return rval
}
func (s *PipelineDepthStencilStateCreateInfo) Vulkanize() *_vkPipelineDepthStencilStateCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineDepthStencilStateCreateInfo{
		sType:                 STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                               /*cb*/
		flags:                 (PipelineDepthStencilStateCreateFlags)(s.Flags),         /*cb*/
		depthTestEnable:       translateInternal_Bool32(s.DepthTestEnable),             /*default*/
		depthWriteEnable:      translateInternal_Bool32(s.DepthWriteEnable),            /*default*/
		depthCompareOp:        (CompareOp)(s.DepthCompareOp),                           /*cb*/
		depthBoundsTestEnable: translateInternal_Bool32(s.DepthBoundsTestEnable),       /*default*/
		stencilTestEnable:     translateInternal_Bool32(s.StencilTestEnable),           /*default*/
		front:                 (_vkStencilOpState)(s.Front),                            /*cb*/
		back:                  (_vkStencilOpState)(s.Back),                             /*cb*/
		minDepthBounds:        (float32)(s.MinDepthBounds),                             /*cb*/
		maxDepthBounds:        (float32)(s.MaxDepthBounds),                             /*cb*/
	}
	return rval
}

// PipelineDiscardRectangleStateCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html
type PipelineDiscardRectangleStateCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT
	PNext                unsafe.Pointer
	Flags                PipelineDiscardRectangleStateCreateFlagsEXT
	DiscardRectangleMode DiscardRectangleModeEXT
	// discardRectangleCount
	PDiscardRectangles []Rect2D
}

type _vkPipelineDiscardRectangleStateCreateInfoEXT struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	flags                 PipelineDiscardRectangleStateCreateFlagsEXT
	discardRectangleMode  DiscardRectangleModeEXT
	discardRectangleCount uint32
	pDiscardRectangles    *_vkRect2D
}

func (s *_vkPipelineDiscardRectangleStateCreateInfoEXT) Goify() *PipelineDiscardRectangleStateCreateInfoEXT {
	rval := &PipelineDiscardRectangleStateCreateInfoEXT{
		PNext:                (unsafe.Pointer)(s.pNext),
		Flags:                (PipelineDiscardRectangleStateCreateFlagsEXT)(s.flags),
		DiscardRectangleMode: (DiscardRectangleModeEXT)(s.discardRectangleMode),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDiscardRectangles in returned struct
	}
	return rval
}
func (s *PipelineDiscardRectangleStateCreateInfoEXT) Vulkanize() *_vkPipelineDiscardRectangleStateCreateInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pDiscardRectangles *_vkRect2D
	if len(s.PDiscardRectangles) > 0 {
		sl_pDiscardRectangles := make([]_vkRect2D, len(s.PDiscardRectangles))
		for i, v := range s.PDiscardRectangles {
			sl_pDiscardRectangles[i] = *(v.Vulkanize())
		}
		psl_pDiscardRectangles = &sl_pDiscardRectangles[0]
	}
	rval := &_vkPipelineDiscardRectangleStateCreateInfoEXT{
		sType:                 STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                       /*cb*/
		flags:                 (PipelineDiscardRectangleStateCreateFlagsEXT)(s.Flags),          /*cb*/
		discardRectangleMode:  (DiscardRectangleModeEXT)(s.DiscardRectangleMode),               /*cb*/
		discardRectangleCount: uint32(len(s.PDiscardRectangles)),                               /*c6-a*/
		pDiscardRectangles:    psl_pDiscardRectangles,                                          /*c rem*/
	}
	return rval
}

// PipelineDynamicStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateInfo.html
type PipelineDynamicStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
	PNext unsafe.Pointer
	Flags PipelineDynamicStateCreateFlags
	// dynamicStateCount
	PDynamicStates []DynamicState
}

type _vkPipelineDynamicStateCreateInfo struct {
	sType             StructureType
	pNext             unsafe.Pointer
	flags             PipelineDynamicStateCreateFlags
	dynamicStateCount uint32
	pDynamicStates    *DynamicState
}

func (s *_vkPipelineDynamicStateCreateInfo) Goify() *PipelineDynamicStateCreateInfo {
	rval := &PipelineDynamicStateCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PipelineDynamicStateCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDynamicStates in returned struct
	}
	return rval
}
func (s *PipelineDynamicStateCreateInfo) Vulkanize() *_vkPipelineDynamicStateCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pDynamicStates *DynamicState
	if len(s.PDynamicStates) > 0 {
		psl_pDynamicStates = &s.PDynamicStates[0]
	}
	rval := &_vkPipelineDynamicStateCreateInfo{
		sType:             STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                         /*cb*/
		flags:             (PipelineDynamicStateCreateFlags)(s.Flags),        /*cb*/
		dynamicStateCount: uint32(len(s.PDynamicStates)),                     /*c6-a*/
		pDynamicStates:    psl_pDynamicStates,                                /*c rem*/
	}
	return rval
}

// PipelineExecutableInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInfoKHR.html
type PipelineExecutableInfoKHR struct {
	// SType = STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR
	PNext           unsafe.Pointer
	Pipeline        Pipeline
	ExecutableIndex uint32
}

type _vkPipelineExecutableInfoKHR struct {
	sType           StructureType
	pNext           unsafe.Pointer
	pipeline        Pipeline
	executableIndex uint32
}

func (s *_vkPipelineExecutableInfoKHR) Goify() *PipelineExecutableInfoKHR {
	rval := &PipelineExecutableInfoKHR{
		PNext:           (unsafe.Pointer)(s.pNext),
		Pipeline:        (Pipeline)(s.pipeline),
		ExecutableIndex: (uint32)(s.executableIndex),
	}
	return rval
}
func (s *PipelineExecutableInfoKHR) Vulkanize() *_vkPipelineExecutableInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineExecutableInfoKHR{
		sType:           STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                   /*cb*/
		pipeline:        (Pipeline)(s.Pipeline),                      /*cb*/
		executableIndex: (uint32)(s.ExecutableIndex),                 /*cb*/
	}
	return rval
}

// PipelineExecutableInternalRepresentationKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInternalRepresentationKHR.html
type PipelineExecutableInternalRepresentationKHR struct {
	// SType = STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR
	PNext       unsafe.Pointer
	Name        string
	Description string
	IsText      bool
	DataSize    uintptr
	PData       unsafe.Pointer
}

// WARNING - struct PipelineExecutableInternalRepresentationKHR is returned only, which is not yet handled in the binding
type _vkPipelineExecutableInternalRepresentationKHR struct {
	sType       StructureType
	pNext       unsafe.Pointer
	name        [MAX_DESCRIPTION_SIZE]byte
	description [MAX_DESCRIPTION_SIZE]byte
	isText      Bool32
	dataSize    uintptr
	pData       unsafe.Pointer
}

func (s *_vkPipelineExecutableInternalRepresentationKHR) Goify() *PipelineExecutableInternalRepresentationKHR {
	rval := &PipelineExecutableInternalRepresentationKHR{
		PNext:       (unsafe.Pointer)(s.pNext),
		Name:        nullTermBytesToString(s.name[:]),        /*c arr*/
		Description: nullTermBytesToString(s.description[:]), /*c arr*/
		IsText:      translatePublic_Bool32(s.isText),        /*default*/
		DataSize:    (uintptr)(s.dataSize),
		PData:       (unsafe.Pointer)(s.pData),
	}
	return rval
}
func (s *PipelineExecutableInternalRepresentationKHR) Vulkanize() *_vkPipelineExecutableInternalRepresentationKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineExecutableInternalRepresentationKHR{
		sType: STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                                      /*cb*/
		// name : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		// description : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		isText:   translateInternal_Bool32(s.IsText), /*default*/
		dataSize: (uintptr)(s.DataSize),              /*cb*/
		pData:    (unsafe.Pointer)(s.PData),          /*cb*/
	}
	return rval
}

// PipelineExecutablePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutablePropertiesKHR.html
type PipelineExecutablePropertiesKHR struct {
	// SType = STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR
	PNext        unsafe.Pointer
	Stages       ShaderStageFlags
	Name         string
	Description  string
	SubgroupSize uint32
}

// WARNING - struct PipelineExecutablePropertiesKHR is returned only, which is not yet handled in the binding
type _vkPipelineExecutablePropertiesKHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	stages       ShaderStageFlags
	name         [MAX_DESCRIPTION_SIZE]byte
	description  [MAX_DESCRIPTION_SIZE]byte
	subgroupSize uint32
}

func (s *_vkPipelineExecutablePropertiesKHR) Goify() *PipelineExecutablePropertiesKHR {
	rval := &PipelineExecutablePropertiesKHR{
		PNext:        (unsafe.Pointer)(s.pNext),
		Stages:       (ShaderStageFlags)(s.stages),
		Name:         nullTermBytesToString(s.name[:]),        /*c arr*/
		Description:  nullTermBytesToString(s.description[:]), /*c arr*/
		SubgroupSize: (uint32)(s.subgroupSize),
	}
	return rval
}
func (s *PipelineExecutablePropertiesKHR) Vulkanize() *_vkPipelineExecutablePropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineExecutablePropertiesKHR{
		sType:  STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR, /*c1*/
		pNext:  (unsafe.Pointer)(s.PNext),                         /*cb*/
		stages: (ShaderStageFlags)(s.Stages),                      /*cb*/
		// name : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		// description : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		subgroupSize: (uint32)(s.SubgroupSize), /*cb*/
	}
	return rval
}

// PipelineExecutableStatisticKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticKHR.html
type PipelineExecutableStatisticKHR struct {
	// SType = STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR
	PNext       unsafe.Pointer
	Name        string
	Description string
	Format      PipelineExecutableStatisticFormatKHR
	Value       PipelineExecutableStatisticValueKHR
}

// WARNING - struct PipelineExecutableStatisticKHR is returned only, which is not yet handled in the binding
type _vkPipelineExecutableStatisticKHR struct {
	sType       StructureType
	pNext       unsafe.Pointer
	name        [MAX_DESCRIPTION_SIZE]byte
	description [MAX_DESCRIPTION_SIZE]byte
	format      PipelineExecutableStatisticFormatKHR
	value       _vkPipelineExecutableStatisticValueKHR
}

func (s *_vkPipelineExecutableStatisticKHR) Goify() *PipelineExecutableStatisticKHR {
	rval := &PipelineExecutableStatisticKHR{
		PNext:       (unsafe.Pointer)(s.pNext),
		Name:        nullTermBytesToString(s.name[:]),        /*c arr*/
		Description: nullTermBytesToString(s.description[:]), /*c arr*/
		Format:      (PipelineExecutableStatisticFormatKHR)(s.format),
		// Can't Goify union member value
	}
	return rval
}
func (s *PipelineExecutableStatisticKHR) Vulkanize() *_vkPipelineExecutableStatisticKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineExecutableStatisticKHR{
		sType: STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                        /*cb*/
		// name : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		// description : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		format: (PipelineExecutableStatisticFormatKHR)(s.Format), /*cb*/
		value:  *s.Value.Vulkanize(),                             /*c union*/
	}
	return rval
}

// PipelineFragmentShadingRateEnumStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html
type PipelineFragmentShadingRateEnumStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV
	PNext           unsafe.Pointer
	ShadingRateType FragmentShadingRateTypeNV
	ShadingRate     FragmentShadingRateNV
	CombinerOps     [2]FragmentShadingRateCombinerOpKHR
}

type _vkPipelineFragmentShadingRateEnumStateCreateInfoNV struct {
	sType           StructureType
	pNext           unsafe.Pointer
	shadingRateType FragmentShadingRateTypeNV
	shadingRate     FragmentShadingRateNV
	combinerOps     [2]FragmentShadingRateCombinerOpKHR
}

func (s *_vkPipelineFragmentShadingRateEnumStateCreateInfoNV) Goify() *PipelineFragmentShadingRateEnumStateCreateInfoNV {
	rval := &PipelineFragmentShadingRateEnumStateCreateInfoNV{
		PNext:           (unsafe.Pointer)(s.pNext),
		ShadingRateType: (FragmentShadingRateTypeNV)(s.shadingRateType),
		ShadingRate:     (FragmentShadingRateNV)(s.shadingRate),
		CombinerOps:     ([2]FragmentShadingRateCombinerOpKHR)(s.combinerOps),
	}
	return rval
}
func (s *PipelineFragmentShadingRateEnumStateCreateInfoNV) Vulkanize() *_vkPipelineFragmentShadingRateEnumStateCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineFragmentShadingRateEnumStateCreateInfoNV{
		sType:           STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                               /*cb*/
		shadingRateType: (FragmentShadingRateTypeNV)(s.ShadingRateType),                          /*cb*/
		shadingRate:     (FragmentShadingRateNV)(s.ShadingRate),                                  /*cb*/
		combinerOps:     ([2]FragmentShadingRateCombinerOpKHR)(s.CombinerOps),                    /*cb*/
	}
	return rval
}

// PipelineFragmentShadingRateStateCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html
type PipelineFragmentShadingRateStateCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR
	PNext        unsafe.Pointer
	FragmentSize Extent2D
	CombinerOps  [2]FragmentShadingRateCombinerOpKHR
}

type _vkPipelineFragmentShadingRateStateCreateInfoKHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	fragmentSize _vkExtent2D
	combinerOps  [2]FragmentShadingRateCombinerOpKHR
}

func (s *_vkPipelineFragmentShadingRateStateCreateInfoKHR) Goify() *PipelineFragmentShadingRateStateCreateInfoKHR {
	rval := &PipelineFragmentShadingRateStateCreateInfoKHR{
		PNext:        (unsafe.Pointer)(s.pNext),
		FragmentSize: (Extent2D)(s.fragmentSize),
		CombinerOps:  ([2]FragmentShadingRateCombinerOpKHR)(s.combinerOps),
	}
	return rval
}
func (s *PipelineFragmentShadingRateStateCreateInfoKHR) Vulkanize() *_vkPipelineFragmentShadingRateStateCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineFragmentShadingRateStateCreateInfoKHR{
		sType:        STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                                           /*cb*/
		fragmentSize: (_vkExtent2D)(s.FragmentSize),                                       /*cb*/
		combinerOps:  ([2]FragmentShadingRateCombinerOpKHR)(s.CombinerOps),                /*cb*/
	}
	return rval
}

// PipelineIndirectDeviceAddressInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineIndirectDeviceAddressInfoNV.html
type PipelineIndirectDeviceAddressInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV
	PNext             unsafe.Pointer
	PipelineBindPoint PipelineBindPoint
	Pipeline          Pipeline
}

type _vkPipelineIndirectDeviceAddressInfoNV struct {
	sType             StructureType
	pNext             unsafe.Pointer
	pipelineBindPoint PipelineBindPoint
	pipeline          Pipeline
}

func (s *_vkPipelineIndirectDeviceAddressInfoNV) Goify() *PipelineIndirectDeviceAddressInfoNV {
	rval := &PipelineIndirectDeviceAddressInfoNV{
		PNext:             (unsafe.Pointer)(s.pNext),
		PipelineBindPoint: (PipelineBindPoint)(s.pipelineBindPoint),
		Pipeline:          (Pipeline)(s.pipeline),
	}
	return rval
}
func (s *PipelineIndirectDeviceAddressInfoNV) Vulkanize() *_vkPipelineIndirectDeviceAddressInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineIndirectDeviceAddressInfoNV{
		sType:             STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                               /*cb*/
		pipelineBindPoint: (PipelineBindPoint)(s.PipelineBindPoint),                /*cb*/
		pipeline:          (Pipeline)(s.Pipeline),                                  /*cb*/
	}
	return rval
}

// PipelineInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInfoEXT.html
type PipelineInfoEXT struct {
}

type _vkPipelineInfoEXT = PipelineInfoEXT

func (s *_vkPipelineInfoEXT) Goify() *PipelineInfoEXT {
	rval := (*PipelineInfoEXT)(s)
	return rval
}
func (s *PipelineInfoEXT) Vulkanize() *_vkPipelineInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPipelineInfoEXT)(s)
	return rval
}

// PipelineInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInfoKHR.html
type PipelineInfoKHR struct {
	// SType = STRUCTURE_TYPE_PIPELINE_INFO_KHR
	PNext    unsafe.Pointer
	Pipeline Pipeline
}

type _vkPipelineInfoKHR struct {
	sType    StructureType
	pNext    unsafe.Pointer
	pipeline Pipeline
}

func (s *_vkPipelineInfoKHR) Goify() *PipelineInfoKHR {
	rval := &PipelineInfoKHR{
		PNext:    (unsafe.Pointer)(s.pNext),
		Pipeline: (Pipeline)(s.pipeline),
	}
	return rval
}
func (s *PipelineInfoKHR) Vulkanize() *_vkPipelineInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineInfoKHR{
		sType:    STRUCTURE_TYPE_PIPELINE_INFO_KHR, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),        /*cb*/
		pipeline: (Pipeline)(s.Pipeline),           /*cb*/
	}
	return rval
}

// PipelineInputAssemblyStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateInfo.html
type PipelineInputAssemblyStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
	PNext                  unsafe.Pointer
	Flags                  PipelineInputAssemblyStateCreateFlags
	Topology               PrimitiveTopology
	PrimitiveRestartEnable bool
}

type _vkPipelineInputAssemblyStateCreateInfo struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	flags                  PipelineInputAssemblyStateCreateFlags
	topology               PrimitiveTopology
	primitiveRestartEnable Bool32
}

func (s *_vkPipelineInputAssemblyStateCreateInfo) Goify() *PipelineInputAssemblyStateCreateInfo {
	rval := &PipelineInputAssemblyStateCreateInfo{
		PNext:                  (unsafe.Pointer)(s.pNext),
		Flags:                  (PipelineInputAssemblyStateCreateFlags)(s.flags),
		Topology:               (PrimitiveTopology)(s.topology),
		PrimitiveRestartEnable: translatePublic_Bool32(s.primitiveRestartEnable), /*default*/
	}
	return rval
}
func (s *PipelineInputAssemblyStateCreateInfo) Vulkanize() *_vkPipelineInputAssemblyStateCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineInputAssemblyStateCreateInfo{
		sType:                  STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                /*cb*/
		flags:                  (PipelineInputAssemblyStateCreateFlags)(s.Flags),         /*cb*/
		topology:               (PrimitiveTopology)(s.Topology),                          /*cb*/
		primitiveRestartEnable: translateInternal_Bool32(s.PrimitiveRestartEnable),       /*default*/
	}
	return rval
}

// PipelineLayoutCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayoutCreateInfo.html
type PipelineLayoutCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
	PNext unsafe.Pointer
	Flags PipelineLayoutCreateFlags
	//  Number of descriptor sets interfaced by the pipeline;
	// setLayoutCount
	//  Array of setCount number of descriptor set layout objects defining the layout of the;
	PSetLayouts []DescriptorSetLayout
	//  Number of push-constant ranges used by the pipeline;
	// pushConstantRangeCount
	//  Array of pushConstantRangeCount number of ranges used by various shader stages;
	PPushConstantRanges []PushConstantRange
}

type _vkPipelineLayoutCreateInfo struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	flags                  PipelineLayoutCreateFlags
	setLayoutCount         uint32
	pSetLayouts            *DescriptorSetLayout
	pushConstantRangeCount uint32
	pPushConstantRanges    *_vkPushConstantRange
}

func (s *_vkPipelineLayoutCreateInfo) Goify() *PipelineLayoutCreateInfo {
	rval := &PipelineLayoutCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PipelineLayoutCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSetLayouts in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPushConstantRanges in returned struct
	}
	return rval
}
func (s *PipelineLayoutCreateInfo) Vulkanize() *_vkPipelineLayoutCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pSetLayouts *DescriptorSetLayout
	if len(s.PSetLayouts) > 0 {
		psl_pSetLayouts = &s.PSetLayouts[0]
	}

	var psl_pPushConstantRanges *_vkPushConstantRange
	if len(s.PPushConstantRanges) > 0 {
		psl_pPushConstantRanges = &s.PPushConstantRanges[0]
	}
	rval := &_vkPipelineLayoutCreateInfo{
		sType:                  STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                  /*cb*/
		flags:                  (PipelineLayoutCreateFlags)(s.Flags),       /*cb*/
		setLayoutCount:         uint32(len(s.PSetLayouts)),                 /*c6-a*/
		pSetLayouts:            psl_pSetLayouts,                            /*c rem*/
		pushConstantRangeCount: uint32(len(s.PPushConstantRanges)),         /*c6-a*/
		pPushConstantRanges:    psl_pPushConstantRanges,                    /*c rem*/
	}
	return rval
}

// PipelineLibraryCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLibraryCreateInfoKHR.html
type PipelineLibraryCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR
	PNext unsafe.Pointer
	// libraryCount
	PLibraries []Pipeline
}

type _vkPipelineLibraryCreateInfoKHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	libraryCount uint32
	pLibraries   *Pipeline
}

func (s *_vkPipelineLibraryCreateInfoKHR) Goify() *PipelineLibraryCreateInfoKHR {
	rval := &PipelineLibraryCreateInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pLibraries in returned struct
	}
	return rval
}
func (s *PipelineLibraryCreateInfoKHR) Vulkanize() *_vkPipelineLibraryCreateInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pLibraries *Pipeline
	if len(s.PLibraries) > 0 {
		psl_pLibraries = &s.PLibraries[0]
	}
	rval := &_vkPipelineLibraryCreateInfoKHR{
		sType:        STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                       /*cb*/
		libraryCount: uint32(len(s.PLibraries)),                       /*c6-a*/
		pLibraries:   psl_pLibraries,                                  /*c rem*/
	}
	return rval
}

// PipelineMultisampleStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html
type PipelineMultisampleStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
	PNext unsafe.Pointer
	Flags PipelineMultisampleStateCreateFlags
	//  Number of samples used for rasterization;
	RasterizationSamples SampleCountFlagBits
	//  optional (GL45);
	SampleShadingEnable bool
	//  optional (GL45);
	MinSampleShading float32
	//  Array of sampleMask words;
	PSampleMask           *SampleMask
	AlphaToCoverageEnable bool
	AlphaToOneEnable      bool
}

type _vkPipelineMultisampleStateCreateInfo struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	flags                 PipelineMultisampleStateCreateFlags
	rasterizationSamples  SampleCountFlagBits
	sampleShadingEnable   Bool32
	minSampleShading      float32
	pSampleMask           *SampleMask
	alphaToCoverageEnable Bool32
	alphaToOneEnable      Bool32
}

func (s *_vkPipelineMultisampleStateCreateInfo) Goify() *PipelineMultisampleStateCreateInfo {
	rval := &PipelineMultisampleStateCreateInfo{
		PNext:                 (unsafe.Pointer)(s.pNext),
		Flags:                 (PipelineMultisampleStateCreateFlags)(s.flags),
		RasterizationSamples:  (SampleCountFlagBits)(s.rasterizationSamples),
		SampleShadingEnable:   translatePublic_Bool32(s.sampleShadingEnable), /*default*/
		MinSampleShading:      (float32)(s.minSampleShading),
		PSampleMask:           (*SampleMask)(s.pSampleMask),
		AlphaToCoverageEnable: translatePublic_Bool32(s.alphaToCoverageEnable), /*default*/
		AlphaToOneEnable:      translatePublic_Bool32(s.alphaToOneEnable),      /*default*/
	}
	return rval
}
func (s *PipelineMultisampleStateCreateInfo) Vulkanize() *_vkPipelineMultisampleStateCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineMultisampleStateCreateInfo{
		sType:                 STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                             /*cb*/
		flags:                 (PipelineMultisampleStateCreateFlags)(s.Flags),        /*cb*/
		rasterizationSamples:  (SampleCountFlagBits)(s.RasterizationSamples),         /*cb*/
		sampleShadingEnable:   translateInternal_Bool32(s.SampleShadingEnable),       /*default*/
		minSampleShading:      (float32)(s.MinSampleShading),                         /*cb*/
		pSampleMask:           (*SampleMask)(s.PSampleMask),                          /*cb*/
		alphaToCoverageEnable: translateInternal_Bool32(s.AlphaToCoverageEnable),     /*default*/
		alphaToOneEnable:      translateInternal_Bool32(s.AlphaToOneEnable),          /*default*/
	}
	return rval
}

// PipelinePropertiesIdentifierEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelinePropertiesIdentifierEXT.html
type PipelinePropertiesIdentifierEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT
	PNext              unsafe.Pointer
	PipelineIdentifier [UUID_SIZE]uint8
}

type _vkPipelinePropertiesIdentifierEXT struct {
	sType              StructureType
	pNext              unsafe.Pointer
	pipelineIdentifier [UUID_SIZE]uint8
}

func (s *_vkPipelinePropertiesIdentifierEXT) Goify() *PipelinePropertiesIdentifierEXT {
	rval := &PipelinePropertiesIdentifierEXT{
		PNext:              (unsafe.Pointer)(s.pNext),
		PipelineIdentifier: ([UUID_SIZE]uint8)(s.pipelineIdentifier),
	}
	return rval
}
func (s *PipelinePropertiesIdentifierEXT) Vulkanize() *_vkPipelinePropertiesIdentifierEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelinePropertiesIdentifierEXT{
		sType:              STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                         /*cb*/
		pipelineIdentifier: ([UUID_SIZE]uint8)(s.PipelineIdentifier),          /*cb*/
	}
	return rval
}

// PipelineRasterizationConservativeStateCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html
type PipelineRasterizationConservativeStateCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT
	PNext unsafe.Pointer
	//  Reserved;
	Flags PipelineRasterizationConservativeStateCreateFlagsEXT
	//  Conservative rasterization mode;
	ConservativeRasterizationMode ConservativeRasterizationModeEXT
	//  Extra overestimation to add to the primitive;
	ExtraPrimitiveOverestimationSize float32
}

type _vkPipelineRasterizationConservativeStateCreateInfoEXT struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	flags                            PipelineRasterizationConservativeStateCreateFlagsEXT
	conservativeRasterizationMode    ConservativeRasterizationModeEXT
	extraPrimitiveOverestimationSize float32
}

func (s *_vkPipelineRasterizationConservativeStateCreateInfoEXT) Goify() *PipelineRasterizationConservativeStateCreateInfoEXT {
	rval := &PipelineRasterizationConservativeStateCreateInfoEXT{
		PNext:                            (unsafe.Pointer)(s.pNext),
		Flags:                            (PipelineRasterizationConservativeStateCreateFlagsEXT)(s.flags),
		ConservativeRasterizationMode:    (ConservativeRasterizationModeEXT)(s.conservativeRasterizationMode),
		ExtraPrimitiveOverestimationSize: (float32)(s.extraPrimitiveOverestimationSize),
	}
	return rval
}
func (s *PipelineRasterizationConservativeStateCreateInfoEXT) Vulkanize() *_vkPipelineRasterizationConservativeStateCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineRasterizationConservativeStateCreateInfoEXT{
		sType:                            STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                                /*cb*/
		flags:                            (PipelineRasterizationConservativeStateCreateFlagsEXT)(s.Flags),          /*cb*/
		conservativeRasterizationMode:    (ConservativeRasterizationModeEXT)(s.ConservativeRasterizationMode),      /*cb*/
		extraPrimitiveOverestimationSize: (float32)(s.ExtraPrimitiveOverestimationSize),                            /*cb*/
	}
	return rval
}

// PipelineRasterizationDepthClipStateCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html
type PipelineRasterizationDepthClipStateCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT
	PNext unsafe.Pointer
	//  Reserved;
	Flags           PipelineRasterizationDepthClipStateCreateFlagsEXT
	DepthClipEnable bool
}

type _vkPipelineRasterizationDepthClipStateCreateInfoEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           PipelineRasterizationDepthClipStateCreateFlagsEXT
	depthClipEnable Bool32
}

func (s *_vkPipelineRasterizationDepthClipStateCreateInfoEXT) Goify() *PipelineRasterizationDepthClipStateCreateInfoEXT {
	rval := &PipelineRasterizationDepthClipStateCreateInfoEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		Flags:           (PipelineRasterizationDepthClipStateCreateFlagsEXT)(s.flags),
		DepthClipEnable: translatePublic_Bool32(s.depthClipEnable), /*default*/
	}
	return rval
}
func (s *PipelineRasterizationDepthClipStateCreateInfoEXT) Vulkanize() *_vkPipelineRasterizationDepthClipStateCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineRasterizationDepthClipStateCreateInfoEXT{
		sType:           STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                              /*cb*/
		flags:           (PipelineRasterizationDepthClipStateCreateFlagsEXT)(s.Flags),           /*cb*/
		depthClipEnable: translateInternal_Bool32(s.DepthClipEnable),                            /*default*/
	}
	return rval
}

// PipelineRasterizationLineStateCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationLineStateCreateInfoEXT.html
type PipelineRasterizationLineStateCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT
	PNext                 unsafe.Pointer
	LineRasterizationMode LineRasterizationModeEXT
	StippledLineEnable    bool
	LineStippleFactor     uint32
	LineStipplePattern    uint16
}

type _vkPipelineRasterizationLineStateCreateInfoEXT struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	lineRasterizationMode LineRasterizationModeEXT
	stippledLineEnable    Bool32
	lineStippleFactor     uint32
	lineStipplePattern    uint16
}

func (s *_vkPipelineRasterizationLineStateCreateInfoEXT) Goify() *PipelineRasterizationLineStateCreateInfoEXT {
	rval := &PipelineRasterizationLineStateCreateInfoEXT{
		PNext:                 (unsafe.Pointer)(s.pNext),
		LineRasterizationMode: (LineRasterizationModeEXT)(s.lineRasterizationMode),
		StippledLineEnable:    translatePublic_Bool32(s.stippledLineEnable), /*default*/
		LineStippleFactor:     (uint32)(s.lineStippleFactor),
		LineStipplePattern:    (uint16)(s.lineStipplePattern),
	}
	return rval
}
func (s *PipelineRasterizationLineStateCreateInfoEXT) Vulkanize() *_vkPipelineRasterizationLineStateCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineRasterizationLineStateCreateInfoEXT{
		sType:                 STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                        /*cb*/
		lineRasterizationMode: (LineRasterizationModeEXT)(s.LineRasterizationMode),              /*cb*/
		stippledLineEnable:    translateInternal_Bool32(s.StippledLineEnable),                   /*default*/
		lineStippleFactor:     (uint32)(s.LineStippleFactor),                                    /*cb*/
		lineStipplePattern:    (uint16)(s.LineStipplePattern),                                   /*cb*/
	}
	return rval
}

// PipelineRasterizationProvokingVertexStateCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.html
type PipelineRasterizationProvokingVertexStateCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT
	PNext               unsafe.Pointer
	ProvokingVertexMode ProvokingVertexModeEXT
}

type _vkPipelineRasterizationProvokingVertexStateCreateInfoEXT struct {
	sType               StructureType
	pNext               unsafe.Pointer
	provokingVertexMode ProvokingVertexModeEXT
}

func (s *_vkPipelineRasterizationProvokingVertexStateCreateInfoEXT) Goify() *PipelineRasterizationProvokingVertexStateCreateInfoEXT {
	rval := &PipelineRasterizationProvokingVertexStateCreateInfoEXT{
		PNext:               (unsafe.Pointer)(s.pNext),
		ProvokingVertexMode: (ProvokingVertexModeEXT)(s.provokingVertexMode),
	}
	return rval
}
func (s *PipelineRasterizationProvokingVertexStateCreateInfoEXT) Vulkanize() *_vkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineRasterizationProvokingVertexStateCreateInfoEXT{
		sType:               STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                                    /*cb*/
		provokingVertexMode: (ProvokingVertexModeEXT)(s.ProvokingVertexMode),                              /*cb*/
	}
	return rval
}

// PipelineRasterizationStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateInfo.html
type PipelineRasterizationStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
	PNext                   unsafe.Pointer
	Flags                   PipelineRasterizationStateCreateFlags
	DepthClampEnable        bool
	RasterizerDiscardEnable bool
	//  optional (GL45);
	PolygonMode             PolygonMode
	CullMode                CullModeFlags
	FrontFace               FrontFace
	DepthBiasEnable         bool
	DepthBiasConstantFactor float32
	DepthBiasClamp          float32
	DepthBiasSlopeFactor    float32
	LineWidth               float32
}

type _vkPipelineRasterizationStateCreateInfo struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	flags                   PipelineRasterizationStateCreateFlags
	depthClampEnable        Bool32
	rasterizerDiscardEnable Bool32
	polygonMode             PolygonMode
	cullMode                CullModeFlags
	frontFace               FrontFace
	depthBiasEnable         Bool32
	depthBiasConstantFactor float32
	depthBiasClamp          float32
	depthBiasSlopeFactor    float32
	lineWidth               float32
}

func (s *_vkPipelineRasterizationStateCreateInfo) Goify() *PipelineRasterizationStateCreateInfo {
	rval := &PipelineRasterizationStateCreateInfo{
		PNext:                   (unsafe.Pointer)(s.pNext),
		Flags:                   (PipelineRasterizationStateCreateFlags)(s.flags),
		DepthClampEnable:        translatePublic_Bool32(s.depthClampEnable),        /*default*/
		RasterizerDiscardEnable: translatePublic_Bool32(s.rasterizerDiscardEnable), /*default*/
		PolygonMode:             (PolygonMode)(s.polygonMode),
		CullMode:                (CullModeFlags)(s.cullMode),
		FrontFace:               (FrontFace)(s.frontFace),
		DepthBiasEnable:         translatePublic_Bool32(s.depthBiasEnable), /*default*/
		DepthBiasConstantFactor: (float32)(s.depthBiasConstantFactor),
		DepthBiasClamp:          (float32)(s.depthBiasClamp),
		DepthBiasSlopeFactor:    (float32)(s.depthBiasSlopeFactor),
		LineWidth:               (float32)(s.lineWidth),
	}
	return rval
}
func (s *PipelineRasterizationStateCreateInfo) Vulkanize() *_vkPipelineRasterizationStateCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineRasterizationStateCreateInfo{
		sType:                   STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                               /*cb*/
		flags:                   (PipelineRasterizationStateCreateFlags)(s.Flags),        /*cb*/
		depthClampEnable:        translateInternal_Bool32(s.DepthClampEnable),            /*default*/
		rasterizerDiscardEnable: translateInternal_Bool32(s.RasterizerDiscardEnable),     /*default*/
		polygonMode:             (PolygonMode)(s.PolygonMode),                            /*cb*/
		cullMode:                (CullModeFlags)(s.CullMode),                             /*cb*/
		frontFace:               (FrontFace)(s.FrontFace),                                /*cb*/
		depthBiasEnable:         translateInternal_Bool32(s.DepthBiasEnable),             /*default*/
		depthBiasConstantFactor: (float32)(s.DepthBiasConstantFactor),                    /*cb*/
		depthBiasClamp:          (float32)(s.DepthBiasClamp),                             /*cb*/
		depthBiasSlopeFactor:    (float32)(s.DepthBiasSlopeFactor),                       /*cb*/
		lineWidth:               (float32)(s.LineWidth),                                  /*cb*/
	}
	return rval
}

// PipelineRasterizationStateRasterizationOrderAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html
type PipelineRasterizationStateRasterizationOrderAMD struct {
	// SType = STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD
	PNext unsafe.Pointer
	//  Rasterization order to use for the pipeline;
	RasterizationOrder RasterizationOrderAMD
}

type _vkPipelineRasterizationStateRasterizationOrderAMD struct {
	sType              StructureType
	pNext              unsafe.Pointer
	rasterizationOrder RasterizationOrderAMD
}

func (s *_vkPipelineRasterizationStateRasterizationOrderAMD) Goify() *PipelineRasterizationStateRasterizationOrderAMD {
	rval := &PipelineRasterizationStateRasterizationOrderAMD{
		PNext:              (unsafe.Pointer)(s.pNext),
		RasterizationOrder: (RasterizationOrderAMD)(s.rasterizationOrder),
	}
	return rval
}
func (s *PipelineRasterizationStateRasterizationOrderAMD) Vulkanize() *_vkPipelineRasterizationStateRasterizationOrderAMD {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineRasterizationStateRasterizationOrderAMD{
		sType:              STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                           /*cb*/
		rasterizationOrder: (RasterizationOrderAMD)(s.RasterizationOrder),                       /*cb*/
	}
	return rval
}

// PipelineRasterizationStateStreamCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html
type PipelineRasterizationStateStreamCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT
	PNext               unsafe.Pointer
	Flags               PipelineRasterizationStateStreamCreateFlagsEXT
	RasterizationStream uint32
}

type _vkPipelineRasterizationStateStreamCreateInfoEXT struct {
	sType               StructureType
	pNext               unsafe.Pointer
	flags               PipelineRasterizationStateStreamCreateFlagsEXT
	rasterizationStream uint32
}

func (s *_vkPipelineRasterizationStateStreamCreateInfoEXT) Goify() *PipelineRasterizationStateStreamCreateInfoEXT {
	rval := &PipelineRasterizationStateStreamCreateInfoEXT{
		PNext:               (unsafe.Pointer)(s.pNext),
		Flags:               (PipelineRasterizationStateStreamCreateFlagsEXT)(s.flags),
		RasterizationStream: (uint32)(s.rasterizationStream),
	}
	return rval
}
func (s *PipelineRasterizationStateStreamCreateInfoEXT) Vulkanize() *_vkPipelineRasterizationStateStreamCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineRasterizationStateStreamCreateInfoEXT{
		sType:               STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                          /*cb*/
		flags:               (PipelineRasterizationStateStreamCreateFlagsEXT)(s.Flags),          /*cb*/
		rasterizationStream: (uint32)(s.RasterizationStream),                                    /*cb*/
	}
	return rval
}

// PipelineRenderingCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRenderingCreateInfoKHR.html
type PipelineRenderingCreateInfoKHR struct {
}

type _vkPipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfoKHR

func (s *_vkPipelineRenderingCreateInfoKHR) Goify() *PipelineRenderingCreateInfoKHR {
	rval := (*PipelineRenderingCreateInfoKHR)(s)
	return rval
}
func (s *PipelineRenderingCreateInfoKHR) Vulkanize() *_vkPipelineRenderingCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPipelineRenderingCreateInfoKHR)(s)
	return rval
}

// PipelineRepresentativeFragmentTestStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html
type PipelineRepresentativeFragmentTestStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV
	PNext                            unsafe.Pointer
	RepresentativeFragmentTestEnable bool
}

type _vkPipelineRepresentativeFragmentTestStateCreateInfoNV struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	representativeFragmentTestEnable Bool32
}

func (s *_vkPipelineRepresentativeFragmentTestStateCreateInfoNV) Goify() *PipelineRepresentativeFragmentTestStateCreateInfoNV {
	rval := &PipelineRepresentativeFragmentTestStateCreateInfoNV{
		PNext:                            (unsafe.Pointer)(s.pNext),
		RepresentativeFragmentTestEnable: translatePublic_Bool32(s.representativeFragmentTestEnable), /*default*/
	}
	return rval
}
func (s *PipelineRepresentativeFragmentTestStateCreateInfoNV) Vulkanize() *_vkPipelineRepresentativeFragmentTestStateCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineRepresentativeFragmentTestStateCreateInfoNV{
		sType:                            STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                                                 /*cb*/
		representativeFragmentTestEnable: translateInternal_Bool32(s.RepresentativeFragmentTestEnable),              /*default*/
	}
	return rval
}

// PipelineRobustnessCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRobustnessCreateInfoEXT.html
type PipelineRobustnessCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT
	PNext          unsafe.Pointer
	StorageBuffers PipelineRobustnessBufferBehaviorEXT
	UniformBuffers PipelineRobustnessBufferBehaviorEXT
	VertexInputs   PipelineRobustnessBufferBehaviorEXT
	Images         PipelineRobustnessImageBehaviorEXT
}

type _vkPipelineRobustnessCreateInfoEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	storageBuffers PipelineRobustnessBufferBehaviorEXT
	uniformBuffers PipelineRobustnessBufferBehaviorEXT
	vertexInputs   PipelineRobustnessBufferBehaviorEXT
	images         PipelineRobustnessImageBehaviorEXT
}

func (s *_vkPipelineRobustnessCreateInfoEXT) Goify() *PipelineRobustnessCreateInfoEXT {
	rval := &PipelineRobustnessCreateInfoEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		StorageBuffers: (PipelineRobustnessBufferBehaviorEXT)(s.storageBuffers),
		UniformBuffers: (PipelineRobustnessBufferBehaviorEXT)(s.uniformBuffers),
		VertexInputs:   (PipelineRobustnessBufferBehaviorEXT)(s.vertexInputs),
		Images:         (PipelineRobustnessImageBehaviorEXT)(s.images),
	}
	return rval
}
func (s *PipelineRobustnessCreateInfoEXT) Vulkanize() *_vkPipelineRobustnessCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineRobustnessCreateInfoEXT{
		sType:          STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT,      /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                               /*cb*/
		storageBuffers: (PipelineRobustnessBufferBehaviorEXT)(s.StorageBuffers), /*cb*/
		uniformBuffers: (PipelineRobustnessBufferBehaviorEXT)(s.UniformBuffers), /*cb*/
		vertexInputs:   (PipelineRobustnessBufferBehaviorEXT)(s.VertexInputs),   /*cb*/
		images:         (PipelineRobustnessImageBehaviorEXT)(s.Images),          /*cb*/
	}
	return rval
}

// PipelineSampleLocationsStateCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html
type PipelineSampleLocationsStateCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT
	PNext                 unsafe.Pointer
	SampleLocationsEnable bool
	SampleLocationsInfo   SampleLocationsInfoEXT
}

type _vkPipelineSampleLocationsStateCreateInfoEXT struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	sampleLocationsEnable Bool32
	sampleLocationsInfo   _vkSampleLocationsInfoEXT
}

func (s *_vkPipelineSampleLocationsStateCreateInfoEXT) Goify() *PipelineSampleLocationsStateCreateInfoEXT {
	rval := &PipelineSampleLocationsStateCreateInfoEXT{
		PNext:                 (unsafe.Pointer)(s.pNext),
		SampleLocationsEnable: translatePublic_Bool32(s.sampleLocationsEnable), /*default*/
		SampleLocationsInfo:   *(s.sampleLocationsInfo.Goify()),
	}
	return rval
}
func (s *PipelineSampleLocationsStateCreateInfoEXT) Vulkanize() *_vkPipelineSampleLocationsStateCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineSampleLocationsStateCreateInfoEXT{
		sType:                 STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                      /*cb*/
		sampleLocationsEnable: translateInternal_Bool32(s.SampleLocationsEnable),              /*default*/
		sampleLocationsInfo:   *(s.SampleLocationsInfo.Vulkanize()),                           /*c3*/
	}
	return rval
}

// PipelineShaderStageCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateInfo.html
type PipelineShaderStageCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
	PNext unsafe.Pointer
	Flags PipelineShaderStageCreateFlags
	//  Shader stage;
	Stage ShaderStageFlagBits
	//  Module containing entry point;
	Module ShaderModule
	//  Null-terminated entry point name;
	PName               string
	PSpecializationInfo *SpecializationInfo
}

type _vkPipelineShaderStageCreateInfo struct {
	sType               StructureType
	pNext               unsafe.Pointer
	flags               PipelineShaderStageCreateFlags
	stage               ShaderStageFlagBits
	module              ShaderModule
	pName               *byte
	pSpecializationInfo *_vkSpecializationInfo
}

func (s *_vkPipelineShaderStageCreateInfo) Goify() *PipelineShaderStageCreateInfo {
	rval := &PipelineShaderStageCreateInfo{
		PNext:  (unsafe.Pointer)(s.pNext),
		Flags:  (PipelineShaderStageCreateFlags)(s.flags),
		Stage:  (ShaderStageFlagBits)(s.stage),
		Module: (ShaderModule)(s.module),
		// Unexpected pointer member pName in returned struct
		// Unexpected pointer member pSpecializationInfo in returned struct
	}
	return rval
}
func (s *PipelineShaderStageCreateInfo) Vulkanize() *_vkPipelineShaderStageCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineShaderStageCreateInfo{
		sType:               STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                        /*cb*/
		flags:               (PipelineShaderStageCreateFlags)(s.Flags),        /*cb*/
		stage:               (ShaderStageFlagBits)(s.Stage),                   /*cb*/
		module:              (ShaderModule)(s.Module),                         /*cb*/
		pName:               sys_stringToBytePointer(s.PName),                 /*c rem*/
		pSpecializationInfo: (s.PSpecializationInfo.Vulkanize()),              /*c rem*/
	}
	return rval
}

// PipelineShaderStageModuleIdentifierCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageModuleIdentifierCreateInfoEXT.html
type PipelineShaderStageModuleIdentifierCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT
	PNext unsafe.Pointer
	// identifierSize
	PIdentifier []uint8
}

type _vkPipelineShaderStageModuleIdentifierCreateInfoEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	identifierSize uint32
	pIdentifier    *uint8
}

func (s *_vkPipelineShaderStageModuleIdentifierCreateInfoEXT) Goify() *PipelineShaderStageModuleIdentifierCreateInfoEXT {
	rval := &PipelineShaderStageModuleIdentifierCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pIdentifier in returned struct
	}
	return rval
}
func (s *PipelineShaderStageModuleIdentifierCreateInfoEXT) Vulkanize() *_vkPipelineShaderStageModuleIdentifierCreateInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pIdentifier *uint8
	if len(s.PIdentifier) > 0 {
		psl_pIdentifier = &s.PIdentifier[0]
	}
	rval := &_vkPipelineShaderStageModuleIdentifierCreateInfoEXT{
		sType:          STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                              /*cb*/
		identifierSize: uint32(len(s.PIdentifier)),                                             /*c6-a*/
		pIdentifier:    psl_pIdentifier,                                                        /*c rem*/
	}
	return rval
}

// PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.html
type PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT struct {
}

type _vkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT

func (s *_vkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT) Goify() *PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
	rval := (*PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)(s)
	return rval
}
func (s *PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT) Vulkanize() *_vkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)(s)
	return rval
}

// PipelineTessellationDomainOriginStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html
type PipelineTessellationDomainOriginStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO
	PNext        unsafe.Pointer
	DomainOrigin TessellationDomainOrigin
}

type _vkPipelineTessellationDomainOriginStateCreateInfo struct {
	sType        StructureType
	pNext        unsafe.Pointer
	domainOrigin TessellationDomainOrigin
}

func (s *_vkPipelineTessellationDomainOriginStateCreateInfo) Goify() *PipelineTessellationDomainOriginStateCreateInfo {
	rval := &PipelineTessellationDomainOriginStateCreateInfo{
		PNext:        (unsafe.Pointer)(s.pNext),
		DomainOrigin: (TessellationDomainOrigin)(s.domainOrigin),
	}
	return rval
}
func (s *PipelineTessellationDomainOriginStateCreateInfo) Vulkanize() *_vkPipelineTessellationDomainOriginStateCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineTessellationDomainOriginStateCreateInfo{
		sType:        STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                                            /*cb*/
		domainOrigin: (TessellationDomainOrigin)(s.DomainOrigin),                           /*cb*/
	}
	return rval
}

// PipelineTessellationDomainOriginStateCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationDomainOriginStateCreateInfoKHR.html
type PipelineTessellationDomainOriginStateCreateInfoKHR struct {
}

type _vkPipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfoKHR

func (s *_vkPipelineTessellationDomainOriginStateCreateInfoKHR) Goify() *PipelineTessellationDomainOriginStateCreateInfoKHR {
	rval := (*PipelineTessellationDomainOriginStateCreateInfoKHR)(s)
	return rval
}
func (s *PipelineTessellationDomainOriginStateCreateInfoKHR) Vulkanize() *_vkPipelineTessellationDomainOriginStateCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkPipelineTessellationDomainOriginStateCreateInfoKHR)(s)
	return rval
}

// PipelineTessellationStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateInfo.html
type PipelineTessellationStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
	PNext              unsafe.Pointer
	Flags              PipelineTessellationStateCreateFlags
	PatchControlPoints uint32
}

type _vkPipelineTessellationStateCreateInfo struct {
	sType              StructureType
	pNext              unsafe.Pointer
	flags              PipelineTessellationStateCreateFlags
	patchControlPoints uint32
}

func (s *_vkPipelineTessellationStateCreateInfo) Goify() *PipelineTessellationStateCreateInfo {
	rval := &PipelineTessellationStateCreateInfo{
		PNext:              (unsafe.Pointer)(s.pNext),
		Flags:              (PipelineTessellationStateCreateFlags)(s.flags),
		PatchControlPoints: (uint32)(s.patchControlPoints),
	}
	return rval
}
func (s *PipelineTessellationStateCreateInfo) Vulkanize() *_vkPipelineTessellationStateCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineTessellationStateCreateInfo{
		sType:              STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                              /*cb*/
		flags:              (PipelineTessellationStateCreateFlags)(s.Flags),        /*cb*/
		patchControlPoints: (uint32)(s.PatchControlPoints),                         /*cb*/
	}
	return rval
}

// PipelineVertexInputDivisorStateCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputDivisorStateCreateInfoEXT.html
type PipelineVertexInputDivisorStateCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT
	PNext unsafe.Pointer
	// vertexBindingDivisorCount
	PVertexBindingDivisors []VertexInputBindingDivisorDescriptionEXT
}

type _vkPipelineVertexInputDivisorStateCreateInfoEXT struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	vertexBindingDivisorCount uint32
	pVertexBindingDivisors    *_vkVertexInputBindingDivisorDescriptionEXT
}

func (s *_vkPipelineVertexInputDivisorStateCreateInfoEXT) Goify() *PipelineVertexInputDivisorStateCreateInfoEXT {
	rval := &PipelineVertexInputDivisorStateCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pVertexBindingDivisors in returned struct
	}
	return rval
}
func (s *PipelineVertexInputDivisorStateCreateInfoEXT) Vulkanize() *_vkPipelineVertexInputDivisorStateCreateInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pVertexBindingDivisors *_vkVertexInputBindingDivisorDescriptionEXT
	if len(s.PVertexBindingDivisors) > 0 {
		psl_pVertexBindingDivisors = &s.PVertexBindingDivisors[0]
	}
	rval := &_vkPipelineVertexInputDivisorStateCreateInfoEXT{
		sType:                     STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                                          /*cb*/
		vertexBindingDivisorCount: uint32(len(s.PVertexBindingDivisors)),                              /*c6-a*/
		pVertexBindingDivisors:    psl_pVertexBindingDivisors,                                         /*c rem*/
	}
	return rval
}

// PipelineVertexInputStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateInfo.html
type PipelineVertexInputStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
	PNext unsafe.Pointer
	Flags PipelineVertexInputStateCreateFlags
	//  number of bindings;
	// vertexBindingDescriptionCount
	PVertexBindingDescriptions []VertexInputBindingDescription
	//  number of attributes;
	// vertexAttributeDescriptionCount
	PVertexAttributeDescriptions []VertexInputAttributeDescription
}

type _vkPipelineVertexInputStateCreateInfo struct {
	sType                           StructureType
	pNext                           unsafe.Pointer
	flags                           PipelineVertexInputStateCreateFlags
	vertexBindingDescriptionCount   uint32
	pVertexBindingDescriptions      *_vkVertexInputBindingDescription
	vertexAttributeDescriptionCount uint32
	pVertexAttributeDescriptions    *_vkVertexInputAttributeDescription
}

func (s *_vkPipelineVertexInputStateCreateInfo) Goify() *PipelineVertexInputStateCreateInfo {
	rval := &PipelineVertexInputStateCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PipelineVertexInputStateCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pVertexBindingDescriptions in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pVertexAttributeDescriptions in returned struct
	}
	return rval
}
func (s *PipelineVertexInputStateCreateInfo) Vulkanize() *_vkPipelineVertexInputStateCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pVertexBindingDescriptions *_vkVertexInputBindingDescription
	if len(s.PVertexBindingDescriptions) > 0 {
		psl_pVertexBindingDescriptions = &s.PVertexBindingDescriptions[0]
	}

	var psl_pVertexAttributeDescriptions *_vkVertexInputAttributeDescription
	if len(s.PVertexAttributeDescriptions) > 0 {
		psl_pVertexAttributeDescriptions = &s.PVertexAttributeDescriptions[0]
	}
	rval := &_vkPipelineVertexInputStateCreateInfo{
		sType:                           STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, /*c1*/
		pNext:                           (unsafe.Pointer)(s.PNext),                              /*cb*/
		flags:                           (PipelineVertexInputStateCreateFlags)(s.Flags),         /*cb*/
		vertexBindingDescriptionCount:   uint32(len(s.PVertexBindingDescriptions)),              /*c6-a*/
		pVertexBindingDescriptions:      psl_pVertexBindingDescriptions,                         /*c rem*/
		vertexAttributeDescriptionCount: uint32(len(s.PVertexAttributeDescriptions)),            /*c6-a*/
		pVertexAttributeDescriptions:    psl_pVertexAttributeDescriptions,                       /*c rem*/
	}
	return rval
}

// PipelineViewportCoarseSampleOrderStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html
type PipelineViewportCoarseSampleOrderStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV
	PNext           unsafe.Pointer
	SampleOrderType CoarseSampleOrderTypeNV
	// customSampleOrderCount
	PCustomSampleOrders []CoarseSampleOrderCustomNV
}

type _vkPipelineViewportCoarseSampleOrderStateCreateInfoNV struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	sampleOrderType        CoarseSampleOrderTypeNV
	customSampleOrderCount uint32
	pCustomSampleOrders    *_vkCoarseSampleOrderCustomNV
}

func (s *_vkPipelineViewportCoarseSampleOrderStateCreateInfoNV) Goify() *PipelineViewportCoarseSampleOrderStateCreateInfoNV {
	rval := &PipelineViewportCoarseSampleOrderStateCreateInfoNV{
		PNext:           (unsafe.Pointer)(s.pNext),
		SampleOrderType: (CoarseSampleOrderTypeNV)(s.sampleOrderType),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCustomSampleOrders in returned struct
	}
	return rval
}
func (s *PipelineViewportCoarseSampleOrderStateCreateInfoNV) Vulkanize() *_vkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pCustomSampleOrders *_vkCoarseSampleOrderCustomNV
	if len(s.PCustomSampleOrders) > 0 {
		sl_pCustomSampleOrders := make([]_vkCoarseSampleOrderCustomNV, len(s.PCustomSampleOrders))
		for i, v := range s.PCustomSampleOrders {
			sl_pCustomSampleOrders[i] = *(v.Vulkanize())
		}
		psl_pCustomSampleOrders = &sl_pCustomSampleOrders[0]
	}
	rval := &_vkPipelineViewportCoarseSampleOrderStateCreateInfoNV{
		sType:                  STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                                 /*cb*/
		sampleOrderType:        (CoarseSampleOrderTypeNV)(s.SampleOrderType),                              /*cb*/
		customSampleOrderCount: uint32(len(s.PCustomSampleOrders)),                                        /*c6-a*/
		pCustomSampleOrders:    psl_pCustomSampleOrders,                                                   /*c rem*/
	}
	return rval
}

// PipelineViewportDepthClipControlCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportDepthClipControlCreateInfoEXT.html
type PipelineViewportDepthClipControlCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT
	PNext            unsafe.Pointer
	NegativeOneToOne bool
}

type _vkPipelineViewportDepthClipControlCreateInfoEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	negativeOneToOne Bool32
}

func (s *_vkPipelineViewportDepthClipControlCreateInfoEXT) Goify() *PipelineViewportDepthClipControlCreateInfoEXT {
	rval := &PipelineViewportDepthClipControlCreateInfoEXT{
		PNext:            (unsafe.Pointer)(s.pNext),
		NegativeOneToOne: translatePublic_Bool32(s.negativeOneToOne), /*default*/
	}
	return rval
}
func (s *PipelineViewportDepthClipControlCreateInfoEXT) Vulkanize() *_vkPipelineViewportDepthClipControlCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkPipelineViewportDepthClipControlCreateInfoEXT{
		sType:            STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                           /*cb*/
		negativeOneToOne: translateInternal_Bool32(s.NegativeOneToOne),                        /*default*/
	}
	return rval
}

// PipelineViewportExclusiveScissorStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html
type PipelineViewportExclusiveScissorStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV
	PNext unsafe.Pointer
	// exclusiveScissorCount
	PExclusiveScissors []Rect2D
}

type _vkPipelineViewportExclusiveScissorStateCreateInfoNV struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	exclusiveScissorCount uint32
	pExclusiveScissors    *_vkRect2D
}

func (s *_vkPipelineViewportExclusiveScissorStateCreateInfoNV) Goify() *PipelineViewportExclusiveScissorStateCreateInfoNV {
	rval := &PipelineViewportExclusiveScissorStateCreateInfoNV{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pExclusiveScissors in returned struct
	}
	return rval
}
func (s *PipelineViewportExclusiveScissorStateCreateInfoNV) Vulkanize() *_vkPipelineViewportExclusiveScissorStateCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pExclusiveScissors *_vkRect2D
	if len(s.PExclusiveScissors) > 0 {
		sl_pExclusiveScissors := make([]_vkRect2D, len(s.PExclusiveScissors))
		for i, v := range s.PExclusiveScissors {
			sl_pExclusiveScissors[i] = *(v.Vulkanize())
		}
		psl_pExclusiveScissors = &sl_pExclusiveScissors[0]
	}
	rval := &_vkPipelineViewportExclusiveScissorStateCreateInfoNV{
		sType:                 STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                                               /*cb*/
		exclusiveScissorCount: uint32(len(s.PExclusiveScissors)),                                       /*c6-a*/
		pExclusiveScissors:    psl_pExclusiveScissors,                                                  /*c rem*/
	}
	return rval
}

// PipelineViewportShadingRateImageStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html
type PipelineViewportShadingRateImageStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV
	PNext                  unsafe.Pointer
	ShadingRateImageEnable bool
	// viewportCount
	PShadingRatePalettes []ShadingRatePaletteNV
}

type _vkPipelineViewportShadingRateImageStateCreateInfoNV struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	shadingRateImageEnable Bool32
	viewportCount          uint32
	pShadingRatePalettes   *_vkShadingRatePaletteNV
}

func (s *_vkPipelineViewportShadingRateImageStateCreateInfoNV) Goify() *PipelineViewportShadingRateImageStateCreateInfoNV {
	rval := &PipelineViewportShadingRateImageStateCreateInfoNV{
		PNext:                  (unsafe.Pointer)(s.pNext),
		ShadingRateImageEnable: translatePublic_Bool32(s.shadingRateImageEnable), /*default*/
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pShadingRatePalettes in returned struct
	}
	return rval
}
func (s *PipelineViewportShadingRateImageStateCreateInfoNV) Vulkanize() *_vkPipelineViewportShadingRateImageStateCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pShadingRatePalettes *_vkShadingRatePaletteNV
	if len(s.PShadingRatePalettes) > 0 {
		sl_pShadingRatePalettes := make([]_vkShadingRatePaletteNV, len(s.PShadingRatePalettes))
		for i, v := range s.PShadingRatePalettes {
			sl_pShadingRatePalettes[i] = *(v.Vulkanize())
		}
		psl_pShadingRatePalettes = &sl_pShadingRatePalettes[0]
	}
	rval := &_vkPipelineViewportShadingRateImageStateCreateInfoNV{
		sType:                  STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                                /*cb*/
		shadingRateImageEnable: translateInternal_Bool32(s.ShadingRateImageEnable),                       /*default*/
		viewportCount:          uint32(len(s.PShadingRatePalettes)),                                      /*c6-a*/
		pShadingRatePalettes:   psl_pShadingRatePalettes,                                                 /*c rem*/
	}
	return rval
}

// PipelineViewportStateCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateInfo.html
type PipelineViewportStateCreateInfo struct {
	// SType = STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
	PNext unsafe.Pointer
	Flags PipelineViewportStateCreateFlags
	// viewportCount
	PViewports []Viewport
	// scissorCount
	PScissors []Rect2D
}

type _vkPipelineViewportStateCreateInfo struct {
	sType         StructureType
	pNext         unsafe.Pointer
	flags         PipelineViewportStateCreateFlags
	viewportCount uint32
	pViewports    *_vkViewport
	scissorCount  uint32
	pScissors     *_vkRect2D
}

func (s *_vkPipelineViewportStateCreateInfo) Goify() *PipelineViewportStateCreateInfo {
	rval := &PipelineViewportStateCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PipelineViewportStateCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pViewports in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pScissors in returned struct
	}
	return rval
}
func (s *PipelineViewportStateCreateInfo) Vulkanize() *_vkPipelineViewportStateCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pViewports *_vkViewport
	if len(s.PViewports) > 0 {
		psl_pViewports = &s.PViewports[0]
	}

	var psl_pScissors *_vkRect2D
	if len(s.PScissors) > 0 {
		sl_pScissors := make([]_vkRect2D, len(s.PScissors))
		for i, v := range s.PScissors {
			sl_pScissors[i] = *(v.Vulkanize())
		}
		psl_pScissors = &sl_pScissors[0]
	}
	rval := &_vkPipelineViewportStateCreateInfo{
		sType:         STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                          /*cb*/
		flags:         (PipelineViewportStateCreateFlags)(s.Flags),        /*cb*/
		viewportCount: uint32(len(s.PViewports)),                          /*c6-a*/
		pViewports:    psl_pViewports,                                     /*c rem*/
		scissorCount:  uint32(len(s.PScissors)),                           /*c6-a*/
		pScissors:     psl_pScissors,                                      /*c rem*/
	}
	return rval
}

// PipelineViewportSwizzleStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html
type PipelineViewportSwizzleStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV
	PNext unsafe.Pointer
	Flags PipelineViewportSwizzleStateCreateFlagsNV
	// viewportCount
	PViewportSwizzles []ViewportSwizzleNV
}

type _vkPipelineViewportSwizzleStateCreateInfoNV struct {
	sType             StructureType
	pNext             unsafe.Pointer
	flags             PipelineViewportSwizzleStateCreateFlagsNV
	viewportCount     uint32
	pViewportSwizzles *_vkViewportSwizzleNV
}

func (s *_vkPipelineViewportSwizzleStateCreateInfoNV) Goify() *PipelineViewportSwizzleStateCreateInfoNV {
	rval := &PipelineViewportSwizzleStateCreateInfoNV{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PipelineViewportSwizzleStateCreateFlagsNV)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pViewportSwizzles in returned struct
	}
	return rval
}
func (s *PipelineViewportSwizzleStateCreateInfoNV) Vulkanize() *_vkPipelineViewportSwizzleStateCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pViewportSwizzles *_vkViewportSwizzleNV
	if len(s.PViewportSwizzles) > 0 {
		psl_pViewportSwizzles = &s.PViewportSwizzles[0]
	}
	rval := &_vkPipelineViewportSwizzleStateCreateInfoNV{
		sType:             STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                     /*cb*/
		flags:             (PipelineViewportSwizzleStateCreateFlagsNV)(s.Flags),          /*cb*/
		viewportCount:     uint32(len(s.PViewportSwizzles)),                              /*c6-a*/
		pViewportSwizzles: psl_pViewportSwizzles,                                         /*c rem*/
	}
	return rval
}

// PipelineViewportWScalingStateCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html
type PipelineViewportWScalingStateCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV
	PNext                  unsafe.Pointer
	ViewportWScalingEnable bool
	// viewportCount
	PViewportWScalings []ViewportWScalingNV
}

type _vkPipelineViewportWScalingStateCreateInfoNV struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	viewportWScalingEnable Bool32
	viewportCount          uint32
	pViewportWScalings     *_vkViewportWScalingNV
}

func (s *_vkPipelineViewportWScalingStateCreateInfoNV) Goify() *PipelineViewportWScalingStateCreateInfoNV {
	rval := &PipelineViewportWScalingStateCreateInfoNV{
		PNext:                  (unsafe.Pointer)(s.pNext),
		ViewportWScalingEnable: translatePublic_Bool32(s.viewportWScalingEnable), /*default*/
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pViewportWScalings in returned struct
	}
	return rval
}
func (s *PipelineViewportWScalingStateCreateInfoNV) Vulkanize() *_vkPipelineViewportWScalingStateCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pViewportWScalings *_vkViewportWScalingNV
	if len(s.PViewportWScalings) > 0 {
		psl_pViewportWScalings = &s.PViewportWScalings[0]
	}
	rval := &_vkPipelineViewportWScalingStateCreateInfoNV{
		sType:                  STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                                       /*cb*/
		viewportWScalingEnable: translateInternal_Bool32(s.ViewportWScalingEnable),              /*default*/
		viewportCount:          uint32(len(s.PViewportWScalings)),                               /*c6-a*/
		pViewportWScalings:     psl_pViewportWScalings,                                          /*c rem*/
	}
	return rval
}

// PresentIdKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentIdKHR.html
type PresentIdKHR struct {
	// SType = STRUCTURE_TYPE_PRESENT_ID_KHR
	PNext unsafe.Pointer
	//  Copy of VkPresentInfoKHR::swapchainCount;
	// swapchainCount
	//  Present ID values for each swapchain;
	PPresentIds []uint64
}

type _vkPresentIdKHR struct {
	sType          StructureType
	pNext          unsafe.Pointer
	swapchainCount uint32
	pPresentIds    *uint64
}

func (s *_vkPresentIdKHR) Goify() *PresentIdKHR {
	rval := &PresentIdKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPresentIds in returned struct
	}
	return rval
}
func (s *PresentIdKHR) Vulkanize() *_vkPresentIdKHR {
	if s == nil {
		return nil
	}

	var psl_pPresentIds *uint64
	if len(s.PPresentIds) > 0 {
		psl_pPresentIds = &s.PPresentIds[0]
	}
	rval := &_vkPresentIdKHR{
		sType:          STRUCTURE_TYPE_PRESENT_ID_KHR, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),     /*cb*/
		swapchainCount: uint32(len(s.PPresentIds)),    /*c6-a*/
		pPresentIds:    psl_pPresentIds,               /*c rem*/
	}
	return rval
}

// PresentInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentInfoKHR.html
type PresentInfoKHR struct {
	// SType = STRUCTURE_TYPE_PRESENT_INFO_KHR
	PNext unsafe.Pointer
	//  Number of semaphores to wait for before presenting;
	// waitSemaphoreCount
	//  Semaphores to wait for before presenting;
	PWaitSemaphores []Semaphore
	//  Number of swapchains to present in this call;
	// swapchainCount
	//  Swapchains to present an image from;
	PSwapchains []SwapchainKHR
	//  Indices of which presentable images to present;
	PImageIndices []uint32
	//  Optional (i.e. if non-NULL) VkResult for each swapchain;
	PResults []Result
}

type _vkPresentInfoKHR struct {
	sType              StructureType
	pNext              unsafe.Pointer
	waitSemaphoreCount uint32
	pWaitSemaphores    *Semaphore
	swapchainCount     uint32
	pSwapchains        *SwapchainKHR
	pImageIndices      *uint32
	pResults           *Result
}

func (s *_vkPresentInfoKHR) Goify() *PresentInfoKHR {
	rval := &PresentInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pWaitSemaphores in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSwapchains in returned struct
		// Unexpected pointer member pImageIndices in returned struct
		// Unexpected pointer member pResults in returned struct
	}
	return rval
}
func (s *PresentInfoKHR) Vulkanize() *_vkPresentInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pWaitSemaphores *Semaphore
	if len(s.PWaitSemaphores) > 0 {
		psl_pWaitSemaphores = &s.PWaitSemaphores[0]
	}

	var psl_pSwapchains *SwapchainKHR
	if len(s.PSwapchains) > 0 {
		psl_pSwapchains = &s.PSwapchains[0]
	}

	var psl_pImageIndices *uint32
	if len(s.PImageIndices) > 0 {
		psl_pImageIndices = &s.PImageIndices[0]
	}

	var psl_pResults *Result
	if len(s.PResults) > 0 {
		psl_pResults = &s.PResults[0]
	}
	rval := &_vkPresentInfoKHR{
		sType:              STRUCTURE_TYPE_PRESENT_INFO_KHR, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),       /*cb*/
		waitSemaphoreCount: uint32(len(s.PWaitSemaphores)),  /*c6-a*/
		pWaitSemaphores:    psl_pWaitSemaphores,             /*c rem*/
		pSwapchains:        psl_pSwapchains,                 /*c rem*/
		pImageIndices:      psl_pImageIndices,               /*c rem*/
		pResults:           psl_pResults,                    /*c rem*/
	}
	rval.swapchainCount = 0 // c6-b
	if uint32(len(s.PSwapchains)) > rval.swapchainCount {
		rval.swapchainCount = uint32(len(s.PSwapchains))
	}
	if uint32(len(s.PImageIndices)) > rval.swapchainCount {
		rval.swapchainCount = uint32(len(s.PImageIndices))
	}
	if uint32(len(s.PResults)) > rval.swapchainCount {
		rval.swapchainCount = uint32(len(s.PResults))
	}
	return rval
}

// PresentRegionKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionKHR.html
type PresentRegionKHR struct {
	//  Number of rectangles in pRectangles;
	// rectangleCount
	//  Array of rectangles that have changed in a swapchain's image(s);
	PRectangles []RectLayerKHR
}

type _vkPresentRegionKHR struct {
	rectangleCount uint32
	pRectangles    *_vkRectLayerKHR
}

func (s *_vkPresentRegionKHR) Goify() *PresentRegionKHR {
	rval := &PresentRegionKHR{
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRectangles in returned struct
	}
	return rval
}
func (s *PresentRegionKHR) Vulkanize() *_vkPresentRegionKHR {
	if s == nil {
		return nil
	}

	var psl_pRectangles *_vkRectLayerKHR
	if len(s.PRectangles) > 0 {
		sl_pRectangles := make([]_vkRectLayerKHR, len(s.PRectangles))
		for i, v := range s.PRectangles {
			sl_pRectangles[i] = *(v.Vulkanize())
		}
		psl_pRectangles = &sl_pRectangles[0]
	}
	rval := &_vkPresentRegionKHR{
		rectangleCount: uint32(len(s.PRectangles)), /*c6-a*/
		pRectangles:    psl_pRectangles,            /*c rem*/
	}
	return rval
}

// PresentRegionsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionsKHR.html
type PresentRegionsKHR struct {
	// SType = STRUCTURE_TYPE_PRESENT_REGIONS_KHR
	PNext unsafe.Pointer
	//  Copy of VkPresentInfoKHR::swapchainCount;
	// swapchainCount
	//  The regions that have changed;
	PRegions []PresentRegionKHR
}

type _vkPresentRegionsKHR struct {
	sType          StructureType
	pNext          unsafe.Pointer
	swapchainCount uint32
	pRegions       *_vkPresentRegionKHR
}

func (s *_vkPresentRegionsKHR) Goify() *PresentRegionsKHR {
	rval := &PresentRegionsKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *PresentRegionsKHR) Vulkanize() *_vkPresentRegionsKHR {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkPresentRegionKHR
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkPresentRegionKHR, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkPresentRegionsKHR{
		sType:          STRUCTURE_TYPE_PRESENT_REGIONS_KHR, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),          /*cb*/
		swapchainCount: uint32(len(s.PRegions)),            /*c6-a*/
		pRegions:       psl_pRegions,                       /*c rem*/
	}
	return rval
}

// PresentTimeGOOGLE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimeGOOGLE.html
type PresentTimeGOOGLE struct {
	//  Application-provided identifier;
	PresentID uint32
	//  Earliest time an image should be presented;
	DesiredPresentTime uint64
}

type _vkPresentTimeGOOGLE = PresentTimeGOOGLE

func (s *_vkPresentTimeGOOGLE) Goify() *PresentTimeGOOGLE {
	rval := (*PresentTimeGOOGLE)(s)
	return rval
}
func (s *PresentTimeGOOGLE) Vulkanize() *_vkPresentTimeGOOGLE {
	if s == nil {
		return nil
	}
	rval := (*_vkPresentTimeGOOGLE)(s)
	return rval
}

// PresentTimesInfoGOOGLE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimesInfoGOOGLE.html
type PresentTimesInfoGOOGLE struct {
	// SType = STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE
	PNext unsafe.Pointer
	//  Copy of VkPresentInfoKHR::swapchainCount;
	// swapchainCount
	//  The earliest times to present images;
	PTimes []PresentTimeGOOGLE
}

type _vkPresentTimesInfoGOOGLE struct {
	sType          StructureType
	pNext          unsafe.Pointer
	swapchainCount uint32
	pTimes         *_vkPresentTimeGOOGLE
}

func (s *_vkPresentTimesInfoGOOGLE) Goify() *PresentTimesInfoGOOGLE {
	rval := &PresentTimesInfoGOOGLE{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pTimes in returned struct
	}
	return rval
}
func (s *PresentTimesInfoGOOGLE) Vulkanize() *_vkPresentTimesInfoGOOGLE {
	if s == nil {
		return nil
	}

	var psl_pTimes *_vkPresentTimeGOOGLE
	if len(s.PTimes) > 0 {
		psl_pTimes = &s.PTimes[0]
	}
	rval := &_vkPresentTimesInfoGOOGLE{
		sType:          STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                /*cb*/
		swapchainCount: uint32(len(s.PTimes)),                    /*c6-a*/
		pTimes:         psl_pTimes,                               /*c rem*/
	}
	return rval
}

// PrivateDataSlotCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateInfo.html
type PrivateDataSlotCreateInfo struct {
	// SType = STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO
	PNext unsafe.Pointer
	Flags PrivateDataSlotCreateFlags
}

type _vkPrivateDataSlotCreateInfo struct {
	sType StructureType
	pNext unsafe.Pointer
	flags PrivateDataSlotCreateFlags
}

func (s *_vkPrivateDataSlotCreateInfo) Goify() *PrivateDataSlotCreateInfo {
	rval := &PrivateDataSlotCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PrivateDataSlotCreateFlags)(s.flags),
	}
	return rval
}
func (s *PrivateDataSlotCreateInfo) Vulkanize() *_vkPrivateDataSlotCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkPrivateDataSlotCreateInfo{
		sType: STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                    /*cb*/
		flags: (PrivateDataSlotCreateFlags)(s.Flags),        /*cb*/
	}
	return rval
}

// PrivateDataSlotCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateInfoEXT.html
type PrivateDataSlotCreateInfoEXT struct {
}

type _vkPrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfoEXT

func (s *_vkPrivateDataSlotCreateInfoEXT) Goify() *PrivateDataSlotCreateInfoEXT {
	rval := (*PrivateDataSlotCreateInfoEXT)(s)
	return rval
}
func (s *PrivateDataSlotCreateInfoEXT) Vulkanize() *_vkPrivateDataSlotCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkPrivateDataSlotCreateInfoEXT)(s)
	return rval
}

// ProtectedSubmitInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkProtectedSubmitInfo.html
type ProtectedSubmitInfo struct {
	// SType = STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO
	PNext unsafe.Pointer
	//  Submit protected command buffers;
	ProtectedSubmit bool
}

type _vkProtectedSubmitInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	protectedSubmit Bool32
}

func (s *_vkProtectedSubmitInfo) Goify() *ProtectedSubmitInfo {
	rval := &ProtectedSubmitInfo{
		PNext:           (unsafe.Pointer)(s.pNext),
		ProtectedSubmit: translatePublic_Bool32(s.protectedSubmit), /*default*/
	}
	return rval
}
func (s *ProtectedSubmitInfo) Vulkanize() *_vkProtectedSubmitInfo {
	if s == nil {
		return nil
	}
	rval := &_vkProtectedSubmitInfo{
		sType:           STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO,        /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                   /*cb*/
		protectedSubmit: translateInternal_Bool32(s.ProtectedSubmit), /*default*/
	}
	return rval
}

// PushConstantRange: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPushConstantRange.html
type PushConstantRange struct {
	//  Which stages use the range;
	StageFlags ShaderStageFlags
	//  Start of the range, in bytes;
	Offset uint32
	//  Size of the range, in bytes;
	Size uint32
}

type _vkPushConstantRange = PushConstantRange

func (s *_vkPushConstantRange) Goify() *PushConstantRange {
	rval := (*PushConstantRange)(s)
	return rval
}
func (s *PushConstantRange) Vulkanize() *_vkPushConstantRange {
	if s == nil {
		return nil
	}
	rval := (*_vkPushConstantRange)(s)
	return rval
}

// QueryLowLatencySupportNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryLowLatencySupportNV.html
type QueryLowLatencySupportNV struct {
	// SType = STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV
	PNext                  unsafe.Pointer
	PQueriedLowLatencyData unsafe.Pointer
}

type _vkQueryLowLatencySupportNV struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	pQueriedLowLatencyData unsafe.Pointer
}

func (s *_vkQueryLowLatencySupportNV) Goify() *QueryLowLatencySupportNV {
	rval := &QueryLowLatencySupportNV{
		PNext:                  (unsafe.Pointer)(s.pNext),
		PQueriedLowLatencyData: (unsafe.Pointer)(s.pQueriedLowLatencyData),
	}
	return rval
}
func (s *QueryLowLatencySupportNV) Vulkanize() *_vkQueryLowLatencySupportNV {
	if s == nil {
		return nil
	}
	rval := &_vkQueryLowLatencySupportNV{
		sType:                  STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                   /*cb*/
		pQueriedLowLatencyData: (unsafe.Pointer)(s.PQueriedLowLatencyData),  /*cb*/
	}
	return rval
}

// QueryPoolCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateInfo.html
type QueryPoolCreateInfo struct {
	// SType = STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
	PNext      unsafe.Pointer
	Flags      QueryPoolCreateFlags
	QueryType  QueryType
	QueryCount uint32
	//  Optional;
	PipelineStatistics QueryPipelineStatisticFlags
}

type _vkQueryPoolCreateInfo struct {
	sType              StructureType
	pNext              unsafe.Pointer
	flags              QueryPoolCreateFlags
	queryType          QueryType
	queryCount         uint32
	pipelineStatistics QueryPipelineStatisticFlags
}

func (s *_vkQueryPoolCreateInfo) Goify() *QueryPoolCreateInfo {
	rval := &QueryPoolCreateInfo{
		PNext:              (unsafe.Pointer)(s.pNext),
		Flags:              (QueryPoolCreateFlags)(s.flags),
		QueryType:          (QueryType)(s.queryType),
		QueryCount:         (uint32)(s.queryCount),
		PipelineStatistics: (QueryPipelineStatisticFlags)(s.pipelineStatistics),
	}
	return rval
}
func (s *QueryPoolCreateInfo) Vulkanize() *_vkQueryPoolCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkQueryPoolCreateInfo{
		sType:              STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,               /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                           /*cb*/
		flags:              (QueryPoolCreateFlags)(s.Flags),                     /*cb*/
		queryType:          (QueryType)(s.QueryType),                            /*cb*/
		queryCount:         (uint32)(s.QueryCount),                              /*cb*/
		pipelineStatistics: (QueryPipelineStatisticFlags)(s.PipelineStatistics), /*cb*/
	}
	return rval
}

// QueryPoolCreateInfoINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateInfoINTEL.html
type QueryPoolCreateInfoINTEL struct {
}

type _vkQueryPoolCreateInfoINTEL = QueryPoolCreateInfoINTEL

func (s *_vkQueryPoolCreateInfoINTEL) Goify() *QueryPoolCreateInfoINTEL {
	rval := (*QueryPoolCreateInfoINTEL)(s)
	return rval
}
func (s *QueryPoolCreateInfoINTEL) Vulkanize() *_vkQueryPoolCreateInfoINTEL {
	if s == nil {
		return nil
	}
	rval := (*_vkQueryPoolCreateInfoINTEL)(s)
	return rval
}

// QueryPoolPerformanceCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceCreateInfoKHR.html
type QueryPoolPerformanceCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR
	PNext            unsafe.Pointer
	QueueFamilyIndex uint32
	// counterIndexCount
	PCounterIndices []uint32
}

type _vkQueryPoolPerformanceCreateInfoKHR struct {
	sType             StructureType
	pNext             unsafe.Pointer
	queueFamilyIndex  uint32
	counterIndexCount uint32
	pCounterIndices   *uint32
}

func (s *_vkQueryPoolPerformanceCreateInfoKHR) Goify() *QueryPoolPerformanceCreateInfoKHR {
	rval := &QueryPoolPerformanceCreateInfoKHR{
		PNext:            (unsafe.Pointer)(s.pNext),
		QueueFamilyIndex: (uint32)(s.queueFamilyIndex),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCounterIndices in returned struct
	}
	return rval
}
func (s *QueryPoolPerformanceCreateInfoKHR) Vulkanize() *_vkQueryPoolPerformanceCreateInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pCounterIndices *uint32
	if len(s.PCounterIndices) > 0 {
		psl_pCounterIndices = &s.PCounterIndices[0]
	}
	rval := &_vkQueryPoolPerformanceCreateInfoKHR{
		sType:             STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                             /*cb*/
		queueFamilyIndex:  (uint32)(s.QueueFamilyIndex),                          /*cb*/
		counterIndexCount: uint32(len(s.PCounterIndices)),                        /*c6-a*/
		pCounterIndices:   psl_pCounterIndices,                                   /*c rem*/
	}
	return rval
}

// QueryPoolPerformanceQueryCreateInfoINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html
type QueryPoolPerformanceQueryCreateInfoINTEL struct {
	// SType = STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL
	PNext                       unsafe.Pointer
	PerformanceCountersSampling QueryPoolSamplingModeINTEL
}

type _vkQueryPoolPerformanceQueryCreateInfoINTEL struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	performanceCountersSampling QueryPoolSamplingModeINTEL
}

func (s *_vkQueryPoolPerformanceQueryCreateInfoINTEL) Goify() *QueryPoolPerformanceQueryCreateInfoINTEL {
	rval := &QueryPoolPerformanceQueryCreateInfoINTEL{
		PNext:                       (unsafe.Pointer)(s.pNext),
		PerformanceCountersSampling: (QueryPoolSamplingModeINTEL)(s.performanceCountersSampling),
	}
	return rval
}
func (s *QueryPoolPerformanceQueryCreateInfoINTEL) Vulkanize() *_vkQueryPoolPerformanceQueryCreateInfoINTEL {
	if s == nil {
		return nil
	}
	rval := &_vkQueryPoolPerformanceQueryCreateInfoINTEL{
		sType:                       STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                                     /*cb*/
		performanceCountersSampling: (QueryPoolSamplingModeINTEL)(s.PerformanceCountersSampling),   /*cb*/
	}
	return rval
}

// QueueFamilyCheckpointProperties2NV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointProperties2NV.html
type QueueFamilyCheckpointProperties2NV struct {
	// SType = STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV
	PNext                        unsafe.Pointer
	CheckpointExecutionStageMask PipelineStageFlags2
}

// WARNING - struct QueueFamilyCheckpointProperties2NV is returned only, which is not yet handled in the binding
type _vkQueueFamilyCheckpointProperties2NV struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	checkpointExecutionStageMask PipelineStageFlags2
}

func (s *_vkQueueFamilyCheckpointProperties2NV) Goify() *QueueFamilyCheckpointProperties2NV {
	rval := &QueueFamilyCheckpointProperties2NV{
		PNext:                        (unsafe.Pointer)(s.pNext),
		CheckpointExecutionStageMask: (PipelineStageFlags2)(s.checkpointExecutionStageMask),
	}
	return rval
}
func (s *QueueFamilyCheckpointProperties2NV) Vulkanize() *_vkQueueFamilyCheckpointProperties2NV {
	if s == nil {
		return nil
	}
	rval := &_vkQueueFamilyCheckpointProperties2NV{
		sType:                        STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                              /*cb*/
		checkpointExecutionStageMask: (PipelineStageFlags2)(s.CheckpointExecutionStageMask),  /*cb*/
	}
	return rval
}

// QueueFamilyCheckpointPropertiesNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointPropertiesNV.html
type QueueFamilyCheckpointPropertiesNV struct {
	// SType = STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV
	PNext                        unsafe.Pointer
	CheckpointExecutionStageMask PipelineStageFlags
}

// WARNING - struct QueueFamilyCheckpointPropertiesNV is returned only, which is not yet handled in the binding
type _vkQueueFamilyCheckpointPropertiesNV struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	checkpointExecutionStageMask PipelineStageFlags
}

func (s *_vkQueueFamilyCheckpointPropertiesNV) Goify() *QueueFamilyCheckpointPropertiesNV {
	rval := &QueueFamilyCheckpointPropertiesNV{
		PNext:                        (unsafe.Pointer)(s.pNext),
		CheckpointExecutionStageMask: (PipelineStageFlags)(s.checkpointExecutionStageMask),
	}
	return rval
}
func (s *QueueFamilyCheckpointPropertiesNV) Vulkanize() *_vkQueueFamilyCheckpointPropertiesNV {
	if s == nil {
		return nil
	}
	rval := &_vkQueueFamilyCheckpointPropertiesNV{
		sType:                        STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                            /*cb*/
		checkpointExecutionStageMask: (PipelineStageFlags)(s.CheckpointExecutionStageMask), /*cb*/
	}
	return rval
}

// QueueFamilyGlobalPriorityPropertiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyGlobalPriorityPropertiesEXT.html
type QueueFamilyGlobalPriorityPropertiesEXT struct {
}

type _vkQueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesEXT

func (s *_vkQueueFamilyGlobalPriorityPropertiesEXT) Goify() *QueueFamilyGlobalPriorityPropertiesEXT {
	rval := (*QueueFamilyGlobalPriorityPropertiesEXT)(s)
	return rval
}
func (s *QueueFamilyGlobalPriorityPropertiesEXT) Vulkanize() *_vkQueueFamilyGlobalPriorityPropertiesEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkQueueFamilyGlobalPriorityPropertiesEXT)(s)
	return rval
}

// QueueFamilyGlobalPriorityPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyGlobalPriorityPropertiesKHR.html
type QueueFamilyGlobalPriorityPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR
	PNext         unsafe.Pointer
	PriorityCount uint32
	Priorities    [MAX_GLOBAL_PRIORITY_SIZE_KHR]QueueGlobalPriorityKHR
}

type _vkQueueFamilyGlobalPriorityPropertiesKHR struct {
	sType         StructureType
	pNext         unsafe.Pointer
	priorityCount uint32
	priorities    [MAX_GLOBAL_PRIORITY_SIZE_KHR]QueueGlobalPriorityKHR
}

func (s *_vkQueueFamilyGlobalPriorityPropertiesKHR) Goify() *QueueFamilyGlobalPriorityPropertiesKHR {
	rval := &QueueFamilyGlobalPriorityPropertiesKHR{
		PNext:         (unsafe.Pointer)(s.pNext),
		PriorityCount: (uint32)(s.priorityCount),
		Priorities:    ([MAX_GLOBAL_PRIORITY_SIZE_KHR]QueueGlobalPriorityKHR)(s.priorities),
	}
	return rval
}
func (s *QueueFamilyGlobalPriorityPropertiesKHR) Vulkanize() *_vkQueueFamilyGlobalPriorityPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkQueueFamilyGlobalPriorityPropertiesKHR{
		sType:         STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR,           /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                            /*cb*/
		priorityCount: (uint32)(s.PriorityCount),                                            /*cb*/
		priorities:    ([MAX_GLOBAL_PRIORITY_SIZE_KHR]QueueGlobalPriorityKHR)(s.Priorities), /*cb*/
	}
	return rval
}

// QueueFamilyProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties.html
type QueueFamilyProperties struct {
	//  Queue flags;
	QueueFlags         QueueFlags
	QueueCount         uint32
	TimestampValidBits uint32
	//  Minimum alignment requirement for image transfers;
	MinImageTransferGranularity Extent3D
}

// WARNING - struct QueueFamilyProperties is returned only, which is not yet handled in the binding
type _vkQueueFamilyProperties struct {
	queueFlags                  QueueFlags
	queueCount                  uint32
	timestampValidBits          uint32
	minImageTransferGranularity _vkExtent3D
}

func (s *_vkQueueFamilyProperties) Goify() *QueueFamilyProperties {
	rval := &QueueFamilyProperties{
		QueueFlags:                  (QueueFlags)(s.queueFlags),
		QueueCount:                  (uint32)(s.queueCount),
		TimestampValidBits:          (uint32)(s.timestampValidBits),
		MinImageTransferGranularity: (Extent3D)(s.minImageTransferGranularity),
	}
	return rval
}
func (s *QueueFamilyProperties) Vulkanize() *_vkQueueFamilyProperties {
	if s == nil {
		return nil
	}
	rval := &_vkQueueFamilyProperties{
		queueFlags:                  (QueueFlags)(s.QueueFlags),                   /*cb*/
		queueCount:                  (uint32)(s.QueueCount),                       /*cb*/
		timestampValidBits:          (uint32)(s.TimestampValidBits),               /*cb*/
		minImageTransferGranularity: (_vkExtent3D)(s.MinImageTransferGranularity), /*cb*/
	}
	return rval
}

// QueueFamilyProperties2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties2.html
type QueueFamilyProperties2 struct {
	// SType = STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2
	PNext                 unsafe.Pointer
	QueueFamilyProperties QueueFamilyProperties
}

// WARNING - struct QueueFamilyProperties2 is returned only, which is not yet handled in the binding
type _vkQueueFamilyProperties2 struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	queueFamilyProperties _vkQueueFamilyProperties
}

func (s *_vkQueueFamilyProperties2) Goify() *QueueFamilyProperties2 {
	rval := &QueueFamilyProperties2{
		PNext:                 (unsafe.Pointer)(s.pNext),
		QueueFamilyProperties: *(s.queueFamilyProperties.Goify()),
	}
	return rval
}
func (s *QueueFamilyProperties2) Vulkanize() *_vkQueueFamilyProperties2 {
	if s == nil {
		return nil
	}
	rval := &_vkQueueFamilyProperties2{
		sType:                 STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                /*cb*/
		queueFamilyProperties: *(s.QueueFamilyProperties.Vulkanize()),   /*c3*/
	}
	return rval
}

// QueueFamilyProperties2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties2KHR.html
type QueueFamilyProperties2KHR struct {
}

type _vkQueueFamilyProperties2KHR = QueueFamilyProperties2KHR

func (s *_vkQueueFamilyProperties2KHR) Goify() *QueueFamilyProperties2KHR {
	rval := (*QueueFamilyProperties2KHR)(s)
	return rval
}
func (s *QueueFamilyProperties2KHR) Vulkanize() *_vkQueueFamilyProperties2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkQueueFamilyProperties2KHR)(s)
	return rval
}

// QueueFamilyQueryResultStatusPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyQueryResultStatusPropertiesKHR.html
type QueueFamilyQueryResultStatusPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR
	PNext                    unsafe.Pointer
	QueryResultStatusSupport bool
}

// WARNING - struct QueueFamilyQueryResultStatusPropertiesKHR is returned only, which is not yet handled in the binding
type _vkQueueFamilyQueryResultStatusPropertiesKHR struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	queryResultStatusSupport Bool32
}

func (s *_vkQueueFamilyQueryResultStatusPropertiesKHR) Goify() *QueueFamilyQueryResultStatusPropertiesKHR {
	rval := &QueueFamilyQueryResultStatusPropertiesKHR{
		PNext:                    (unsafe.Pointer)(s.pNext),
		QueryResultStatusSupport: translatePublic_Bool32(s.queryResultStatusSupport), /*default*/
	}
	return rval
}
func (s *QueueFamilyQueryResultStatusPropertiesKHR) Vulkanize() *_vkQueueFamilyQueryResultStatusPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkQueueFamilyQueryResultStatusPropertiesKHR{
		sType:                    STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                                      /*cb*/
		queryResultStatusSupport: translateInternal_Bool32(s.QueryResultStatusSupport),           /*default*/
	}
	return rval
}

// QueueFamilyVideoPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyVideoPropertiesKHR.html
type QueueFamilyVideoPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR
	PNext                unsafe.Pointer
	VideoCodecOperations VideoCodecOperationFlagsKHR
}

// WARNING - struct QueueFamilyVideoPropertiesKHR is returned only, which is not yet handled in the binding
type _vkQueueFamilyVideoPropertiesKHR struct {
	sType                StructureType
	pNext                unsafe.Pointer
	videoCodecOperations VideoCodecOperationFlagsKHR
}

func (s *_vkQueueFamilyVideoPropertiesKHR) Goify() *QueueFamilyVideoPropertiesKHR {
	rval := &QueueFamilyVideoPropertiesKHR{
		PNext:                (unsafe.Pointer)(s.pNext),
		VideoCodecOperations: (VideoCodecOperationFlagsKHR)(s.videoCodecOperations),
	}
	return rval
}
func (s *QueueFamilyVideoPropertiesKHR) Vulkanize() *_vkQueueFamilyVideoPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkQueueFamilyVideoPropertiesKHR{
		sType:                STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR,      /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                             /*cb*/
		videoCodecOperations: (VideoCodecOperationFlagsKHR)(s.VideoCodecOperations), /*cb*/
	}
	return rval
}

// RayTracingPipelineCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoKHR.html
type RayTracingPipelineCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR
	PNext unsafe.Pointer
	//  Pipeline creation flags;
	Flags PipelineCreateFlags
	// stageCount
	//  One entry for each active shader stage;
	PStages []PipelineShaderStageCreateInfo
	// groupCount
	PGroups                      []RayTracingShaderGroupCreateInfoKHR
	MaxPipelineRayRecursionDepth uint32
	PLibraryInfo                 *PipelineLibraryCreateInfoKHR
	PLibraryInterface            *RayTracingPipelineInterfaceCreateInfoKHR
	PDynamicState                *PipelineDynamicStateCreateInfo
	//  Interface layout of the pipeline;
	Layout PipelineLayout
	//  If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of;
	BasePipelineHandle Pipeline
	//  If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of;
	BasePipelineIndex int32
}

type _vkRayTracingPipelineCreateInfoKHR struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	flags                        PipelineCreateFlags
	stageCount                   uint32
	pStages                      *_vkPipelineShaderStageCreateInfo
	groupCount                   uint32
	pGroups                      *_vkRayTracingShaderGroupCreateInfoKHR
	maxPipelineRayRecursionDepth uint32
	pLibraryInfo                 *_vkPipelineLibraryCreateInfoKHR
	pLibraryInterface            *_vkRayTracingPipelineInterfaceCreateInfoKHR
	pDynamicState                *_vkPipelineDynamicStateCreateInfo
	layout                       PipelineLayout
	basePipelineHandle           Pipeline
	basePipelineIndex            int32
}

func (s *_vkRayTracingPipelineCreateInfoKHR) Goify() *RayTracingPipelineCreateInfoKHR {
	rval := &RayTracingPipelineCreateInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PipelineCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStages in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pGroups in returned struct
		MaxPipelineRayRecursionDepth: (uint32)(s.maxPipelineRayRecursionDepth),
		// Unexpected pointer member pLibraryInfo in returned struct
		// Unexpected pointer member pLibraryInterface in returned struct
		// Unexpected pointer member pDynamicState in returned struct
		Layout:             (PipelineLayout)(s.layout),
		BasePipelineHandle: (Pipeline)(s.basePipelineHandle),
		BasePipelineIndex:  (int32)(s.basePipelineIndex),
	}
	return rval
}
func (s *RayTracingPipelineCreateInfoKHR) Vulkanize() *_vkRayTracingPipelineCreateInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pStages *_vkPipelineShaderStageCreateInfo
	if len(s.PStages) > 0 {
		sl_pStages := make([]_vkPipelineShaderStageCreateInfo, len(s.PStages))
		for i, v := range s.PStages {
			sl_pStages[i] = *(v.Vulkanize())
		}
		psl_pStages = &sl_pStages[0]
	}

	var psl_pGroups *_vkRayTracingShaderGroupCreateInfoKHR
	if len(s.PGroups) > 0 {
		sl_pGroups := make([]_vkRayTracingShaderGroupCreateInfoKHR, len(s.PGroups))
		for i, v := range s.PGroups {
			sl_pGroups[i] = *(v.Vulkanize())
		}
		psl_pGroups = &sl_pGroups[0]
	}
	rval := &_vkRayTracingPipelineCreateInfoKHR{
		sType:                        STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                           /*cb*/
		flags:                        (PipelineCreateFlags)(s.Flags),                      /*cb*/
		stageCount:                   uint32(len(s.PStages)),                              /*c6-a*/
		pStages:                      psl_pStages,                                         /*c rem*/
		groupCount:                   uint32(len(s.PGroups)),                              /*c6-a*/
		pGroups:                      psl_pGroups,                                         /*c rem*/
		maxPipelineRayRecursionDepth: (uint32)(s.MaxPipelineRayRecursionDepth),            /*cb*/
		pLibraryInfo:                 (s.PLibraryInfo.Vulkanize()),                        /*c rem*/
		pLibraryInterface:            (s.PLibraryInterface.Vulkanize()),                   /*c rem*/
		pDynamicState:                (s.PDynamicState.Vulkanize()),                       /*c rem*/
		layout:                       (PipelineLayout)(s.Layout),                          /*cb*/
		basePipelineHandle:           (Pipeline)(s.BasePipelineHandle),                    /*cb*/
		basePipelineIndex:            (int32)(s.BasePipelineIndex),                        /*cb*/
	}
	return rval
}

// RayTracingPipelineCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoNV.html
type RayTracingPipelineCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV
	PNext unsafe.Pointer
	//  Pipeline creation flags;
	Flags PipelineCreateFlags
	// stageCount
	//  One entry for each active shader stage;
	PStages []PipelineShaderStageCreateInfo
	// groupCount
	PGroups           []RayTracingShaderGroupCreateInfoNV
	MaxRecursionDepth uint32
	//  Interface layout of the pipeline;
	Layout PipelineLayout
	//  If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of;
	BasePipelineHandle Pipeline
	//  If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of;
	BasePipelineIndex int32
}

type _vkRayTracingPipelineCreateInfoNV struct {
	sType              StructureType
	pNext              unsafe.Pointer
	flags              PipelineCreateFlags
	stageCount         uint32
	pStages            *_vkPipelineShaderStageCreateInfo
	groupCount         uint32
	pGroups            *_vkRayTracingShaderGroupCreateInfoNV
	maxRecursionDepth  uint32
	layout             PipelineLayout
	basePipelineHandle Pipeline
	basePipelineIndex  int32
}

func (s *_vkRayTracingPipelineCreateInfoNV) Goify() *RayTracingPipelineCreateInfoNV {
	rval := &RayTracingPipelineCreateInfoNV{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (PipelineCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStages in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pGroups in returned struct
		MaxRecursionDepth:  (uint32)(s.maxRecursionDepth),
		Layout:             (PipelineLayout)(s.layout),
		BasePipelineHandle: (Pipeline)(s.basePipelineHandle),
		BasePipelineIndex:  (int32)(s.basePipelineIndex),
	}
	return rval
}
func (s *RayTracingPipelineCreateInfoNV) Vulkanize() *_vkRayTracingPipelineCreateInfoNV {
	if s == nil {
		return nil
	}

	var psl_pStages *_vkPipelineShaderStageCreateInfo
	if len(s.PStages) > 0 {
		sl_pStages := make([]_vkPipelineShaderStageCreateInfo, len(s.PStages))
		for i, v := range s.PStages {
			sl_pStages[i] = *(v.Vulkanize())
		}
		psl_pStages = &sl_pStages[0]
	}

	var psl_pGroups *_vkRayTracingShaderGroupCreateInfoNV
	if len(s.PGroups) > 0 {
		sl_pGroups := make([]_vkRayTracingShaderGroupCreateInfoNV, len(s.PGroups))
		for i, v := range s.PGroups {
			sl_pGroups[i] = *(v.Vulkanize())
		}
		psl_pGroups = &sl_pGroups[0]
	}
	rval := &_vkRayTracingPipelineCreateInfoNV{
		sType:              STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                          /*cb*/
		flags:              (PipelineCreateFlags)(s.Flags),                     /*cb*/
		stageCount:         uint32(len(s.PStages)),                             /*c6-a*/
		pStages:            psl_pStages,                                        /*c rem*/
		groupCount:         uint32(len(s.PGroups)),                             /*c6-a*/
		pGroups:            psl_pGroups,                                        /*c rem*/
		maxRecursionDepth:  (uint32)(s.MaxRecursionDepth),                      /*cb*/
		layout:             (PipelineLayout)(s.Layout),                         /*cb*/
		basePipelineHandle: (Pipeline)(s.BasePipelineHandle),                   /*cb*/
		basePipelineIndex:  (int32)(s.BasePipelineIndex),                       /*cb*/
	}
	return rval
}

// RayTracingPipelineInterfaceCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html
type RayTracingPipelineInterfaceCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR
	PNext                          unsafe.Pointer
	MaxPipelineRayPayloadSize      uint32
	MaxPipelineRayHitAttributeSize uint32
}

type _vkRayTracingPipelineInterfaceCreateInfoKHR struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	maxPipelineRayPayloadSize      uint32
	maxPipelineRayHitAttributeSize uint32
}

func (s *_vkRayTracingPipelineInterfaceCreateInfoKHR) Goify() *RayTracingPipelineInterfaceCreateInfoKHR {
	rval := &RayTracingPipelineInterfaceCreateInfoKHR{
		PNext:                          (unsafe.Pointer)(s.pNext),
		MaxPipelineRayPayloadSize:      (uint32)(s.maxPipelineRayPayloadSize),
		MaxPipelineRayHitAttributeSize: (uint32)(s.maxPipelineRayHitAttributeSize),
	}
	return rval
}
func (s *RayTracingPipelineInterfaceCreateInfoKHR) Vulkanize() *_vkRayTracingPipelineInterfaceCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkRayTracingPipelineInterfaceCreateInfoKHR{
		sType:                          STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR, /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                     /*cb*/
		maxPipelineRayPayloadSize:      (uint32)(s.MaxPipelineRayPayloadSize),                         /*cb*/
		maxPipelineRayHitAttributeSize: (uint32)(s.MaxPipelineRayHitAttributeSize),                    /*cb*/
	}
	return rval
}

// RayTracingShaderGroupCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoKHR.html
type RayTracingShaderGroupCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR
	PNext                           unsafe.Pointer
	Typ                             RayTracingShaderGroupTypeKHR
	GeneralShader                   uint32
	ClosestHitShader                uint32
	AnyHitShader                    uint32
	IntersectionShader              uint32
	PShaderGroupCaptureReplayHandle unsafe.Pointer
}

type _vkRayTracingShaderGroupCreateInfoKHR struct {
	sType                           StructureType
	pNext                           unsafe.Pointer
	typ                             RayTracingShaderGroupTypeKHR
	generalShader                   uint32
	closestHitShader                uint32
	anyHitShader                    uint32
	intersectionShader              uint32
	pShaderGroupCaptureReplayHandle unsafe.Pointer
}

func (s *_vkRayTracingShaderGroupCreateInfoKHR) Goify() *RayTracingShaderGroupCreateInfoKHR {
	rval := &RayTracingShaderGroupCreateInfoKHR{
		PNext:                           (unsafe.Pointer)(s.pNext),
		Typ:                             (RayTracingShaderGroupTypeKHR)(s.typ),
		GeneralShader:                   (uint32)(s.generalShader),
		ClosestHitShader:                (uint32)(s.closestHitShader),
		AnyHitShader:                    (uint32)(s.anyHitShader),
		IntersectionShader:              (uint32)(s.intersectionShader),
		PShaderGroupCaptureReplayHandle: (unsafe.Pointer)(s.pShaderGroupCaptureReplayHandle),
	}
	return rval
}
func (s *RayTracingShaderGroupCreateInfoKHR) Vulkanize() *_vkRayTracingShaderGroupCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkRayTracingShaderGroupCreateInfoKHR{
		sType:                           STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR, /*c1*/
		pNext:                           (unsafe.Pointer)(s.PNext),                               /*cb*/
		typ:                             (RayTracingShaderGroupTypeKHR)(s.Typ),                   /*cb*/
		generalShader:                   (uint32)(s.GeneralShader),                               /*cb*/
		closestHitShader:                (uint32)(s.ClosestHitShader),                            /*cb*/
		anyHitShader:                    (uint32)(s.AnyHitShader),                                /*cb*/
		intersectionShader:              (uint32)(s.IntersectionShader),                          /*cb*/
		pShaderGroupCaptureReplayHandle: (unsafe.Pointer)(s.PShaderGroupCaptureReplayHandle),     /*cb*/
	}
	return rval
}

// RayTracingShaderGroupCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoNV.html
type RayTracingShaderGroupCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV
	PNext              unsafe.Pointer
	Typ                RayTracingShaderGroupTypeKHR
	GeneralShader      uint32
	ClosestHitShader   uint32
	AnyHitShader       uint32
	IntersectionShader uint32
}

type _vkRayTracingShaderGroupCreateInfoNV struct {
	sType              StructureType
	pNext              unsafe.Pointer
	typ                RayTracingShaderGroupTypeKHR
	generalShader      uint32
	closestHitShader   uint32
	anyHitShader       uint32
	intersectionShader uint32
}

func (s *_vkRayTracingShaderGroupCreateInfoNV) Goify() *RayTracingShaderGroupCreateInfoNV {
	rval := &RayTracingShaderGroupCreateInfoNV{
		PNext:              (unsafe.Pointer)(s.pNext),
		Typ:                (RayTracingShaderGroupTypeKHR)(s.typ),
		GeneralShader:      (uint32)(s.generalShader),
		ClosestHitShader:   (uint32)(s.closestHitShader),
		AnyHitShader:       (uint32)(s.anyHitShader),
		IntersectionShader: (uint32)(s.intersectionShader),
	}
	return rval
}
func (s *RayTracingShaderGroupCreateInfoNV) Vulkanize() *_vkRayTracingShaderGroupCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkRayTracingShaderGroupCreateInfoNV{
		sType:              STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                              /*cb*/
		typ:                (RayTracingShaderGroupTypeKHR)(s.Typ),                  /*cb*/
		generalShader:      (uint32)(s.GeneralShader),                              /*cb*/
		closestHitShader:   (uint32)(s.ClosestHitShader),                           /*cb*/
		anyHitShader:       (uint32)(s.AnyHitShader),                               /*cb*/
		intersectionShader: (uint32)(s.IntersectionShader),                         /*cb*/
	}
	return rval
}

// Rect2D: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRect2D.html
type Rect2D struct {
	Offset Offset2D
	Extent Extent2D
}

type _vkRect2D struct {
	offset _vkOffset2D
	extent _vkExtent2D
}

func (s *_vkRect2D) Goify() *Rect2D {
	rval := &Rect2D{
		Offset: (Offset2D)(s.offset),
		Extent: (Extent2D)(s.extent),
	}
	return rval
}
func (s *Rect2D) Vulkanize() *_vkRect2D {
	if s == nil {
		return nil
	}
	rval := &_vkRect2D{
		offset: (_vkOffset2D)(s.Offset), /*cb*/
		extent: (_vkExtent2D)(s.Extent), /*cb*/
	}
	return rval
}

// RectLayerKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRectLayerKHR.html
type RectLayerKHR struct {
	//  upper-left corner of a rectangle that has not changed, in pixels of a presentation images;
	Offset Offset2D
	//  Dimensions of a rectangle that has not changed, in pixels of a presentation images;
	Extent Extent2D
	//  Layer of a swapchain's image(s), for stereoscopic-3D images;
	Layer uint32
}

type _vkRectLayerKHR struct {
	offset _vkOffset2D
	extent _vkExtent2D
	layer  uint32
}

func (s *_vkRectLayerKHR) Goify() *RectLayerKHR {
	rval := &RectLayerKHR{
		Offset: (Offset2D)(s.offset),
		Extent: (Extent2D)(s.extent),
		Layer:  (uint32)(s.layer),
	}
	return rval
}
func (s *RectLayerKHR) Vulkanize() *_vkRectLayerKHR {
	if s == nil {
		return nil
	}
	rval := &_vkRectLayerKHR{
		offset: (_vkOffset2D)(s.Offset), /*cb*/
		extent: (_vkExtent2D)(s.Extent), /*cb*/
		layer:  (uint32)(s.Layer),       /*cb*/
	}
	return rval
}

// RefreshCycleDurationGOOGLE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRefreshCycleDurationGOOGLE.html
type RefreshCycleDurationGOOGLE struct {
	//  Number of nanoseconds from the start of one refresh cycle to the next;
	RefreshDuration uint64
}

type _vkRefreshCycleDurationGOOGLE = RefreshCycleDurationGOOGLE

func (s *_vkRefreshCycleDurationGOOGLE) Goify() *RefreshCycleDurationGOOGLE {
	rval := (*RefreshCycleDurationGOOGLE)(s)
	return rval
}
func (s *RefreshCycleDurationGOOGLE) Vulkanize() *_vkRefreshCycleDurationGOOGLE {
	if s == nil {
		return nil
	}
	rval := (*_vkRefreshCycleDurationGOOGLE)(s)
	return rval
}

// RefreshObjectKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRefreshObjectKHR.html
type RefreshObjectKHR struct {
	ObjectType   ObjectType
	ObjectHandle uint64
	Flags        RefreshObjectFlagsKHR
}

type _vkRefreshObjectKHR = RefreshObjectKHR

func (s *_vkRefreshObjectKHR) Goify() *RefreshObjectKHR {
	rval := (*RefreshObjectKHR)(s)
	return rval
}
func (s *RefreshObjectKHR) Vulkanize() *_vkRefreshObjectKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkRefreshObjectKHR)(s)
	return rval
}

// RefreshObjectListKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRefreshObjectListKHR.html
type RefreshObjectListKHR struct {
	// SType = STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR
	PNext unsafe.Pointer
	// objectCount
	PObjects []RefreshObjectKHR
}

type _vkRefreshObjectListKHR struct {
	sType       StructureType
	pNext       unsafe.Pointer
	objectCount uint32
	pObjects    *_vkRefreshObjectKHR
}

func (s *_vkRefreshObjectListKHR) Goify() *RefreshObjectListKHR {
	rval := &RefreshObjectListKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pObjects in returned struct
	}
	return rval
}
func (s *RefreshObjectListKHR) Vulkanize() *_vkRefreshObjectListKHR {
	if s == nil {
		return nil
	}

	var psl_pObjects *_vkRefreshObjectKHR
	if len(s.PObjects) > 0 {
		psl_pObjects = &s.PObjects[0]
	}
	rval := &_vkRefreshObjectListKHR{
		sType:       STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),              /*cb*/
		objectCount: uint32(len(s.PObjects)),                /*c6-a*/
		pObjects:    psl_pObjects,                           /*c rem*/
	}
	return rval
}

// ReleaseSwapchainImagesInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkReleaseSwapchainImagesInfoEXT.html
type ReleaseSwapchainImagesInfoEXT struct {
	// SType = STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT
	PNext unsafe.Pointer
	//  Swapchain for which images are being released;
	Swapchain SwapchainKHR
	//  Number of indices to release;
	// imageIndexCount
	//  Indices of which presentable images to release;
	PImageIndices []uint32
}

type _vkReleaseSwapchainImagesInfoEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	swapchain       SwapchainKHR
	imageIndexCount uint32
	pImageIndices   *uint32
}

func (s *_vkReleaseSwapchainImagesInfoEXT) Goify() *ReleaseSwapchainImagesInfoEXT {
	rval := &ReleaseSwapchainImagesInfoEXT{
		PNext:     (unsafe.Pointer)(s.pNext),
		Swapchain: (SwapchainKHR)(s.swapchain),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pImageIndices in returned struct
	}
	return rval
}
func (s *ReleaseSwapchainImagesInfoEXT) Vulkanize() *_vkReleaseSwapchainImagesInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pImageIndices *uint32
	if len(s.PImageIndices) > 0 {
		psl_pImageIndices = &s.PImageIndices[0]
	}
	rval := &_vkReleaseSwapchainImagesInfoEXT{
		sType:           STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                        /*cb*/
		swapchain:       (SwapchainKHR)(s.Swapchain),                      /*cb*/
		imageIndexCount: uint32(len(s.PImageIndices)),                     /*c6-a*/
		pImageIndices:   psl_pImageIndices,                                /*c rem*/
	}
	return rval
}

// RenderPassAttachmentBeginInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassAttachmentBeginInfo.html
type RenderPassAttachmentBeginInfo struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO
	PNext unsafe.Pointer
	// attachmentCount
	PAttachments []ImageView
}

type _vkRenderPassAttachmentBeginInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	attachmentCount uint32
	pAttachments    *ImageView
}

func (s *_vkRenderPassAttachmentBeginInfo) Goify() *RenderPassAttachmentBeginInfo {
	rval := &RenderPassAttachmentBeginInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAttachments in returned struct
	}
	return rval
}
func (s *RenderPassAttachmentBeginInfo) Vulkanize() *_vkRenderPassAttachmentBeginInfo {
	if s == nil {
		return nil
	}

	var psl_pAttachments *ImageView
	if len(s.PAttachments) > 0 {
		psl_pAttachments = &s.PAttachments[0]
	}
	rval := &_vkRenderPassAttachmentBeginInfo{
		sType:           STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                        /*cb*/
		attachmentCount: uint32(len(s.PAttachments)),                      /*c6-a*/
		pAttachments:    psl_pAttachments,                                 /*c rem*/
	}
	return rval
}

// RenderPassAttachmentBeginInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassAttachmentBeginInfoKHR.html
type RenderPassAttachmentBeginInfoKHR struct {
}

type _vkRenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfoKHR

func (s *_vkRenderPassAttachmentBeginInfoKHR) Goify() *RenderPassAttachmentBeginInfoKHR {
	rval := (*RenderPassAttachmentBeginInfoKHR)(s)
	return rval
}
func (s *RenderPassAttachmentBeginInfoKHR) Vulkanize() *_vkRenderPassAttachmentBeginInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkRenderPassAttachmentBeginInfoKHR)(s)
	return rval
}

// RenderPassBeginInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassBeginInfo.html
type RenderPassBeginInfo struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
	PNext       unsafe.Pointer
	RenderPass  RenderPass
	Framebuffer Framebuffer
	RenderArea  Rect2D
	// clearValueCount
	PClearValues []ClearValue
}

type _vkRenderPassBeginInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	renderPass      RenderPass
	framebuffer     Framebuffer
	renderArea      _vkRect2D
	clearValueCount uint32
	pClearValues    *_vkClearValue
}

func (s *_vkRenderPassBeginInfo) Goify() *RenderPassBeginInfo {
	rval := &RenderPassBeginInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		RenderPass:  (RenderPass)(s.renderPass),
		Framebuffer: (Framebuffer)(s.framebuffer),
		RenderArea:  *(s.renderArea.Goify()),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pClearValues in returned struct
	}
	return rval
}
func (s *RenderPassBeginInfo) Vulkanize() *_vkRenderPassBeginInfo {
	if s == nil {
		return nil
	}

	var psl_pClearValues *_vkClearValue
	if len(s.PClearValues) > 0 {
		sl_pClearValues := make([]_vkClearValue, len(s.PClearValues))
		for i, v := range s.PClearValues {
			sl_pClearValues[i] = *v.Vulkanize()
		}
		psl_pClearValues = &sl_pClearValues[0]
	}
	rval := &_vkRenderPassBeginInfo{
		sType:           STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),             /*cb*/
		renderPass:      (RenderPass)(s.RenderPass),            /*cb*/
		framebuffer:     (Framebuffer)(s.Framebuffer),          /*cb*/
		renderArea:      *(s.RenderArea.Vulkanize()),           /*c3*/
		clearValueCount: uint32(len(s.PClearValues)),           /*c6-a*/
		pClearValues:    psl_pClearValues,                      /*c rem*/
	}
	return rval
}

// RenderPassCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo.html
type RenderPassCreateInfo struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
	PNext unsafe.Pointer
	Flags RenderPassCreateFlags
	// attachmentCount
	PAttachments []AttachmentDescription
	// subpassCount
	PSubpasses []SubpassDescription
	// dependencyCount
	PDependencies []SubpassDependency
}

type _vkRenderPassCreateInfo struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           RenderPassCreateFlags
	attachmentCount uint32
	pAttachments    *_vkAttachmentDescription
	subpassCount    uint32
	pSubpasses      *_vkSubpassDescription
	dependencyCount uint32
	pDependencies   *_vkSubpassDependency
}

func (s *_vkRenderPassCreateInfo) Goify() *RenderPassCreateInfo {
	rval := &RenderPassCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (RenderPassCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAttachments in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSubpasses in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDependencies in returned struct
	}
	return rval
}
func (s *RenderPassCreateInfo) Vulkanize() *_vkRenderPassCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pAttachments *_vkAttachmentDescription
	if len(s.PAttachments) > 0 {
		psl_pAttachments = &s.PAttachments[0]
	}

	var psl_pSubpasses *_vkSubpassDescription
	if len(s.PSubpasses) > 0 {
		sl_pSubpasses := make([]_vkSubpassDescription, len(s.PSubpasses))
		for i, v := range s.PSubpasses {
			sl_pSubpasses[i] = *(v.Vulkanize())
		}
		psl_pSubpasses = &sl_pSubpasses[0]
	}

	var psl_pDependencies *_vkSubpassDependency
	if len(s.PDependencies) > 0 {
		psl_pDependencies = &s.PDependencies[0]
	}
	rval := &_vkRenderPassCreateInfo{
		sType:           STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),              /*cb*/
		flags:           (RenderPassCreateFlags)(s.Flags),       /*cb*/
		attachmentCount: uint32(len(s.PAttachments)),            /*c6-a*/
		pAttachments:    psl_pAttachments,                       /*c rem*/
		subpassCount:    uint32(len(s.PSubpasses)),              /*c6-a*/
		pSubpasses:      psl_pSubpasses,                         /*c rem*/
		dependencyCount: uint32(len(s.PDependencies)),           /*c6-a*/
		pDependencies:   psl_pDependencies,                      /*c rem*/
	}
	return rval
}

// RenderPassCreateInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo2.html
type RenderPassCreateInfo2 struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2
	PNext unsafe.Pointer
	Flags RenderPassCreateFlags
	// attachmentCount
	PAttachments []AttachmentDescription2
	// subpassCount
	PSubpasses []SubpassDescription2
	// dependencyCount
	PDependencies []SubpassDependency2
	// correlatedViewMaskCount
	PCorrelatedViewMasks []uint32
}

type _vkRenderPassCreateInfo2 struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	flags                   RenderPassCreateFlags
	attachmentCount         uint32
	pAttachments            *_vkAttachmentDescription2
	subpassCount            uint32
	pSubpasses              *_vkSubpassDescription2
	dependencyCount         uint32
	pDependencies           *_vkSubpassDependency2
	correlatedViewMaskCount uint32
	pCorrelatedViewMasks    *uint32
}

func (s *_vkRenderPassCreateInfo2) Goify() *RenderPassCreateInfo2 {
	rval := &RenderPassCreateInfo2{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (RenderPassCreateFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAttachments in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSubpasses in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDependencies in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCorrelatedViewMasks in returned struct
	}
	return rval
}
func (s *RenderPassCreateInfo2) Vulkanize() *_vkRenderPassCreateInfo2 {
	if s == nil {
		return nil
	}

	var psl_pAttachments *_vkAttachmentDescription2
	if len(s.PAttachments) > 0 {
		sl_pAttachments := make([]_vkAttachmentDescription2, len(s.PAttachments))
		for i, v := range s.PAttachments {
			sl_pAttachments[i] = *(v.Vulkanize())
		}
		psl_pAttachments = &sl_pAttachments[0]
	}

	var psl_pSubpasses *_vkSubpassDescription2
	if len(s.PSubpasses) > 0 {
		sl_pSubpasses := make([]_vkSubpassDescription2, len(s.PSubpasses))
		for i, v := range s.PSubpasses {
			sl_pSubpasses[i] = *(v.Vulkanize())
		}
		psl_pSubpasses = &sl_pSubpasses[0]
	}

	var psl_pDependencies *_vkSubpassDependency2
	if len(s.PDependencies) > 0 {
		sl_pDependencies := make([]_vkSubpassDependency2, len(s.PDependencies))
		for i, v := range s.PDependencies {
			sl_pDependencies[i] = *(v.Vulkanize())
		}
		psl_pDependencies = &sl_pDependencies[0]
	}

	var psl_pCorrelatedViewMasks *uint32
	if len(s.PCorrelatedViewMasks) > 0 {
		psl_pCorrelatedViewMasks = &s.PCorrelatedViewMasks[0]
	}
	rval := &_vkRenderPassCreateInfo2{
		sType:                   STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                /*cb*/
		flags:                   (RenderPassCreateFlags)(s.Flags),         /*cb*/
		attachmentCount:         uint32(len(s.PAttachments)),              /*c6-a*/
		pAttachments:            psl_pAttachments,                         /*c rem*/
		subpassCount:            uint32(len(s.PSubpasses)),                /*c6-a*/
		pSubpasses:              psl_pSubpasses,                           /*c rem*/
		dependencyCount:         uint32(len(s.PDependencies)),             /*c6-a*/
		pDependencies:           psl_pDependencies,                        /*c rem*/
		correlatedViewMaskCount: uint32(len(s.PCorrelatedViewMasks)),      /*c6-a*/
		pCorrelatedViewMasks:    psl_pCorrelatedViewMasks,                 /*c rem*/
	}
	return rval
}

// RenderPassCreateInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo2KHR.html
type RenderPassCreateInfo2KHR struct {
}

type _vkRenderPassCreateInfo2KHR = RenderPassCreateInfo2KHR

func (s *_vkRenderPassCreateInfo2KHR) Goify() *RenderPassCreateInfo2KHR {
	rval := (*RenderPassCreateInfo2KHR)(s)
	return rval
}
func (s *RenderPassCreateInfo2KHR) Vulkanize() *_vkRenderPassCreateInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkRenderPassCreateInfo2KHR)(s)
	return rval
}

// RenderPassCreationControlEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreationControlEXT.html
type RenderPassCreationControlEXT struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT
	PNext           unsafe.Pointer
	DisallowMerging bool
}

type _vkRenderPassCreationControlEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	disallowMerging Bool32
}

func (s *_vkRenderPassCreationControlEXT) Goify() *RenderPassCreationControlEXT {
	rval := &RenderPassCreationControlEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		DisallowMerging: translatePublic_Bool32(s.disallowMerging), /*default*/
	}
	return rval
}
func (s *RenderPassCreationControlEXT) Vulkanize() *_vkRenderPassCreationControlEXT {
	if s == nil {
		return nil
	}
	rval := &_vkRenderPassCreationControlEXT{
		sType:           STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                       /*cb*/
		disallowMerging: translateInternal_Bool32(s.DisallowMerging),     /*default*/
	}
	return rval
}

// RenderPassCreationFeedbackCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreationFeedbackCreateInfoEXT.html
type RenderPassCreationFeedbackCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT
	PNext               unsafe.Pointer
	PRenderPassFeedback *RenderPassCreationFeedbackInfoEXT
}

type _vkRenderPassCreationFeedbackCreateInfoEXT struct {
	sType               StructureType
	pNext               unsafe.Pointer
	pRenderPassFeedback *_vkRenderPassCreationFeedbackInfoEXT
}

func (s *_vkRenderPassCreationFeedbackCreateInfoEXT) Goify() *RenderPassCreationFeedbackCreateInfoEXT {
	rval := &RenderPassCreationFeedbackCreateInfoEXT{
		PNext:               (unsafe.Pointer)(s.pNext),
		PRenderPassFeedback: (*RenderPassCreationFeedbackInfoEXT)(s.pRenderPassFeedback),
	}
	return rval
}
func (s *RenderPassCreationFeedbackCreateInfoEXT) Vulkanize() *_vkRenderPassCreationFeedbackCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkRenderPassCreationFeedbackCreateInfoEXT{
		sType:               STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT,   /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                                      /*cb*/
		pRenderPassFeedback: (*_vkRenderPassCreationFeedbackInfoEXT)(s.PRenderPassFeedback), /*cb*/
	}
	return rval
}

// RenderPassCreationFeedbackInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreationFeedbackInfoEXT.html
type RenderPassCreationFeedbackInfoEXT struct {
	PostMergeSubpassCount uint32
}

type _vkRenderPassCreationFeedbackInfoEXT = RenderPassCreationFeedbackInfoEXT

func (s *_vkRenderPassCreationFeedbackInfoEXT) Goify() *RenderPassCreationFeedbackInfoEXT {
	rval := (*RenderPassCreationFeedbackInfoEXT)(s)
	return rval
}
func (s *RenderPassCreationFeedbackInfoEXT) Vulkanize() *_vkRenderPassCreationFeedbackInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkRenderPassCreationFeedbackInfoEXT)(s)
	return rval
}

// RenderPassFragmentDensityMapCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html
type RenderPassFragmentDensityMapCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT
	PNext                        unsafe.Pointer
	FragmentDensityMapAttachment AttachmentReference
}

type _vkRenderPassFragmentDensityMapCreateInfoEXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	fragmentDensityMapAttachment _vkAttachmentReference
}

func (s *_vkRenderPassFragmentDensityMapCreateInfoEXT) Goify() *RenderPassFragmentDensityMapCreateInfoEXT {
	rval := &RenderPassFragmentDensityMapCreateInfoEXT{
		PNext:                        (unsafe.Pointer)(s.pNext),
		FragmentDensityMapAttachment: (AttachmentReference)(s.fragmentDensityMapAttachment),
	}
	return rval
}
func (s *RenderPassFragmentDensityMapCreateInfoEXT) Vulkanize() *_vkRenderPassFragmentDensityMapCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkRenderPassFragmentDensityMapCreateInfoEXT{
		sType:                        STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                                       /*cb*/
		fragmentDensityMapAttachment: (_vkAttachmentReference)(s.FragmentDensityMapAttachment),        /*cb*/
	}
	return rval
}

// RenderPassInputAttachmentAspectCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html
type RenderPassInputAttachmentAspectCreateInfo struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO
	PNext unsafe.Pointer
	// aspectReferenceCount
	PAspectReferences []InputAttachmentAspectReference
}

type _vkRenderPassInputAttachmentAspectCreateInfo struct {
	sType                StructureType
	pNext                unsafe.Pointer
	aspectReferenceCount uint32
	pAspectReferences    *_vkInputAttachmentAspectReference
}

func (s *_vkRenderPassInputAttachmentAspectCreateInfo) Goify() *RenderPassInputAttachmentAspectCreateInfo {
	rval := &RenderPassInputAttachmentAspectCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAspectReferences in returned struct
	}
	return rval
}
func (s *RenderPassInputAttachmentAspectCreateInfo) Vulkanize() *_vkRenderPassInputAttachmentAspectCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pAspectReferences *_vkInputAttachmentAspectReference
	if len(s.PAspectReferences) > 0 {
		psl_pAspectReferences = &s.PAspectReferences[0]
	}
	rval := &_vkRenderPassInputAttachmentAspectCreateInfo{
		sType:                STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                                      /*cb*/
		aspectReferenceCount: uint32(len(s.PAspectReferences)),                               /*c6-a*/
		pAspectReferences:    psl_pAspectReferences,                                          /*c rem*/
	}
	return rval
}

// RenderPassInputAttachmentAspectCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassInputAttachmentAspectCreateInfoKHR.html
type RenderPassInputAttachmentAspectCreateInfoKHR struct {
}

type _vkRenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfoKHR

func (s *_vkRenderPassInputAttachmentAspectCreateInfoKHR) Goify() *RenderPassInputAttachmentAspectCreateInfoKHR {
	rval := (*RenderPassInputAttachmentAspectCreateInfoKHR)(s)
	return rval
}
func (s *RenderPassInputAttachmentAspectCreateInfoKHR) Vulkanize() *_vkRenderPassInputAttachmentAspectCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkRenderPassInputAttachmentAspectCreateInfoKHR)(s)
	return rval
}

// RenderPassMultiviewCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassMultiviewCreateInfo.html
type RenderPassMultiviewCreateInfo struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO
	PNext unsafe.Pointer
	// subpassCount
	PViewMasks []uint32
	// dependencyCount
	PViewOffsets []int32
	// correlationMaskCount
	PCorrelationMasks []uint32
}

type _vkRenderPassMultiviewCreateInfo struct {
	sType                StructureType
	pNext                unsafe.Pointer
	subpassCount         uint32
	pViewMasks           *uint32
	dependencyCount      uint32
	pViewOffsets         *int32
	correlationMaskCount uint32
	pCorrelationMasks    *uint32
}

func (s *_vkRenderPassMultiviewCreateInfo) Goify() *RenderPassMultiviewCreateInfo {
	rval := &RenderPassMultiviewCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pViewMasks in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pViewOffsets in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCorrelationMasks in returned struct
	}
	return rval
}
func (s *RenderPassMultiviewCreateInfo) Vulkanize() *_vkRenderPassMultiviewCreateInfo {
	if s == nil {
		return nil
	}

	var psl_pViewMasks *uint32
	if len(s.PViewMasks) > 0 {
		psl_pViewMasks = &s.PViewMasks[0]
	}

	var psl_pViewOffsets *int32
	if len(s.PViewOffsets) > 0 {
		psl_pViewOffsets = &s.PViewOffsets[0]
	}

	var psl_pCorrelationMasks *uint32
	if len(s.PCorrelationMasks) > 0 {
		psl_pCorrelationMasks = &s.PCorrelationMasks[0]
	}
	rval := &_vkRenderPassMultiviewCreateInfo{
		sType:                STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                        /*cb*/
		subpassCount:         uint32(len(s.PViewMasks)),                        /*c6-a*/
		pViewMasks:           psl_pViewMasks,                                   /*c rem*/
		dependencyCount:      uint32(len(s.PViewOffsets)),                      /*c6-a*/
		pViewOffsets:         psl_pViewOffsets,                                 /*c rem*/
		correlationMaskCount: uint32(len(s.PCorrelationMasks)),                 /*c6-a*/
		pCorrelationMasks:    psl_pCorrelationMasks,                            /*c rem*/
	}
	return rval
}

// RenderPassMultiviewCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassMultiviewCreateInfoKHR.html
type RenderPassMultiviewCreateInfoKHR struct {
}

type _vkRenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfoKHR

func (s *_vkRenderPassMultiviewCreateInfoKHR) Goify() *RenderPassMultiviewCreateInfoKHR {
	rval := (*RenderPassMultiviewCreateInfoKHR)(s)
	return rval
}
func (s *RenderPassMultiviewCreateInfoKHR) Vulkanize() *_vkRenderPassMultiviewCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkRenderPassMultiviewCreateInfoKHR)(s)
	return rval
}

// RenderPassSampleLocationsBeginInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html
type RenderPassSampleLocationsBeginInfoEXT struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT
	PNext unsafe.Pointer
	// attachmentInitialSampleLocationsCount
	PAttachmentInitialSampleLocations []AttachmentSampleLocationsEXT
	// postSubpassSampleLocationsCount
	PPostSubpassSampleLocations []SubpassSampleLocationsEXT
}

type _vkRenderPassSampleLocationsBeginInfoEXT struct {
	sType                                 StructureType
	pNext                                 unsafe.Pointer
	attachmentInitialSampleLocationsCount uint32
	pAttachmentInitialSampleLocations     *_vkAttachmentSampleLocationsEXT
	postSubpassSampleLocationsCount       uint32
	pPostSubpassSampleLocations           *_vkSubpassSampleLocationsEXT
}

func (s *_vkRenderPassSampleLocationsBeginInfoEXT) Goify() *RenderPassSampleLocationsBeginInfoEXT {
	rval := &RenderPassSampleLocationsBeginInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAttachmentInitialSampleLocations in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPostSubpassSampleLocations in returned struct
	}
	return rval
}
func (s *RenderPassSampleLocationsBeginInfoEXT) Vulkanize() *_vkRenderPassSampleLocationsBeginInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pAttachmentInitialSampleLocations *_vkAttachmentSampleLocationsEXT
	if len(s.PAttachmentInitialSampleLocations) > 0 {
		sl_pAttachmentInitialSampleLocations := make([]_vkAttachmentSampleLocationsEXT, len(s.PAttachmentInitialSampleLocations))
		for i, v := range s.PAttachmentInitialSampleLocations {
			sl_pAttachmentInitialSampleLocations[i] = *(v.Vulkanize())
		}
		psl_pAttachmentInitialSampleLocations = &sl_pAttachmentInitialSampleLocations[0]
	}

	var psl_pPostSubpassSampleLocations *_vkSubpassSampleLocationsEXT
	if len(s.PPostSubpassSampleLocations) > 0 {
		sl_pPostSubpassSampleLocations := make([]_vkSubpassSampleLocationsEXT, len(s.PPostSubpassSampleLocations))
		for i, v := range s.PPostSubpassSampleLocations {
			sl_pPostSubpassSampleLocations[i] = *(v.Vulkanize())
		}
		psl_pPostSubpassSampleLocations = &sl_pPostSubpassSampleLocations[0]
	}
	rval := &_vkRenderPassSampleLocationsBeginInfoEXT{
		sType:                                 STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, /*c1*/
		pNext:                                 (unsafe.Pointer)(s.PNext),                                  /*cb*/
		attachmentInitialSampleLocationsCount: uint32(len(s.PAttachmentInitialSampleLocations)),           /*c6-a*/
		pAttachmentInitialSampleLocations:     psl_pAttachmentInitialSampleLocations,                      /*c rem*/
		postSubpassSampleLocationsCount:       uint32(len(s.PPostSubpassSampleLocations)),                 /*c6-a*/
		pPostSubpassSampleLocations:           psl_pPostSubpassSampleLocations,                            /*c rem*/
	}
	return rval
}

// RenderPassSubpassFeedbackCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSubpassFeedbackCreateInfoEXT.html
type RenderPassSubpassFeedbackCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT
	PNext            unsafe.Pointer
	PSubpassFeedback *RenderPassSubpassFeedbackInfoEXT
}

type _vkRenderPassSubpassFeedbackCreateInfoEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	pSubpassFeedback *_vkRenderPassSubpassFeedbackInfoEXT
}

func (s *_vkRenderPassSubpassFeedbackCreateInfoEXT) Goify() *RenderPassSubpassFeedbackCreateInfoEXT {
	rval := &RenderPassSubpassFeedbackCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected pointer member pSubpassFeedback in returned struct
	}
	return rval
}
func (s *RenderPassSubpassFeedbackCreateInfoEXT) Vulkanize() *_vkRenderPassSubpassFeedbackCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkRenderPassSubpassFeedbackCreateInfoEXT{
		sType:            STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                                   /*cb*/
		pSubpassFeedback: (s.PSubpassFeedback.Vulkanize()),                            /*c rem*/
	}
	return rval
}

// RenderPassSubpassFeedbackInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSubpassFeedbackInfoEXT.html
type RenderPassSubpassFeedbackInfoEXT struct {
	SubpassMergeStatus SubpassMergeStatusEXT
	Description        string
	PostMergeIndex     uint32
}

// WARNING - struct RenderPassSubpassFeedbackInfoEXT is returned only, which is not yet handled in the binding
type _vkRenderPassSubpassFeedbackInfoEXT struct {
	subpassMergeStatus SubpassMergeStatusEXT
	description        [MAX_DESCRIPTION_SIZE]byte
	postMergeIndex     uint32
}

func (s *_vkRenderPassSubpassFeedbackInfoEXT) Goify() *RenderPassSubpassFeedbackInfoEXT {
	rval := &RenderPassSubpassFeedbackInfoEXT{
		SubpassMergeStatus: (SubpassMergeStatusEXT)(s.subpassMergeStatus),
		Description:        nullTermBytesToString(s.description[:]), /*c arr*/
		PostMergeIndex:     (uint32)(s.postMergeIndex),
	}
	return rval
}
func (s *RenderPassSubpassFeedbackInfoEXT) Vulkanize() *_vkRenderPassSubpassFeedbackInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkRenderPassSubpassFeedbackInfoEXT{
		subpassMergeStatus: (SubpassMergeStatusEXT)(s.SubpassMergeStatus), /*cb*/
		// description : 0 /* TODO ARRAY NOT HANDLED */,/*c arr*/
		postMergeIndex: (uint32)(s.PostMergeIndex), /*cb*/
	}
	return rval
}

// RenderPassTransformBeginInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassTransformBeginInfoQCOM.html
type RenderPassTransformBeginInfoQCOM struct {
	// SType = STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM
	//  Pointer to next structure;
	PNext     unsafe.Pointer
	Transform SurfaceTransformFlagBitsKHR
}

type _vkRenderPassTransformBeginInfoQCOM struct {
	sType     StructureType
	pNext     unsafe.Pointer
	transform SurfaceTransformFlagBitsKHR
}

func (s *_vkRenderPassTransformBeginInfoQCOM) Goify() *RenderPassTransformBeginInfoQCOM {
	rval := &RenderPassTransformBeginInfoQCOM{
		PNext:     (unsafe.Pointer)(s.pNext),
		Transform: (SurfaceTransformFlagBitsKHR)(s.transform),
	}
	return rval
}
func (s *RenderPassTransformBeginInfoQCOM) Vulkanize() *_vkRenderPassTransformBeginInfoQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkRenderPassTransformBeginInfoQCOM{
		sType:     STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                            /*cb*/
		transform: (SurfaceTransformFlagBitsKHR)(s.Transform),           /*cb*/
	}
	return rval
}

// RenderingAreaInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingAreaInfoKHR.html
type RenderingAreaInfoKHR struct {
	// SType = STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR
	PNext    unsafe.Pointer
	ViewMask uint32
	// colorAttachmentCount
	PColorAttachmentFormats []Format
	DepthAttachmentFormat   Format
	StencilAttachmentFormat Format
}

type _vkRenderingAreaInfoKHR struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	viewMask                uint32
	colorAttachmentCount    uint32
	pColorAttachmentFormats *Format
	depthAttachmentFormat   Format
	stencilAttachmentFormat Format
}

func (s *_vkRenderingAreaInfoKHR) Goify() *RenderingAreaInfoKHR {
	rval := &RenderingAreaInfoKHR{
		PNext:    (unsafe.Pointer)(s.pNext),
		ViewMask: (uint32)(s.viewMask),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pColorAttachmentFormats in returned struct
		DepthAttachmentFormat:   (Format)(s.depthAttachmentFormat),
		StencilAttachmentFormat: (Format)(s.stencilAttachmentFormat),
	}
	return rval
}
func (s *RenderingAreaInfoKHR) Vulkanize() *_vkRenderingAreaInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pColorAttachmentFormats *Format
	if len(s.PColorAttachmentFormats) > 0 {
		psl_pColorAttachmentFormats = &s.PColorAttachmentFormats[0]
	}
	rval := &_vkRenderingAreaInfoKHR{
		sType:                   STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),              /*cb*/
		viewMask:                (uint32)(s.ViewMask),                   /*cb*/
		colorAttachmentCount:    uint32(len(s.PColorAttachmentFormats)), /*c6-a*/
		pColorAttachmentFormats: psl_pColorAttachmentFormats,            /*c rem*/
		depthAttachmentFormat:   (Format)(s.DepthAttachmentFormat),      /*cb*/
		stencilAttachmentFormat: (Format)(s.StencilAttachmentFormat),    /*cb*/
	}
	return rval
}

// RenderingAttachmentInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingAttachmentInfo.html
type RenderingAttachmentInfo struct {
	// SType = STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO
	PNext              unsafe.Pointer
	ImageView          ImageView
	ImageLayout        ImageLayout
	ResolveMode        ResolveModeFlagBits
	ResolveImageView   ImageView
	ResolveImageLayout ImageLayout
	LoadOp             AttachmentLoadOp
	StoreOp            AttachmentStoreOp
	ClearValue         ClearValue
}

type _vkRenderingAttachmentInfo struct {
	sType              StructureType
	pNext              unsafe.Pointer
	imageView          ImageView
	imageLayout        ImageLayout
	resolveMode        ResolveModeFlagBits
	resolveImageView   ImageView
	resolveImageLayout ImageLayout
	loadOp             AttachmentLoadOp
	storeOp            AttachmentStoreOp
	clearValue         _vkClearValue
}

func (s *_vkRenderingAttachmentInfo) Goify() *RenderingAttachmentInfo {
	rval := &RenderingAttachmentInfo{
		PNext:              (unsafe.Pointer)(s.pNext),
		ImageView:          (ImageView)(s.imageView),
		ImageLayout:        (ImageLayout)(s.imageLayout),
		ResolveMode:        (ResolveModeFlagBits)(s.resolveMode),
		ResolveImageView:   (ImageView)(s.resolveImageView),
		ResolveImageLayout: (ImageLayout)(s.resolveImageLayout),
		LoadOp:             (AttachmentLoadOp)(s.loadOp),
		StoreOp:            (AttachmentStoreOp)(s.storeOp),
		// Can't Goify union member clearValue
	}
	return rval
}
func (s *RenderingAttachmentInfo) Vulkanize() *_vkRenderingAttachmentInfo {
	if s == nil {
		return nil
	}
	rval := &_vkRenderingAttachmentInfo{
		sType:              STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                /*cb*/
		imageView:          (ImageView)(s.ImageView),                 /*cb*/
		imageLayout:        (ImageLayout)(s.ImageLayout),             /*cb*/
		resolveMode:        (ResolveModeFlagBits)(s.ResolveMode),     /*cb*/
		resolveImageView:   (ImageView)(s.ResolveImageView),          /*cb*/
		resolveImageLayout: (ImageLayout)(s.ResolveImageLayout),      /*cb*/
		loadOp:             (AttachmentLoadOp)(s.LoadOp),             /*cb*/
		storeOp:            (AttachmentStoreOp)(s.StoreOp),           /*cb*/
		clearValue:         *s.ClearValue.Vulkanize(),                /*c union*/
	}
	return rval
}

// RenderingAttachmentInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingAttachmentInfoKHR.html
type RenderingAttachmentInfoKHR struct {
}

type _vkRenderingAttachmentInfoKHR = RenderingAttachmentInfoKHR

func (s *_vkRenderingAttachmentInfoKHR) Goify() *RenderingAttachmentInfoKHR {
	rval := (*RenderingAttachmentInfoKHR)(s)
	return rval
}
func (s *RenderingAttachmentInfoKHR) Vulkanize() *_vkRenderingAttachmentInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkRenderingAttachmentInfoKHR)(s)
	return rval
}

// RenderingFragmentDensityMapAttachmentInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html
type RenderingFragmentDensityMapAttachmentInfoEXT struct {
	// SType = STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT
	PNext       unsafe.Pointer
	ImageView   ImageView
	ImageLayout ImageLayout
}

type _vkRenderingFragmentDensityMapAttachmentInfoEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	imageView   ImageView
	imageLayout ImageLayout
}

func (s *_vkRenderingFragmentDensityMapAttachmentInfoEXT) Goify() *RenderingFragmentDensityMapAttachmentInfoEXT {
	rval := &RenderingFragmentDensityMapAttachmentInfoEXT{
		PNext:       (unsafe.Pointer)(s.pNext),
		ImageView:   (ImageView)(s.imageView),
		ImageLayout: (ImageLayout)(s.imageLayout),
	}
	return rval
}
func (s *RenderingFragmentDensityMapAttachmentInfoEXT) Vulkanize() *_vkRenderingFragmentDensityMapAttachmentInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkRenderingFragmentDensityMapAttachmentInfoEXT{
		sType:       STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                                         /*cb*/
		imageView:   (ImageView)(s.ImageView),                                          /*cb*/
		imageLayout: (ImageLayout)(s.ImageLayout),                                      /*cb*/
	}
	return rval
}

// RenderingFragmentShadingRateAttachmentInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentShadingRateAttachmentInfoKHR.html
type RenderingFragmentShadingRateAttachmentInfoKHR struct {
	// SType = STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR
	PNext                          unsafe.Pointer
	ImageView                      ImageView
	ImageLayout                    ImageLayout
	ShadingRateAttachmentTexelSize Extent2D
}

type _vkRenderingFragmentShadingRateAttachmentInfoKHR struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	imageView                      ImageView
	imageLayout                    ImageLayout
	shadingRateAttachmentTexelSize _vkExtent2D
}

func (s *_vkRenderingFragmentShadingRateAttachmentInfoKHR) Goify() *RenderingFragmentShadingRateAttachmentInfoKHR {
	rval := &RenderingFragmentShadingRateAttachmentInfoKHR{
		PNext:                          (unsafe.Pointer)(s.pNext),
		ImageView:                      (ImageView)(s.imageView),
		ImageLayout:                    (ImageLayout)(s.imageLayout),
		ShadingRateAttachmentTexelSize: (Extent2D)(s.shadingRateAttachmentTexelSize),
	}
	return rval
}
func (s *RenderingFragmentShadingRateAttachmentInfoKHR) Vulkanize() *_vkRenderingFragmentShadingRateAttachmentInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkRenderingFragmentShadingRateAttachmentInfoKHR{
		sType:                          STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                          /*cb*/
		imageView:                      (ImageView)(s.ImageView),                                           /*cb*/
		imageLayout:                    (ImageLayout)(s.ImageLayout),                                       /*cb*/
		shadingRateAttachmentTexelSize: (_vkExtent2D)(s.ShadingRateAttachmentTexelSize),                    /*cb*/
	}
	return rval
}

// RenderingInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingInfo.html
type RenderingInfo struct {
	// SType = STRUCTURE_TYPE_RENDERING_INFO
	PNext      unsafe.Pointer
	Flags      RenderingFlags
	RenderArea Rect2D
	LayerCount uint32
	ViewMask   uint32
	// colorAttachmentCount
	PColorAttachments  []RenderingAttachmentInfo
	PDepthAttachment   *RenderingAttachmentInfo
	PStencilAttachment *RenderingAttachmentInfo
}

type _vkRenderingInfo struct {
	sType                StructureType
	pNext                unsafe.Pointer
	flags                RenderingFlags
	renderArea           _vkRect2D
	layerCount           uint32
	viewMask             uint32
	colorAttachmentCount uint32
	pColorAttachments    *_vkRenderingAttachmentInfo
	pDepthAttachment     *_vkRenderingAttachmentInfo
	pStencilAttachment   *_vkRenderingAttachmentInfo
}

func (s *_vkRenderingInfo) Goify() *RenderingInfo {
	rval := &RenderingInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		Flags:      (RenderingFlags)(s.flags),
		RenderArea: *(s.renderArea.Goify()),
		LayerCount: (uint32)(s.layerCount),
		ViewMask:   (uint32)(s.viewMask),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pColorAttachments in returned struct
		// Unexpected pointer member pDepthAttachment in returned struct
		// Unexpected pointer member pStencilAttachment in returned struct
	}
	return rval
}
func (s *RenderingInfo) Vulkanize() *_vkRenderingInfo {
	if s == nil {
		return nil
	}

	var psl_pColorAttachments *_vkRenderingAttachmentInfo
	if len(s.PColorAttachments) > 0 {
		sl_pColorAttachments := make([]_vkRenderingAttachmentInfo, len(s.PColorAttachments))
		for i, v := range s.PColorAttachments {
			sl_pColorAttachments[i] = *(v.Vulkanize())
		}
		psl_pColorAttachments = &sl_pColorAttachments[0]
	}
	rval := &_vkRenderingInfo{
		sType:                STRUCTURE_TYPE_RENDERING_INFO,      /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),          /*cb*/
		flags:                (RenderingFlags)(s.Flags),          /*cb*/
		renderArea:           *(s.RenderArea.Vulkanize()),        /*c3*/
		layerCount:           (uint32)(s.LayerCount),             /*cb*/
		viewMask:             (uint32)(s.ViewMask),               /*cb*/
		colorAttachmentCount: uint32(len(s.PColorAttachments)),   /*c6-a*/
		pColorAttachments:    psl_pColorAttachments,              /*c rem*/
		pDepthAttachment:     (s.PDepthAttachment.Vulkanize()),   /*c rem*/
		pStencilAttachment:   (s.PStencilAttachment.Vulkanize()), /*c rem*/
	}
	return rval
}

// RenderingInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingInfoKHR.html
type RenderingInfoKHR struct {
}

type _vkRenderingInfoKHR = RenderingInfoKHR

func (s *_vkRenderingInfoKHR) Goify() *RenderingInfoKHR {
	rval := (*RenderingInfoKHR)(s)
	return rval
}
func (s *RenderingInfoKHR) Vulkanize() *_vkRenderingInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkRenderingInfoKHR)(s)
	return rval
}

// ResolveImageInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveImageInfo2.html
type ResolveImageInfo2 struct {
	// SType = STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2
	PNext          unsafe.Pointer
	SrcImage       Image
	SrcImageLayout ImageLayout
	DstImage       Image
	DstImageLayout ImageLayout
	// regionCount
	PRegions []ImageResolve2
}

type _vkResolveImageInfo2 struct {
	sType          StructureType
	pNext          unsafe.Pointer
	srcImage       Image
	srcImageLayout ImageLayout
	dstImage       Image
	dstImageLayout ImageLayout
	regionCount    uint32
	pRegions       *_vkImageResolve2
}

func (s *_vkResolveImageInfo2) Goify() *ResolveImageInfo2 {
	rval := &ResolveImageInfo2{
		PNext:          (unsafe.Pointer)(s.pNext),
		SrcImage:       (Image)(s.srcImage),
		SrcImageLayout: (ImageLayout)(s.srcImageLayout),
		DstImage:       (Image)(s.dstImage),
		DstImageLayout: (ImageLayout)(s.dstImageLayout),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pRegions in returned struct
	}
	return rval
}
func (s *ResolveImageInfo2) Vulkanize() *_vkResolveImageInfo2 {
	if s == nil {
		return nil
	}

	var psl_pRegions *_vkImageResolve2
	if len(s.PRegions) > 0 {
		sl_pRegions := make([]_vkImageResolve2, len(s.PRegions))
		for i, v := range s.PRegions {
			sl_pRegions[i] = *(v.Vulkanize())
		}
		psl_pRegions = &sl_pRegions[0]
	}
	rval := &_vkResolveImageInfo2{
		sType:          STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),           /*cb*/
		srcImage:       (Image)(s.SrcImage),                 /*cb*/
		srcImageLayout: (ImageLayout)(s.SrcImageLayout),     /*cb*/
		dstImage:       (Image)(s.DstImage),                 /*cb*/
		dstImageLayout: (ImageLayout)(s.DstImageLayout),     /*cb*/
		regionCount:    uint32(len(s.PRegions)),             /*c6-a*/
		pRegions:       psl_pRegions,                        /*c rem*/
	}
	return rval
}

// ResolveImageInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveImageInfo2KHR.html
type ResolveImageInfo2KHR struct {
}

type _vkResolveImageInfo2KHR = ResolveImageInfo2KHR

func (s *_vkResolveImageInfo2KHR) Goify() *ResolveImageInfo2KHR {
	rval := (*ResolveImageInfo2KHR)(s)
	return rval
}
func (s *ResolveImageInfo2KHR) Vulkanize() *_vkResolveImageInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkResolveImageInfo2KHR)(s)
	return rval
}

// SRTDataNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSRTDataNV.html
type SRTDataNV struct {
	Sx  float32
	A   float32
	B   float32
	Pvx float32
	Sy  float32
	C   float32
	Pvy float32
	Sz  float32
	Pvz float32
	Qx  float32
	Qy  float32
	Qz  float32
	Qw  float32
	Tx  float32
	Ty  float32
	Tz  float32
}

type _vkSRTDataNV = SRTDataNV

func (s *_vkSRTDataNV) Goify() *SRTDataNV {
	rval := (*SRTDataNV)(s)
	return rval
}
func (s *SRTDataNV) Vulkanize() *_vkSRTDataNV {
	if s == nil {
		return nil
	}
	rval := (*_vkSRTDataNV)(s)
	return rval
}

// SampleLocationEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationEXT.html
type SampleLocationEXT struct {
	X float32
	Y float32
}

type _vkSampleLocationEXT = SampleLocationEXT

func (s *_vkSampleLocationEXT) Goify() *SampleLocationEXT {
	rval := (*SampleLocationEXT)(s)
	return rval
}
func (s *SampleLocationEXT) Vulkanize() *_vkSampleLocationEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkSampleLocationEXT)(s)
	return rval
}

// SampleLocationsInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationsInfoEXT.html
type SampleLocationsInfoEXT struct {
	// SType = STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT
	PNext                   unsafe.Pointer
	SampleLocationsPerPixel SampleCountFlagBits
	SampleLocationGridSize  Extent2D
	// sampleLocationsCount
	PSampleLocations []SampleLocationEXT
}

type _vkSampleLocationsInfoEXT struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	sampleLocationsPerPixel SampleCountFlagBits
	sampleLocationGridSize  _vkExtent2D
	sampleLocationsCount    uint32
	pSampleLocations        *_vkSampleLocationEXT
}

func (s *_vkSampleLocationsInfoEXT) Goify() *SampleLocationsInfoEXT {
	rval := &SampleLocationsInfoEXT{
		PNext:                   (unsafe.Pointer)(s.pNext),
		SampleLocationsPerPixel: (SampleCountFlagBits)(s.sampleLocationsPerPixel),
		SampleLocationGridSize:  (Extent2D)(s.sampleLocationGridSize),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSampleLocations in returned struct
	}
	return rval
}
func (s *SampleLocationsInfoEXT) Vulkanize() *_vkSampleLocationsInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pSampleLocations *_vkSampleLocationEXT
	if len(s.PSampleLocations) > 0 {
		psl_pSampleLocations = &s.PSampleLocations[0]
	}
	rval := &_vkSampleLocationsInfoEXT{
		sType:                   STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,         /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                        /*cb*/
		sampleLocationsPerPixel: (SampleCountFlagBits)(s.SampleLocationsPerPixel), /*cb*/
		sampleLocationGridSize:  (_vkExtent2D)(s.SampleLocationGridSize),          /*cb*/
		sampleLocationsCount:    uint32(len(s.PSampleLocations)),                  /*c6-a*/
		pSampleLocations:        psl_pSampleLocations,                             /*c rem*/
	}
	return rval
}

// SamplerBlockMatchWindowCreateInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerBlockMatchWindowCreateInfoQCOM.html
type SamplerBlockMatchWindowCreateInfoQCOM struct {
	// SType = STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM
	PNext             unsafe.Pointer
	WindowExtent      Extent2D
	WindowCompareMode BlockMatchWindowCompareModeQCOM
}

type _vkSamplerBlockMatchWindowCreateInfoQCOM struct {
	sType             StructureType
	pNext             unsafe.Pointer
	windowExtent      _vkExtent2D
	windowCompareMode BlockMatchWindowCompareModeQCOM
}

func (s *_vkSamplerBlockMatchWindowCreateInfoQCOM) Goify() *SamplerBlockMatchWindowCreateInfoQCOM {
	rval := &SamplerBlockMatchWindowCreateInfoQCOM{
		PNext:             (unsafe.Pointer)(s.pNext),
		WindowExtent:      (Extent2D)(s.windowExtent),
		WindowCompareMode: (BlockMatchWindowCompareModeQCOM)(s.windowCompareMode),
	}
	return rval
}
func (s *SamplerBlockMatchWindowCreateInfoQCOM) Vulkanize() *_vkSamplerBlockMatchWindowCreateInfoQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerBlockMatchWindowCreateInfoQCOM{
		sType:             STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                  /*cb*/
		windowExtent:      (_vkExtent2D)(s.WindowExtent),                              /*cb*/
		windowCompareMode: (BlockMatchWindowCompareModeQCOM)(s.WindowCompareMode),     /*cb*/
	}
	return rval
}

// SamplerBorderColorComponentMappingCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerBorderColorComponentMappingCreateInfoEXT.html
type SamplerBorderColorComponentMappingCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT
	PNext      unsafe.Pointer
	Components ComponentMapping
	Srgb       bool
}

type _vkSamplerBorderColorComponentMappingCreateInfoEXT struct {
	sType      StructureType
	pNext      unsafe.Pointer
	components _vkComponentMapping
	srgb       Bool32
}

func (s *_vkSamplerBorderColorComponentMappingCreateInfoEXT) Goify() *SamplerBorderColorComponentMappingCreateInfoEXT {
	rval := &SamplerBorderColorComponentMappingCreateInfoEXT{
		PNext:      (unsafe.Pointer)(s.pNext),
		Components: (ComponentMapping)(s.components),
		Srgb:       translatePublic_Bool32(s.srgb), /*default*/
	}
	return rval
}
func (s *SamplerBorderColorComponentMappingCreateInfoEXT) Vulkanize() *_vkSamplerBorderColorComponentMappingCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerBorderColorComponentMappingCreateInfoEXT{
		sType:      STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                                             /*cb*/
		components: (_vkComponentMapping)(s.Components),                                   /*cb*/
		srgb:       translateInternal_Bool32(s.Srgb),                                      /*default*/
	}
	return rval
}

// SamplerCaptureDescriptorDataInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCaptureDescriptorDataInfoEXT.html
type SamplerCaptureDescriptorDataInfoEXT struct {
	// SType = STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
	PNext   unsafe.Pointer
	Sampler Sampler
}

type _vkSamplerCaptureDescriptorDataInfoEXT struct {
	sType   StructureType
	pNext   unsafe.Pointer
	sampler Sampler
}

func (s *_vkSamplerCaptureDescriptorDataInfoEXT) Goify() *SamplerCaptureDescriptorDataInfoEXT {
	rval := &SamplerCaptureDescriptorDataInfoEXT{
		PNext:   (unsafe.Pointer)(s.pNext),
		Sampler: (Sampler)(s.sampler),
	}
	return rval
}
func (s *SamplerCaptureDescriptorDataInfoEXT) Vulkanize() *_vkSamplerCaptureDescriptorDataInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerCaptureDescriptorDataInfoEXT{
		sType:   STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, /*c1*/
		pNext:   (unsafe.Pointer)(s.PNext),                               /*cb*/
		sampler: (Sampler)(s.Sampler),                                    /*cb*/
	}
	return rval
}

// SamplerCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateInfo.html
type SamplerCreateInfo struct {
	// SType = STRUCTURE_TYPE_SAMPLER_CREATE_INFO
	PNext unsafe.Pointer
	Flags SamplerCreateFlags
	//  Filter mode for magnification;
	MagFilter Filter
	//  Filter mode for minifiation;
	MinFilter Filter
	//  Mipmap selection mode;
	MipmapMode              SamplerMipmapMode
	AddressModeU            SamplerAddressMode
	AddressModeV            SamplerAddressMode
	AddressModeW            SamplerAddressMode
	MipLodBias              float32
	AnisotropyEnable        bool
	MaxAnisotropy           float32
	CompareEnable           bool
	CompareOp               CompareOp
	MinLod                  float32
	MaxLod                  float32
	BorderColor             BorderColor
	UnnormalizedCoordinates bool
}

type _vkSamplerCreateInfo struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	flags                   SamplerCreateFlags
	magFilter               Filter
	minFilter               Filter
	mipmapMode              SamplerMipmapMode
	addressModeU            SamplerAddressMode
	addressModeV            SamplerAddressMode
	addressModeW            SamplerAddressMode
	mipLodBias              float32
	anisotropyEnable        Bool32
	maxAnisotropy           float32
	compareEnable           Bool32
	compareOp               CompareOp
	minLod                  float32
	maxLod                  float32
	borderColor             BorderColor
	unnormalizedCoordinates Bool32
}

func (s *_vkSamplerCreateInfo) Goify() *SamplerCreateInfo {
	rval := &SamplerCreateInfo{
		PNext:                   (unsafe.Pointer)(s.pNext),
		Flags:                   (SamplerCreateFlags)(s.flags),
		MagFilter:               (Filter)(s.magFilter),
		MinFilter:               (Filter)(s.minFilter),
		MipmapMode:              (SamplerMipmapMode)(s.mipmapMode),
		AddressModeU:            (SamplerAddressMode)(s.addressModeU),
		AddressModeV:            (SamplerAddressMode)(s.addressModeV),
		AddressModeW:            (SamplerAddressMode)(s.addressModeW),
		MipLodBias:              (float32)(s.mipLodBias),
		AnisotropyEnable:        translatePublic_Bool32(s.anisotropyEnable), /*default*/
		MaxAnisotropy:           (float32)(s.maxAnisotropy),
		CompareEnable:           translatePublic_Bool32(s.compareEnable), /*default*/
		CompareOp:               (CompareOp)(s.compareOp),
		MinLod:                  (float32)(s.minLod),
		MaxLod:                  (float32)(s.maxLod),
		BorderColor:             (BorderColor)(s.borderColor),
		UnnormalizedCoordinates: translatePublic_Bool32(s.unnormalizedCoordinates), /*default*/
	}
	return rval
}
func (s *SamplerCreateInfo) Vulkanize() *_vkSamplerCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerCreateInfo{
		sType:                   STRUCTURE_TYPE_SAMPLER_CREATE_INFO,                  /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                           /*cb*/
		flags:                   (SamplerCreateFlags)(s.Flags),                       /*cb*/
		magFilter:               (Filter)(s.MagFilter),                               /*cb*/
		minFilter:               (Filter)(s.MinFilter),                               /*cb*/
		mipmapMode:              (SamplerMipmapMode)(s.MipmapMode),                   /*cb*/
		addressModeU:            (SamplerAddressMode)(s.AddressModeU),                /*cb*/
		addressModeV:            (SamplerAddressMode)(s.AddressModeV),                /*cb*/
		addressModeW:            (SamplerAddressMode)(s.AddressModeW),                /*cb*/
		mipLodBias:              (float32)(s.MipLodBias),                             /*cb*/
		anisotropyEnable:        translateInternal_Bool32(s.AnisotropyEnable),        /*default*/
		maxAnisotropy:           (float32)(s.MaxAnisotropy),                          /*cb*/
		compareEnable:           translateInternal_Bool32(s.CompareEnable),           /*default*/
		compareOp:               (CompareOp)(s.CompareOp),                            /*cb*/
		minLod:                  (float32)(s.MinLod),                                 /*cb*/
		maxLod:                  (float32)(s.MaxLod),                                 /*cb*/
		borderColor:             (BorderColor)(s.BorderColor),                        /*cb*/
		unnormalizedCoordinates: translateInternal_Bool32(s.UnnormalizedCoordinates), /*default*/
	}
	return rval
}

// SamplerCubicWeightsCreateInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCubicWeightsCreateInfoQCOM.html
type SamplerCubicWeightsCreateInfoQCOM struct {
	// SType = STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM
	PNext        unsafe.Pointer
	CubicWeights CubicFilterWeightsQCOM
}

type _vkSamplerCubicWeightsCreateInfoQCOM struct {
	sType        StructureType
	pNext        unsafe.Pointer
	cubicWeights CubicFilterWeightsQCOM
}

func (s *_vkSamplerCubicWeightsCreateInfoQCOM) Goify() *SamplerCubicWeightsCreateInfoQCOM {
	rval := &SamplerCubicWeightsCreateInfoQCOM{
		PNext:        (unsafe.Pointer)(s.pNext),
		CubicWeights: (CubicFilterWeightsQCOM)(s.cubicWeights),
	}
	return rval
}
func (s *SamplerCubicWeightsCreateInfoQCOM) Vulkanize() *_vkSamplerCubicWeightsCreateInfoQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerCubicWeightsCreateInfoQCOM{
		sType:        STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                             /*cb*/
		cubicWeights: (CubicFilterWeightsQCOM)(s.CubicWeights),              /*cb*/
	}
	return rval
}

// SamplerCustomBorderColorCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html
type SamplerCustomBorderColorCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT
	PNext             unsafe.Pointer
	CustomBorderColor ClearColorValue
	Format            Format
}

type _vkSamplerCustomBorderColorCreateInfoEXT struct {
	sType             StructureType
	pNext             unsafe.Pointer
	customBorderColor _vkClearColorValue
	format            Format
}

func (s *_vkSamplerCustomBorderColorCreateInfoEXT) Goify() *SamplerCustomBorderColorCreateInfoEXT {
	rval := &SamplerCustomBorderColorCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Can't Goify union member customBorderColor
		Format: (Format)(s.format),
	}
	return rval
}
func (s *SamplerCustomBorderColorCreateInfoEXT) Vulkanize() *_vkSamplerCustomBorderColorCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerCustomBorderColorCreateInfoEXT{
		sType:             STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                  /*cb*/
		customBorderColor: *s.CustomBorderColor.Vulkanize(),                           /*c union*/
		format:            (Format)(s.Format),                                         /*cb*/
	}
	return rval
}

// SamplerReductionModeCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerReductionModeCreateInfo.html
type SamplerReductionModeCreateInfo struct {
	// SType = STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO
	PNext         unsafe.Pointer
	ReductionMode SamplerReductionMode
}

type _vkSamplerReductionModeCreateInfo struct {
	sType         StructureType
	pNext         unsafe.Pointer
	reductionMode SamplerReductionMode
}

func (s *_vkSamplerReductionModeCreateInfo) Goify() *SamplerReductionModeCreateInfo {
	rval := &SamplerReductionModeCreateInfo{
		PNext:         (unsafe.Pointer)(s.pNext),
		ReductionMode: (SamplerReductionMode)(s.reductionMode),
	}
	return rval
}
func (s *SamplerReductionModeCreateInfo) Vulkanize() *_vkSamplerReductionModeCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerReductionModeCreateInfo{
		sType:         STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                         /*cb*/
		reductionMode: (SamplerReductionMode)(s.ReductionMode),           /*cb*/
	}
	return rval
}

// SamplerReductionModeCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerReductionModeCreateInfoEXT.html
type SamplerReductionModeCreateInfoEXT struct {
}

type _vkSamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfoEXT

func (s *_vkSamplerReductionModeCreateInfoEXT) Goify() *SamplerReductionModeCreateInfoEXT {
	rval := (*SamplerReductionModeCreateInfoEXT)(s)
	return rval
}
func (s *SamplerReductionModeCreateInfoEXT) Vulkanize() *_vkSamplerReductionModeCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkSamplerReductionModeCreateInfoEXT)(s)
	return rval
}

// SamplerYcbcrConversionCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionCreateInfo.html
type SamplerYcbcrConversionCreateInfo struct {
	// SType = STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO
	PNext                       unsafe.Pointer
	Format                      Format
	YcbcrModel                  SamplerYcbcrModelConversion
	YcbcrRange                  SamplerYcbcrRange
	Components                  ComponentMapping
	XChromaOffset               ChromaLocation
	YChromaOffset               ChromaLocation
	ChromaFilter                Filter
	ForceExplicitReconstruction bool
}

type _vkSamplerYcbcrConversionCreateInfo struct {
	sType                       StructureType
	pNext                       unsafe.Pointer
	format                      Format
	ycbcrModel                  SamplerYcbcrModelConversion
	ycbcrRange                  SamplerYcbcrRange
	components                  _vkComponentMapping
	xChromaOffset               ChromaLocation
	yChromaOffset               ChromaLocation
	chromaFilter                Filter
	forceExplicitReconstruction Bool32
}

func (s *_vkSamplerYcbcrConversionCreateInfo) Goify() *SamplerYcbcrConversionCreateInfo {
	rval := &SamplerYcbcrConversionCreateInfo{
		PNext:                       (unsafe.Pointer)(s.pNext),
		Format:                      (Format)(s.format),
		YcbcrModel:                  (SamplerYcbcrModelConversion)(s.ycbcrModel),
		YcbcrRange:                  (SamplerYcbcrRange)(s.ycbcrRange),
		Components:                  (ComponentMapping)(s.components),
		XChromaOffset:               (ChromaLocation)(s.xChromaOffset),
		YChromaOffset:               (ChromaLocation)(s.yChromaOffset),
		ChromaFilter:                (Filter)(s.chromaFilter),
		ForceExplicitReconstruction: translatePublic_Bool32(s.forceExplicitReconstruction), /*default*/
	}
	return rval
}
func (s *SamplerYcbcrConversionCreateInfo) Vulkanize() *_vkSamplerYcbcrConversionCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerYcbcrConversionCreateInfo{
		sType:                       STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,     /*c1*/
		pNext:                       (unsafe.Pointer)(s.PNext),                               /*cb*/
		format:                      (Format)(s.Format),                                      /*cb*/
		ycbcrModel:                  (SamplerYcbcrModelConversion)(s.YcbcrModel),             /*cb*/
		ycbcrRange:                  (SamplerYcbcrRange)(s.YcbcrRange),                       /*cb*/
		components:                  (_vkComponentMapping)(s.Components),                     /*cb*/
		xChromaOffset:               (ChromaLocation)(s.XChromaOffset),                       /*cb*/
		yChromaOffset:               (ChromaLocation)(s.YChromaOffset),                       /*cb*/
		chromaFilter:                (Filter)(s.ChromaFilter),                                /*cb*/
		forceExplicitReconstruction: translateInternal_Bool32(s.ForceExplicitReconstruction), /*default*/
	}
	return rval
}

// SamplerYcbcrConversionCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionCreateInfoKHR.html
type SamplerYcbcrConversionCreateInfoKHR struct {
}

type _vkSamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfoKHR

func (s *_vkSamplerYcbcrConversionCreateInfoKHR) Goify() *SamplerYcbcrConversionCreateInfoKHR {
	rval := (*SamplerYcbcrConversionCreateInfoKHR)(s)
	return rval
}
func (s *SamplerYcbcrConversionCreateInfoKHR) Vulkanize() *_vkSamplerYcbcrConversionCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSamplerYcbcrConversionCreateInfoKHR)(s)
	return rval
}

// SamplerYcbcrConversionImageFormatProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionImageFormatProperties.html
type SamplerYcbcrConversionImageFormatProperties struct {
	// SType = STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES
	PNext                               unsafe.Pointer
	CombinedImageSamplerDescriptorCount uint32
}

// WARNING - struct SamplerYcbcrConversionImageFormatProperties is returned only, which is not yet handled in the binding
type _vkSamplerYcbcrConversionImageFormatProperties struct {
	sType                               StructureType
	pNext                               unsafe.Pointer
	combinedImageSamplerDescriptorCount uint32
}

func (s *_vkSamplerYcbcrConversionImageFormatProperties) Goify() *SamplerYcbcrConversionImageFormatProperties {
	rval := &SamplerYcbcrConversionImageFormatProperties{
		PNext:                               (unsafe.Pointer)(s.pNext),
		CombinedImageSamplerDescriptorCount: (uint32)(s.combinedImageSamplerDescriptorCount),
	}
	return rval
}
func (s *SamplerYcbcrConversionImageFormatProperties) Vulkanize() *_vkSamplerYcbcrConversionImageFormatProperties {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerYcbcrConversionImageFormatProperties{
		sType:                               STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, /*c1*/
		pNext:                               (unsafe.Pointer)(s.PNext),                                       /*cb*/
		combinedImageSamplerDescriptorCount: (uint32)(s.CombinedImageSamplerDescriptorCount),                 /*cb*/
	}
	return rval
}

// SamplerYcbcrConversionImageFormatPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionImageFormatPropertiesKHR.html
type SamplerYcbcrConversionImageFormatPropertiesKHR struct {
}

type _vkSamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatPropertiesKHR

func (s *_vkSamplerYcbcrConversionImageFormatPropertiesKHR) Goify() *SamplerYcbcrConversionImageFormatPropertiesKHR {
	rval := (*SamplerYcbcrConversionImageFormatPropertiesKHR)(s)
	return rval
}
func (s *SamplerYcbcrConversionImageFormatPropertiesKHR) Vulkanize() *_vkSamplerYcbcrConversionImageFormatPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSamplerYcbcrConversionImageFormatPropertiesKHR)(s)
	return rval
}

// SamplerYcbcrConversionInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionInfo.html
type SamplerYcbcrConversionInfo struct {
	// SType = STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO
	PNext      unsafe.Pointer
	Conversion SamplerYcbcrConversion
}

type _vkSamplerYcbcrConversionInfo struct {
	sType      StructureType
	pNext      unsafe.Pointer
	conversion SamplerYcbcrConversion
}

func (s *_vkSamplerYcbcrConversionInfo) Goify() *SamplerYcbcrConversionInfo {
	rval := &SamplerYcbcrConversionInfo{
		PNext:      (unsafe.Pointer)(s.pNext),
		Conversion: (SamplerYcbcrConversion)(s.conversion),
	}
	return rval
}
func (s *SamplerYcbcrConversionInfo) Vulkanize() *_vkSamplerYcbcrConversionInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerYcbcrConversionInfo{
		sType:      STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                    /*cb*/
		conversion: (SamplerYcbcrConversion)(s.Conversion),       /*cb*/
	}
	return rval
}

// SamplerYcbcrConversionInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionInfoKHR.html
type SamplerYcbcrConversionInfoKHR struct {
}

type _vkSamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfoKHR

func (s *_vkSamplerYcbcrConversionInfoKHR) Goify() *SamplerYcbcrConversionInfoKHR {
	rval := (*SamplerYcbcrConversionInfoKHR)(s)
	return rval
}
func (s *SamplerYcbcrConversionInfoKHR) Vulkanize() *_vkSamplerYcbcrConversionInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSamplerYcbcrConversionInfoKHR)(s)
	return rval
}

// SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.html
type SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM struct {
	// SType = STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM
	PNext             unsafe.Pointer
	EnableYDegamma    bool
	EnableCbCrDegamma bool
}

type _vkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM struct {
	sType             StructureType
	pNext             unsafe.Pointer
	enableYDegamma    Bool32
	enableCbCrDegamma Bool32
}

func (s *_vkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM) Goify() *SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
	rval := &SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM{
		PNext:             (unsafe.Pointer)(s.pNext),
		EnableYDegamma:    translatePublic_Bool32(s.enableYDegamma),    /*default*/
		EnableCbCrDegamma: translatePublic_Bool32(s.enableCbCrDegamma), /*default*/
	}
	return rval
}
func (s *SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM) Vulkanize() *_vkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM{
		sType:             STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                                              /*cb*/
		enableYDegamma:    translateInternal_Bool32(s.EnableYDegamma),                             /*default*/
		enableCbCrDegamma: translateInternal_Bool32(s.EnableCbCrDegamma),                          /*default*/
	}
	return rval
}

// SemaphoreCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreCreateInfo.html
type SemaphoreCreateInfo struct {
	// SType = STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
	PNext unsafe.Pointer
	//  Semaphore creation flags;
	Flags SemaphoreCreateFlags
}

type _vkSemaphoreCreateInfo struct {
	sType StructureType
	pNext unsafe.Pointer
	flags SemaphoreCreateFlags
}

func (s *_vkSemaphoreCreateInfo) Goify() *SemaphoreCreateInfo {
	rval := &SemaphoreCreateInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (SemaphoreCreateFlags)(s.flags),
	}
	return rval
}
func (s *SemaphoreCreateInfo) Vulkanize() *_vkSemaphoreCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSemaphoreCreateInfo{
		sType: STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),            /*cb*/
		flags: (SemaphoreCreateFlags)(s.Flags),      /*cb*/
	}
	return rval
}

// SemaphoreGetFdInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetFdInfoKHR.html
type SemaphoreGetFdInfoKHR struct {
	// SType = STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR
	PNext      unsafe.Pointer
	Semaphore  Semaphore
	HandleType ExternalSemaphoreHandleTypeFlagBits
}

type _vkSemaphoreGetFdInfoKHR struct {
	sType      StructureType
	pNext      unsafe.Pointer
	semaphore  Semaphore
	handleType ExternalSemaphoreHandleTypeFlagBits
}

func (s *_vkSemaphoreGetFdInfoKHR) Goify() *SemaphoreGetFdInfoKHR {
	rval := &SemaphoreGetFdInfoKHR{
		PNext:      (unsafe.Pointer)(s.pNext),
		Semaphore:  (Semaphore)(s.semaphore),
		HandleType: (ExternalSemaphoreHandleTypeFlagBits)(s.handleType),
	}
	return rval
}
func (s *SemaphoreGetFdInfoKHR) Vulkanize() *_vkSemaphoreGetFdInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkSemaphoreGetFdInfoKHR{
		sType:      STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,            /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                           /*cb*/
		semaphore:  (Semaphore)(s.Semaphore),                            /*cb*/
		handleType: (ExternalSemaphoreHandleTypeFlagBits)(s.HandleType), /*cb*/
	}
	return rval
}

// SemaphoreSignalInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSignalInfo.html
type SemaphoreSignalInfo struct {
	// SType = STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO
	PNext     unsafe.Pointer
	Semaphore Semaphore
	Value     uint64
}

type _vkSemaphoreSignalInfo struct {
	sType     StructureType
	pNext     unsafe.Pointer
	semaphore Semaphore
	value     uint64
}

func (s *_vkSemaphoreSignalInfo) Goify() *SemaphoreSignalInfo {
	rval := &SemaphoreSignalInfo{
		PNext:     (unsafe.Pointer)(s.pNext),
		Semaphore: (Semaphore)(s.semaphore),
		Value:     (uint64)(s.value),
	}
	return rval
}
func (s *SemaphoreSignalInfo) Vulkanize() *_vkSemaphoreSignalInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSemaphoreSignalInfo{
		sType:     STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),            /*cb*/
		semaphore: (Semaphore)(s.Semaphore),             /*cb*/
		value:     (uint64)(s.Value),                    /*cb*/
	}
	return rval
}

// SemaphoreSignalInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSignalInfoKHR.html
type SemaphoreSignalInfoKHR struct {
}

type _vkSemaphoreSignalInfoKHR = SemaphoreSignalInfoKHR

func (s *_vkSemaphoreSignalInfoKHR) Goify() *SemaphoreSignalInfoKHR {
	rval := (*SemaphoreSignalInfoKHR)(s)
	return rval
}
func (s *SemaphoreSignalInfoKHR) Vulkanize() *_vkSemaphoreSignalInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSemaphoreSignalInfoKHR)(s)
	return rval
}

// SemaphoreSubmitInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSubmitInfo.html
type SemaphoreSubmitInfo struct {
	// SType = STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO
	PNext       unsafe.Pointer
	Semaphore   Semaphore
	Value       uint64
	StageMask   PipelineStageFlags2
	DeviceIndex uint32
}

type _vkSemaphoreSubmitInfo struct {
	sType       StructureType
	pNext       unsafe.Pointer
	semaphore   Semaphore
	value       uint64
	stageMask   PipelineStageFlags2
	deviceIndex uint32
}

func (s *_vkSemaphoreSubmitInfo) Goify() *SemaphoreSubmitInfo {
	rval := &SemaphoreSubmitInfo{
		PNext:       (unsafe.Pointer)(s.pNext),
		Semaphore:   (Semaphore)(s.semaphore),
		Value:       (uint64)(s.value),
		StageMask:   (PipelineStageFlags2)(s.stageMask),
		DeviceIndex: (uint32)(s.deviceIndex),
	}
	return rval
}
func (s *SemaphoreSubmitInfo) Vulkanize() *_vkSemaphoreSubmitInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSemaphoreSubmitInfo{
		sType:       STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),            /*cb*/
		semaphore:   (Semaphore)(s.Semaphore),             /*cb*/
		value:       (uint64)(s.Value),                    /*cb*/
		stageMask:   (PipelineStageFlags2)(s.StageMask),   /*cb*/
		deviceIndex: (uint32)(s.DeviceIndex),              /*cb*/
	}
	return rval
}

// SemaphoreSubmitInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSubmitInfoKHR.html
type SemaphoreSubmitInfoKHR struct {
}

type _vkSemaphoreSubmitInfoKHR = SemaphoreSubmitInfoKHR

func (s *_vkSemaphoreSubmitInfoKHR) Goify() *SemaphoreSubmitInfoKHR {
	rval := (*SemaphoreSubmitInfoKHR)(s)
	return rval
}
func (s *SemaphoreSubmitInfoKHR) Vulkanize() *_vkSemaphoreSubmitInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSemaphoreSubmitInfoKHR)(s)
	return rval
}

// SemaphoreTypeCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreTypeCreateInfo.html
type SemaphoreTypeCreateInfo struct {
	// SType = STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO
	PNext         unsafe.Pointer
	SemaphoreType SemaphoreType
	InitialValue  uint64
}

type _vkSemaphoreTypeCreateInfo struct {
	sType         StructureType
	pNext         unsafe.Pointer
	semaphoreType SemaphoreType
	initialValue  uint64
}

func (s *_vkSemaphoreTypeCreateInfo) Goify() *SemaphoreTypeCreateInfo {
	rval := &SemaphoreTypeCreateInfo{
		PNext:         (unsafe.Pointer)(s.pNext),
		SemaphoreType: (SemaphoreType)(s.semaphoreType),
		InitialValue:  (uint64)(s.initialValue),
	}
	return rval
}
func (s *SemaphoreTypeCreateInfo) Vulkanize() *_vkSemaphoreTypeCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSemaphoreTypeCreateInfo{
		sType:         STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                 /*cb*/
		semaphoreType: (SemaphoreType)(s.SemaphoreType),          /*cb*/
		initialValue:  (uint64)(s.InitialValue),                  /*cb*/
	}
	return rval
}

// SemaphoreTypeCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreTypeCreateInfoKHR.html
type SemaphoreTypeCreateInfoKHR struct {
}

type _vkSemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfoKHR

func (s *_vkSemaphoreTypeCreateInfoKHR) Goify() *SemaphoreTypeCreateInfoKHR {
	rval := (*SemaphoreTypeCreateInfoKHR)(s)
	return rval
}
func (s *SemaphoreTypeCreateInfoKHR) Vulkanize() *_vkSemaphoreTypeCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSemaphoreTypeCreateInfoKHR)(s)
	return rval
}

// SemaphoreWaitInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitInfo.html
type SemaphoreWaitInfo struct {
	// SType = STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO
	PNext unsafe.Pointer
	Flags SemaphoreWaitFlags
	// semaphoreCount
	PSemaphores []Semaphore
	PValues     []uint64
}

type _vkSemaphoreWaitInfo struct {
	sType          StructureType
	pNext          unsafe.Pointer
	flags          SemaphoreWaitFlags
	semaphoreCount uint32
	pSemaphores    *Semaphore
	pValues        *uint64
}

func (s *_vkSemaphoreWaitInfo) Goify() *SemaphoreWaitInfo {
	rval := &SemaphoreWaitInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (SemaphoreWaitFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSemaphores in returned struct
		// Unexpected pointer member pValues in returned struct
	}
	return rval
}
func (s *SemaphoreWaitInfo) Vulkanize() *_vkSemaphoreWaitInfo {
	if s == nil {
		return nil
	}

	var psl_pSemaphores *Semaphore
	if len(s.PSemaphores) > 0 {
		psl_pSemaphores = &s.PSemaphores[0]
	}

	var psl_pValues *uint64
	if len(s.PValues) > 0 {
		psl_pValues = &s.PValues[0]
	}
	rval := &_vkSemaphoreWaitInfo{
		sType:       STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),          /*cb*/
		flags:       (SemaphoreWaitFlags)(s.Flags),      /*cb*/
		pSemaphores: psl_pSemaphores,                    /*c rem*/
		pValues:     psl_pValues,                        /*c rem*/
	}
	rval.semaphoreCount = 0 // c6-b
	if uint32(len(s.PSemaphores)) > rval.semaphoreCount {
		rval.semaphoreCount = uint32(len(s.PSemaphores))
	}
	if uint32(len(s.PValues)) > rval.semaphoreCount {
		rval.semaphoreCount = uint32(len(s.PValues))
	}
	return rval
}

// SemaphoreWaitInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitInfoKHR.html
type SemaphoreWaitInfoKHR struct {
}

type _vkSemaphoreWaitInfoKHR = SemaphoreWaitInfoKHR

func (s *_vkSemaphoreWaitInfoKHR) Goify() *SemaphoreWaitInfoKHR {
	rval := (*SemaphoreWaitInfoKHR)(s)
	return rval
}
func (s *SemaphoreWaitInfoKHR) Vulkanize() *_vkSemaphoreWaitInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSemaphoreWaitInfoKHR)(s)
	return rval
}

// SetLatencyMarkerInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSetLatencyMarkerInfoNV.html
type SetLatencyMarkerInfoNV struct {
	// SType = STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV
	PNext     unsafe.Pointer
	PresentID uint64
	Marker    LatencyMarkerNV
}

type _vkSetLatencyMarkerInfoNV struct {
	sType     StructureType
	pNext     unsafe.Pointer
	presentID uint64
	marker    LatencyMarkerNV
}

func (s *_vkSetLatencyMarkerInfoNV) Goify() *SetLatencyMarkerInfoNV {
	rval := &SetLatencyMarkerInfoNV{
		PNext:     (unsafe.Pointer)(s.pNext),
		PresentID: (uint64)(s.presentID),
		Marker:    (LatencyMarkerNV)(s.marker),
	}
	return rval
}
func (s *SetLatencyMarkerInfoNV) Vulkanize() *_vkSetLatencyMarkerInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkSetLatencyMarkerInfoNV{
		sType:     STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                 /*cb*/
		presentID: (uint64)(s.PresentID),                     /*cb*/
		marker:    (LatencyMarkerNV)(s.Marker),               /*cb*/
	}
	return rval
}

// SetStateFlagsIndirectCommandNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html
type SetStateFlagsIndirectCommandNV struct {
	Data uint32
}

type _vkSetStateFlagsIndirectCommandNV = SetStateFlagsIndirectCommandNV

func (s *_vkSetStateFlagsIndirectCommandNV) Goify() *SetStateFlagsIndirectCommandNV {
	rval := (*SetStateFlagsIndirectCommandNV)(s)
	return rval
}
func (s *SetStateFlagsIndirectCommandNV) Vulkanize() *_vkSetStateFlagsIndirectCommandNV {
	if s == nil {
		return nil
	}
	rval := (*_vkSetStateFlagsIndirectCommandNV)(s)
	return rval
}

// ShaderCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCreateInfoEXT.html
type ShaderCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT
	PNext     unsafe.Pointer
	Flags     ShaderCreateFlagsEXT
	Stage     ShaderStageFlagBits
	NextStage ShaderStageFlags
	CodeType  ShaderCodeTypeEXT
	CodeSize  uintptr
	PCode     unsafe.Pointer
	PName     string
	// setLayoutCount
	PSetLayouts []DescriptorSetLayout
	// pushConstantRangeCount
	PPushConstantRanges []PushConstantRange
	PSpecializationInfo *SpecializationInfo
}

type _vkShaderCreateInfoEXT struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	flags                  ShaderCreateFlagsEXT
	stage                  ShaderStageFlagBits
	nextStage              ShaderStageFlags
	codeType               ShaderCodeTypeEXT
	codeSize               uintptr
	pCode                  unsafe.Pointer
	pName                  *byte
	setLayoutCount         uint32
	pSetLayouts            *DescriptorSetLayout
	pushConstantRangeCount uint32
	pPushConstantRanges    *_vkPushConstantRange
	pSpecializationInfo    *_vkSpecializationInfo
}

func (s *_vkShaderCreateInfoEXT) Goify() *ShaderCreateInfoEXT {
	rval := &ShaderCreateInfoEXT{
		PNext:     (unsafe.Pointer)(s.pNext),
		Flags:     (ShaderCreateFlagsEXT)(s.flags),
		Stage:     (ShaderStageFlagBits)(s.stage),
		NextStage: (ShaderStageFlags)(s.nextStage),
		CodeType:  (ShaderCodeTypeEXT)(s.codeType),
		CodeSize:  (uintptr)(s.codeSize),
		PCode:     (unsafe.Pointer)(s.pCode),
		// Unexpected pointer member pName in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSetLayouts in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPushConstantRanges in returned struct
		// Unexpected pointer member pSpecializationInfo in returned struct
	}
	return rval
}
func (s *ShaderCreateInfoEXT) Vulkanize() *_vkShaderCreateInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pSetLayouts *DescriptorSetLayout
	if len(s.PSetLayouts) > 0 {
		psl_pSetLayouts = &s.PSetLayouts[0]
	}

	var psl_pPushConstantRanges *_vkPushConstantRange
	if len(s.PPushConstantRanges) > 0 {
		psl_pPushConstantRanges = &s.PPushConstantRanges[0]
	}
	rval := &_vkShaderCreateInfoEXT{
		sType:                  STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),             /*cb*/
		flags:                  (ShaderCreateFlagsEXT)(s.Flags),       /*cb*/
		stage:                  (ShaderStageFlagBits)(s.Stage),        /*cb*/
		nextStage:              (ShaderStageFlags)(s.NextStage),       /*cb*/
		codeType:               (ShaderCodeTypeEXT)(s.CodeType),       /*cb*/
		codeSize:               (uintptr)(s.CodeSize),                 /*cb*/
		pCode:                  (unsafe.Pointer)(s.PCode),             /*cb*/
		pName:                  sys_stringToBytePointer(s.PName),      /*c rem*/
		setLayoutCount:         uint32(len(s.PSetLayouts)),            /*c6-a*/
		pSetLayouts:            psl_pSetLayouts,                       /*c rem*/
		pushConstantRangeCount: uint32(len(s.PPushConstantRanges)),    /*c6-a*/
		pPushConstantRanges:    psl_pPushConstantRanges,               /*c rem*/
		pSpecializationInfo:    (s.PSpecializationInfo.Vulkanize()),   /*c rem*/
	}
	return rval
}

// ShaderModuleCreateInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleCreateInfo.html
type ShaderModuleCreateInfo struct {
	// SType = STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
	//  noautovalidity because this structure can be either an explicit parameter, or passed in a pNext chain;
	PNext unsafe.Pointer
	Flags ShaderModuleCreateFlags
	//  Specified in bytes;
	CodeSize uintptr
	//  Binary code of size codeSize;
	PCode *uint32
}

type _vkShaderModuleCreateInfo struct {
	sType    StructureType
	pNext    unsafe.Pointer
	flags    ShaderModuleCreateFlags
	codeSize uintptr
	pCode    *uint32
}

func (s *_vkShaderModuleCreateInfo) Goify() *ShaderModuleCreateInfo {
	rval := &ShaderModuleCreateInfo{
		PNext:    (unsafe.Pointer)(s.pNext),
		Flags:    (ShaderModuleCreateFlags)(s.flags),
		CodeSize: (uintptr)(s.codeSize),
		PCode:    (*uint32)(s.pCode),
	}
	return rval
}
func (s *ShaderModuleCreateInfo) Vulkanize() *_vkShaderModuleCreateInfo {
	if s == nil {
		return nil
	}
	rval := &_vkShaderModuleCreateInfo{
		sType:    STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                /*cb*/
		flags:    (ShaderModuleCreateFlags)(s.Flags),       /*cb*/
		codeSize: (uintptr)(s.CodeSize),                    /*cb*/
		pCode:    (*uint32)(s.PCode),                       /*cb*/
	}
	return rval
}

// ShaderModuleIdentifierEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleIdentifierEXT.html
type ShaderModuleIdentifierEXT struct {
	// SType = STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT
	PNext          unsafe.Pointer
	IdentifierSize uint32
	Identifier     [MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]uint8
}

// WARNING - struct ShaderModuleIdentifierEXT is returned only, which is not yet handled in the binding
type _vkShaderModuleIdentifierEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	identifierSize uint32
	identifier     [MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]uint8
}

func (s *_vkShaderModuleIdentifierEXT) Goify() *ShaderModuleIdentifierEXT {
	rval := &ShaderModuleIdentifierEXT{
		PNext:          (unsafe.Pointer)(s.pNext),
		IdentifierSize: (uint32)(s.identifierSize),
		Identifier:     ([MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]uint8)(s.identifier),
	}
	return rval
}
func (s *ShaderModuleIdentifierEXT) Vulkanize() *_vkShaderModuleIdentifierEXT {
	if s == nil {
		return nil
	}
	rval := &_vkShaderModuleIdentifierEXT{
		sType:          STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT,                  /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                                    /*cb*/
		identifierSize: (uint32)(s.IdentifierSize),                                   /*cb*/
		identifier:     ([MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]uint8)(s.Identifier), /*cb*/
	}
	return rval
}

// ShaderModuleValidationCacheCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html
type ShaderModuleValidationCacheCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT
	PNext           unsafe.Pointer
	ValidationCache ValidationCacheEXT
}

type _vkShaderModuleValidationCacheCreateInfoEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	validationCache ValidationCacheEXT
}

func (s *_vkShaderModuleValidationCacheCreateInfoEXT) Goify() *ShaderModuleValidationCacheCreateInfoEXT {
	rval := &ShaderModuleValidationCacheCreateInfoEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		ValidationCache: (ValidationCacheEXT)(s.validationCache),
	}
	return rval
}
func (s *ShaderModuleValidationCacheCreateInfoEXT) Vulkanize() *_vkShaderModuleValidationCacheCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkShaderModuleValidationCacheCreateInfoEXT{
		sType:           STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                     /*cb*/
		validationCache: (ValidationCacheEXT)(s.ValidationCache),                       /*cb*/
	}
	return rval
}

// ShaderRequiredSubgroupSizeCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderRequiredSubgroupSizeCreateInfoEXT.html
type ShaderRequiredSubgroupSizeCreateInfoEXT struct {
}

type _vkShaderRequiredSubgroupSizeCreateInfoEXT = ShaderRequiredSubgroupSizeCreateInfoEXT

func (s *_vkShaderRequiredSubgroupSizeCreateInfoEXT) Goify() *ShaderRequiredSubgroupSizeCreateInfoEXT {
	rval := (*ShaderRequiredSubgroupSizeCreateInfoEXT)(s)
	return rval
}
func (s *ShaderRequiredSubgroupSizeCreateInfoEXT) Vulkanize() *_vkShaderRequiredSubgroupSizeCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkShaderRequiredSubgroupSizeCreateInfoEXT)(s)
	return rval
}

// ShaderResourceUsageAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderResourceUsageAMD.html
type ShaderResourceUsageAMD struct {
	NumUsedVgprs             uint32
	NumUsedSgprs             uint32
	LdsSizePerLocalWorkGroup uint32
	LdsUsageSizeInBytes      uintptr
	ScratchMemUsageInBytes   uintptr
}

type _vkShaderResourceUsageAMD = ShaderResourceUsageAMD

func (s *_vkShaderResourceUsageAMD) Goify() *ShaderResourceUsageAMD {
	rval := (*ShaderResourceUsageAMD)(s)
	return rval
}
func (s *ShaderResourceUsageAMD) Vulkanize() *_vkShaderResourceUsageAMD {
	if s == nil {
		return nil
	}
	rval := (*_vkShaderResourceUsageAMD)(s)
	return rval
}

// ShaderStatisticsInfoAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderStatisticsInfoAMD.html
type ShaderStatisticsInfoAMD struct {
	ShaderStageMask      ShaderStageFlags
	ResourceUsage        ShaderResourceUsageAMD
	NumPhysicalVgprs     uint32
	NumPhysicalSgprs     uint32
	NumAvailableVgprs    uint32
	NumAvailableSgprs    uint32
	ComputeWorkGroupSize [3]uint32
}

// WARNING - struct ShaderStatisticsInfoAMD is returned only, which is not yet handled in the binding
type _vkShaderStatisticsInfoAMD struct {
	shaderStageMask      ShaderStageFlags
	resourceUsage        _vkShaderResourceUsageAMD
	numPhysicalVgprs     uint32
	numPhysicalSgprs     uint32
	numAvailableVgprs    uint32
	numAvailableSgprs    uint32
	computeWorkGroupSize [3]uint32
}

func (s *_vkShaderStatisticsInfoAMD) Goify() *ShaderStatisticsInfoAMD {
	rval := &ShaderStatisticsInfoAMD{
		ShaderStageMask:      (ShaderStageFlags)(s.shaderStageMask),
		ResourceUsage:        (ShaderResourceUsageAMD)(s.resourceUsage),
		NumPhysicalVgprs:     (uint32)(s.numPhysicalVgprs),
		NumPhysicalSgprs:     (uint32)(s.numPhysicalSgprs),
		NumAvailableVgprs:    (uint32)(s.numAvailableVgprs),
		NumAvailableSgprs:    (uint32)(s.numAvailableSgprs),
		ComputeWorkGroupSize: ([3]uint32)(s.computeWorkGroupSize),
	}
	return rval
}
func (s *ShaderStatisticsInfoAMD) Vulkanize() *_vkShaderStatisticsInfoAMD {
	if s == nil {
		return nil
	}
	rval := &_vkShaderStatisticsInfoAMD{
		shaderStageMask:      (ShaderStageFlags)(s.ShaderStageMask),        /*cb*/
		resourceUsage:        (_vkShaderResourceUsageAMD)(s.ResourceUsage), /*cb*/
		numPhysicalVgprs:     (uint32)(s.NumPhysicalVgprs),                 /*cb*/
		numPhysicalSgprs:     (uint32)(s.NumPhysicalSgprs),                 /*cb*/
		numAvailableVgprs:    (uint32)(s.NumAvailableVgprs),                /*cb*/
		numAvailableSgprs:    (uint32)(s.NumAvailableSgprs),                /*cb*/
		computeWorkGroupSize: ([3]uint32)(s.ComputeWorkGroupSize),          /*cb*/
	}
	return rval
}

// ShadingRatePaletteNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShadingRatePaletteNV.html
type ShadingRatePaletteNV struct {
	// shadingRatePaletteEntryCount
	PShadingRatePaletteEntries []ShadingRatePaletteEntryNV
}

type _vkShadingRatePaletteNV struct {
	shadingRatePaletteEntryCount uint32
	pShadingRatePaletteEntries   *ShadingRatePaletteEntryNV
}

func (s *_vkShadingRatePaletteNV) Goify() *ShadingRatePaletteNV {
	rval := &ShadingRatePaletteNV{
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pShadingRatePaletteEntries in returned struct
	}
	return rval
}
func (s *ShadingRatePaletteNV) Vulkanize() *_vkShadingRatePaletteNV {
	if s == nil {
		return nil
	}

	var psl_pShadingRatePaletteEntries *ShadingRatePaletteEntryNV
	if len(s.PShadingRatePaletteEntries) > 0 {
		psl_pShadingRatePaletteEntries = &s.PShadingRatePaletteEntries[0]
	}
	rval := &_vkShadingRatePaletteNV{
		shadingRatePaletteEntryCount: uint32(len(s.PShadingRatePaletteEntries)), /*c6-a*/
		pShadingRatePaletteEntries:   psl_pShadingRatePaletteEntries,            /*c rem*/
	}
	return rval
}

// SharedPresentSurfaceCapabilitiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html
type SharedPresentSurfaceCapabilitiesKHR struct {
	// SType = STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR
	PNext unsafe.Pointer
	//  Supported image usage flags if swapchain created using a shared present mode;
	SharedPresentSupportedUsageFlags ImageUsageFlags
}

// WARNING - struct SharedPresentSurfaceCapabilitiesKHR is returned only, which is not yet handled in the binding
type _vkSharedPresentSurfaceCapabilitiesKHR struct {
	sType                            StructureType
	pNext                            unsafe.Pointer
	sharedPresentSupportedUsageFlags ImageUsageFlags
}

func (s *_vkSharedPresentSurfaceCapabilitiesKHR) Goify() *SharedPresentSurfaceCapabilitiesKHR {
	rval := &SharedPresentSurfaceCapabilitiesKHR{
		PNext:                            (unsafe.Pointer)(s.pNext),
		SharedPresentSupportedUsageFlags: (ImageUsageFlags)(s.sharedPresentSupportedUsageFlags),
	}
	return rval
}
func (s *SharedPresentSurfaceCapabilitiesKHR) Vulkanize() *_vkSharedPresentSurfaceCapabilitiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkSharedPresentSurfaceCapabilitiesKHR{
		sType:                            STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, /*c1*/
		pNext:                            (unsafe.Pointer)(s.PNext),                              /*cb*/
		sharedPresentSupportedUsageFlags: (ImageUsageFlags)(s.SharedPresentSupportedUsageFlags),  /*cb*/
	}
	return rval
}

// SparseBufferMemoryBindInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseBufferMemoryBindInfo.html
type SparseBufferMemoryBindInfo struct {
	Buffer Buffer
	// bindCount
	PBinds []SparseMemoryBind
}

type _vkSparseBufferMemoryBindInfo struct {
	buffer    Buffer
	bindCount uint32
	pBinds    *_vkSparseMemoryBind
}

func (s *_vkSparseBufferMemoryBindInfo) Goify() *SparseBufferMemoryBindInfo {
	rval := &SparseBufferMemoryBindInfo{
		Buffer: (Buffer)(s.buffer),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pBinds in returned struct
	}
	return rval
}
func (s *SparseBufferMemoryBindInfo) Vulkanize() *_vkSparseBufferMemoryBindInfo {
	if s == nil {
		return nil
	}

	var psl_pBinds *_vkSparseMemoryBind
	if len(s.PBinds) > 0 {
		psl_pBinds = &s.PBinds[0]
	}
	rval := &_vkSparseBufferMemoryBindInfo{
		buffer:    (Buffer)(s.Buffer),    /*cb*/
		bindCount: uint32(len(s.PBinds)), /*c6-a*/
		pBinds:    psl_pBinds,            /*c rem*/
	}
	return rval
}

// SparseImageFormatProperties: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties.html
type SparseImageFormatProperties struct {
	AspectMask       ImageAspectFlags
	ImageGranularity Extent3D
	Flags            SparseImageFormatFlags
}

// WARNING - struct SparseImageFormatProperties is returned only, which is not yet handled in the binding
type _vkSparseImageFormatProperties struct {
	aspectMask       ImageAspectFlags
	imageGranularity _vkExtent3D
	flags            SparseImageFormatFlags
}

func (s *_vkSparseImageFormatProperties) Goify() *SparseImageFormatProperties {
	rval := &SparseImageFormatProperties{
		AspectMask:       (ImageAspectFlags)(s.aspectMask),
		ImageGranularity: (Extent3D)(s.imageGranularity),
		Flags:            (SparseImageFormatFlags)(s.flags),
	}
	return rval
}
func (s *SparseImageFormatProperties) Vulkanize() *_vkSparseImageFormatProperties {
	if s == nil {
		return nil
	}
	rval := &_vkSparseImageFormatProperties{
		aspectMask:       (ImageAspectFlags)(s.AspectMask),  /*cb*/
		imageGranularity: (_vkExtent3D)(s.ImageGranularity), /*cb*/
		flags:            (SparseImageFormatFlags)(s.Flags), /*cb*/
	}
	return rval
}

// SparseImageFormatProperties2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties2.html
type SparseImageFormatProperties2 struct {
	// SType = STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2
	PNext      unsafe.Pointer
	Properties SparseImageFormatProperties
}

// WARNING - struct SparseImageFormatProperties2 is returned only, which is not yet handled in the binding
type _vkSparseImageFormatProperties2 struct {
	sType      StructureType
	pNext      unsafe.Pointer
	properties _vkSparseImageFormatProperties
}

func (s *_vkSparseImageFormatProperties2) Goify() *SparseImageFormatProperties2 {
	rval := &SparseImageFormatProperties2{
		PNext:      (unsafe.Pointer)(s.pNext),
		Properties: *(s.properties.Goify()),
	}
	return rval
}
func (s *SparseImageFormatProperties2) Vulkanize() *_vkSparseImageFormatProperties2 {
	if s == nil {
		return nil
	}
	rval := &_vkSparseImageFormatProperties2{
		sType:      STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                       /*cb*/
		properties: *(s.Properties.Vulkanize()),                     /*c3*/
	}
	return rval
}

// SparseImageFormatProperties2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties2KHR.html
type SparseImageFormatProperties2KHR struct {
}

type _vkSparseImageFormatProperties2KHR = SparseImageFormatProperties2KHR

func (s *_vkSparseImageFormatProperties2KHR) Goify() *SparseImageFormatProperties2KHR {
	rval := (*SparseImageFormatProperties2KHR)(s)
	return rval
}
func (s *SparseImageFormatProperties2KHR) Vulkanize() *_vkSparseImageFormatProperties2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSparseImageFormatProperties2KHR)(s)
	return rval
}

// SparseImageMemoryBind: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBind.html
type SparseImageMemoryBind struct {
	Subresource ImageSubresource
	Offset      Offset3D
	Extent      Extent3D
	Memory      DeviceMemory
	//  Specified in bytes;
	MemoryOffset DeviceSize
	Flags        SparseMemoryBindFlags
}

type _vkSparseImageMemoryBind struct {
	subresource  _vkImageSubresource
	offset       _vkOffset3D
	extent       _vkExtent3D
	memory       DeviceMemory
	memoryOffset DeviceSize
	flags        SparseMemoryBindFlags
}

func (s *_vkSparseImageMemoryBind) Goify() *SparseImageMemoryBind {
	rval := &SparseImageMemoryBind{
		Subresource:  (ImageSubresource)(s.subresource),
		Offset:       (Offset3D)(s.offset),
		Extent:       (Extent3D)(s.extent),
		Memory:       (DeviceMemory)(s.memory),
		MemoryOffset: (DeviceSize)(s.memoryOffset),
		Flags:        (SparseMemoryBindFlags)(s.flags),
	}
	return rval
}
func (s *SparseImageMemoryBind) Vulkanize() *_vkSparseImageMemoryBind {
	if s == nil {
		return nil
	}
	rval := &_vkSparseImageMemoryBind{
		subresource:  (_vkImageSubresource)(s.Subresource), /*cb*/
		offset:       (_vkOffset3D)(s.Offset),              /*cb*/
		extent:       (_vkExtent3D)(s.Extent),              /*cb*/
		memory:       (DeviceMemory)(s.Memory),             /*cb*/
		memoryOffset: (DeviceSize)(s.MemoryOffset),         /*cb*/
		flags:        (SparseMemoryBindFlags)(s.Flags),     /*cb*/
	}
	return rval
}

// SparseImageMemoryBindInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBindInfo.html
type SparseImageMemoryBindInfo struct {
	Image Image
	// bindCount
	PBinds []SparseImageMemoryBind
}

type _vkSparseImageMemoryBindInfo struct {
	image     Image
	bindCount uint32
	pBinds    *_vkSparseImageMemoryBind
}

func (s *_vkSparseImageMemoryBindInfo) Goify() *SparseImageMemoryBindInfo {
	rval := &SparseImageMemoryBindInfo{
		Image: (Image)(s.image),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pBinds in returned struct
	}
	return rval
}
func (s *SparseImageMemoryBindInfo) Vulkanize() *_vkSparseImageMemoryBindInfo {
	if s == nil {
		return nil
	}

	var psl_pBinds *_vkSparseImageMemoryBind
	if len(s.PBinds) > 0 {
		sl_pBinds := make([]_vkSparseImageMemoryBind, len(s.PBinds))
		for i, v := range s.PBinds {
			sl_pBinds[i] = *(v.Vulkanize())
		}
		psl_pBinds = &sl_pBinds[0]
	}
	rval := &_vkSparseImageMemoryBindInfo{
		image:     (Image)(s.Image),      /*cb*/
		bindCount: uint32(len(s.PBinds)), /*c6-a*/
		pBinds:    psl_pBinds,            /*c rem*/
	}
	return rval
}

// SparseImageMemoryRequirements: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements.html
type SparseImageMemoryRequirements struct {
	FormatProperties     SparseImageFormatProperties
	ImageMipTailFirstLod uint32
	//  Specified in bytes, must be a multiple of sparse block size in bytes / alignment;
	ImageMipTailSize DeviceSize
	//  Specified in bytes, must be a multiple of sparse block size in bytes / alignment;
	ImageMipTailOffset DeviceSize
	//  Specified in bytes, must be a multiple of sparse block size in bytes / alignment;
	ImageMipTailStride DeviceSize
}

// WARNING - struct SparseImageMemoryRequirements is returned only, which is not yet handled in the binding
type _vkSparseImageMemoryRequirements struct {
	formatProperties     _vkSparseImageFormatProperties
	imageMipTailFirstLod uint32
	imageMipTailSize     DeviceSize
	imageMipTailOffset   DeviceSize
	imageMipTailStride   DeviceSize
}

func (s *_vkSparseImageMemoryRequirements) Goify() *SparseImageMemoryRequirements {
	rval := &SparseImageMemoryRequirements{
		FormatProperties:     *(s.formatProperties.Goify()),
		ImageMipTailFirstLod: (uint32)(s.imageMipTailFirstLod),
		ImageMipTailSize:     (DeviceSize)(s.imageMipTailSize),
		ImageMipTailOffset:   (DeviceSize)(s.imageMipTailOffset),
		ImageMipTailStride:   (DeviceSize)(s.imageMipTailStride),
	}
	return rval
}
func (s *SparseImageMemoryRequirements) Vulkanize() *_vkSparseImageMemoryRequirements {
	if s == nil {
		return nil
	}
	rval := &_vkSparseImageMemoryRequirements{
		formatProperties:     *(s.FormatProperties.Vulkanize()),  /*c3*/
		imageMipTailFirstLod: (uint32)(s.ImageMipTailFirstLod),   /*cb*/
		imageMipTailSize:     (DeviceSize)(s.ImageMipTailSize),   /*cb*/
		imageMipTailOffset:   (DeviceSize)(s.ImageMipTailOffset), /*cb*/
		imageMipTailStride:   (DeviceSize)(s.ImageMipTailStride), /*cb*/
	}
	return rval
}

// SparseImageMemoryRequirements2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements2.html
type SparseImageMemoryRequirements2 struct {
	// SType = STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2
	PNext              unsafe.Pointer
	MemoryRequirements SparseImageMemoryRequirements
}

// WARNING - struct SparseImageMemoryRequirements2 is returned only, which is not yet handled in the binding
type _vkSparseImageMemoryRequirements2 struct {
	sType              StructureType
	pNext              unsafe.Pointer
	memoryRequirements _vkSparseImageMemoryRequirements
}

func (s *_vkSparseImageMemoryRequirements2) Goify() *SparseImageMemoryRequirements2 {
	rval := &SparseImageMemoryRequirements2{
		PNext:              (unsafe.Pointer)(s.pNext),
		MemoryRequirements: *(s.memoryRequirements.Goify()),
	}
	return rval
}
func (s *SparseImageMemoryRequirements2) Vulkanize() *_vkSparseImageMemoryRequirements2 {
	if s == nil {
		return nil
	}
	rval := &_vkSparseImageMemoryRequirements2{
		sType:              STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                         /*cb*/
		memoryRequirements: *(s.MemoryRequirements.Vulkanize()),               /*c3*/
	}
	return rval
}

// SparseImageMemoryRequirements2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements2KHR.html
type SparseImageMemoryRequirements2KHR struct {
}

type _vkSparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2KHR

func (s *_vkSparseImageMemoryRequirements2KHR) Goify() *SparseImageMemoryRequirements2KHR {
	rval := (*SparseImageMemoryRequirements2KHR)(s)
	return rval
}
func (s *SparseImageMemoryRequirements2KHR) Vulkanize() *_vkSparseImageMemoryRequirements2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSparseImageMemoryRequirements2KHR)(s)
	return rval
}

// SparseImageOpaqueMemoryBindInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageOpaqueMemoryBindInfo.html
type SparseImageOpaqueMemoryBindInfo struct {
	Image Image
	// bindCount
	PBinds []SparseMemoryBind
}

type _vkSparseImageOpaqueMemoryBindInfo struct {
	image     Image
	bindCount uint32
	pBinds    *_vkSparseMemoryBind
}

func (s *_vkSparseImageOpaqueMemoryBindInfo) Goify() *SparseImageOpaqueMemoryBindInfo {
	rval := &SparseImageOpaqueMemoryBindInfo{
		Image: (Image)(s.image),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pBinds in returned struct
	}
	return rval
}
func (s *SparseImageOpaqueMemoryBindInfo) Vulkanize() *_vkSparseImageOpaqueMemoryBindInfo {
	if s == nil {
		return nil
	}

	var psl_pBinds *_vkSparseMemoryBind
	if len(s.PBinds) > 0 {
		psl_pBinds = &s.PBinds[0]
	}
	rval := &_vkSparseImageOpaqueMemoryBindInfo{
		image:     (Image)(s.Image),      /*cb*/
		bindCount: uint32(len(s.PBinds)), /*c6-a*/
		pBinds:    psl_pBinds,            /*c rem*/
	}
	return rval
}

// SparseMemoryBind: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseMemoryBind.html
type SparseMemoryBind struct {
	//  Specified in bytes;
	ResourceOffset DeviceSize
	//  Specified in bytes;
	Size   DeviceSize
	Memory DeviceMemory
	//  Specified in bytes;
	MemoryOffset DeviceSize
	Flags        SparseMemoryBindFlags
}

type _vkSparseMemoryBind = SparseMemoryBind

func (s *_vkSparseMemoryBind) Goify() *SparseMemoryBind {
	rval := (*SparseMemoryBind)(s)
	return rval
}
func (s *SparseMemoryBind) Vulkanize() *_vkSparseMemoryBind {
	if s == nil {
		return nil
	}
	rval := (*_vkSparseMemoryBind)(s)
	return rval
}

// SpecializationInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationInfo.html
type SpecializationInfo struct {
	//  Number of entries in the map;
	// mapEntryCount
	//  Array of map entries;
	PMapEntries []SpecializationMapEntry
	//  Size in bytes of pData;
	DataSize uintptr
	//  Pointer to SpecConstant data;
	PData unsafe.Pointer
}

type _vkSpecializationInfo struct {
	mapEntryCount uint32
	pMapEntries   *_vkSpecializationMapEntry
	dataSize      uintptr
	pData         unsafe.Pointer
}

func (s *_vkSpecializationInfo) Goify() *SpecializationInfo {
	rval := &SpecializationInfo{
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pMapEntries in returned struct
		DataSize: (uintptr)(s.dataSize),
		PData:    (unsafe.Pointer)(s.pData),
	}
	return rval
}
func (s *SpecializationInfo) Vulkanize() *_vkSpecializationInfo {
	if s == nil {
		return nil
	}

	var psl_pMapEntries *_vkSpecializationMapEntry
	if len(s.PMapEntries) > 0 {
		psl_pMapEntries = &s.PMapEntries[0]
	}
	rval := &_vkSpecializationInfo{
		mapEntryCount: uint32(len(s.PMapEntries)), /*c6-a*/
		pMapEntries:   psl_pMapEntries,            /*c rem*/
		dataSize:      (uintptr)(s.DataSize),      /*cb*/
		pData:         (unsafe.Pointer)(s.PData),  /*cb*/
	}
	return rval
}

// SpecializationMapEntry: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationMapEntry.html
type SpecializationMapEntry struct {
	//  The SpecConstant ID specified in the BIL;
	ConstantID uint32
	//  Offset of the value in the data block;
	Offset uint32
	//  Size in bytes of the SpecConstant;
	Size uintptr
}

type _vkSpecializationMapEntry = SpecializationMapEntry

func (s *_vkSpecializationMapEntry) Goify() *SpecializationMapEntry {
	rval := (*SpecializationMapEntry)(s)
	return rval
}
func (s *SpecializationMapEntry) Vulkanize() *_vkSpecializationMapEntry {
	if s == nil {
		return nil
	}
	rval := (*_vkSpecializationMapEntry)(s)
	return rval
}

// StencilOpState: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilOpState.html
type StencilOpState struct {
	FailOp      StencilOp
	PassOp      StencilOp
	DepthFailOp StencilOp
	CompareOp   CompareOp
	CompareMask uint32
	WriteMask   uint32
	Reference   uint32
}

type _vkStencilOpState = StencilOpState

func (s *_vkStencilOpState) Goify() *StencilOpState {
	rval := (*StencilOpState)(s)
	return rval
}
func (s *StencilOpState) Vulkanize() *_vkStencilOpState {
	if s == nil {
		return nil
	}
	rval := (*_vkStencilOpState)(s)
	return rval
}

// StridedDeviceAddressRegionKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStridedDeviceAddressRegionKHR.html
type StridedDeviceAddressRegionKHR struct {
	DeviceAddress DeviceAddress
	Stride        DeviceSize
	Size          DeviceSize
}

type _vkStridedDeviceAddressRegionKHR = StridedDeviceAddressRegionKHR

func (s *_vkStridedDeviceAddressRegionKHR) Goify() *StridedDeviceAddressRegionKHR {
	rval := (*StridedDeviceAddressRegionKHR)(s)
	return rval
}
func (s *StridedDeviceAddressRegionKHR) Vulkanize() *_vkStridedDeviceAddressRegionKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkStridedDeviceAddressRegionKHR)(s)
	return rval
}

// SubmitInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo.html
type SubmitInfo struct {
	// SType = STRUCTURE_TYPE_SUBMIT_INFO
	PNext unsafe.Pointer
	// waitSemaphoreCount
	PWaitSemaphores   []Semaphore
	PWaitDstStageMask []PipelineStageFlags
	// commandBufferCount
	PCommandBuffers []CommandBuffer
	// signalSemaphoreCount
	PSignalSemaphores []Semaphore
}

type _vkSubmitInfo struct {
	sType                StructureType
	pNext                unsafe.Pointer
	waitSemaphoreCount   uint32
	pWaitSemaphores      *Semaphore
	pWaitDstStageMask    *PipelineStageFlags
	commandBufferCount   uint32
	pCommandBuffers      *CommandBuffer
	signalSemaphoreCount uint32
	pSignalSemaphores    *Semaphore
}

func (s *_vkSubmitInfo) Goify() *SubmitInfo {
	rval := &SubmitInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pWaitSemaphores in returned struct
		// Unexpected pointer member pWaitDstStageMask in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCommandBuffers in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSignalSemaphores in returned struct
	}
	return rval
}
func (s *SubmitInfo) Vulkanize() *_vkSubmitInfo {
	if s == nil {
		return nil
	}

	var psl_pWaitSemaphores *Semaphore
	if len(s.PWaitSemaphores) > 0 {
		psl_pWaitSemaphores = &s.PWaitSemaphores[0]
	}

	var psl_pWaitDstStageMask *PipelineStageFlags
	if len(s.PWaitDstStageMask) > 0 {
		psl_pWaitDstStageMask = &s.PWaitDstStageMask[0]
	}

	var psl_pCommandBuffers *CommandBuffer
	if len(s.PCommandBuffers) > 0 {
		psl_pCommandBuffers = &s.PCommandBuffers[0]
	}

	var psl_pSignalSemaphores *Semaphore
	if len(s.PSignalSemaphores) > 0 {
		psl_pSignalSemaphores = &s.PSignalSemaphores[0]
	}
	rval := &_vkSubmitInfo{
		sType:                STRUCTURE_TYPE_SUBMIT_INFO,       /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),        /*cb*/
		pWaitSemaphores:      psl_pWaitSemaphores,              /*c rem*/
		pWaitDstStageMask:    psl_pWaitDstStageMask,            /*c rem*/
		commandBufferCount:   uint32(len(s.PCommandBuffers)),   /*c6-a*/
		pCommandBuffers:      psl_pCommandBuffers,              /*c rem*/
		signalSemaphoreCount: uint32(len(s.PSignalSemaphores)), /*c6-a*/
		pSignalSemaphores:    psl_pSignalSemaphores,            /*c rem*/
	}
	rval.waitSemaphoreCount = 0 // c6-b
	if uint32(len(s.PWaitSemaphores)) > rval.waitSemaphoreCount {
		rval.waitSemaphoreCount = uint32(len(s.PWaitSemaphores))
	}
	if uint32(len(s.PWaitDstStageMask)) > rval.waitSemaphoreCount {
		rval.waitSemaphoreCount = uint32(len(s.PWaitDstStageMask))
	}
	return rval
}

// SubmitInfo2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo2.html
type SubmitInfo2 struct {
	// SType = STRUCTURE_TYPE_SUBMIT_INFO_2
	PNext unsafe.Pointer
	Flags SubmitFlags
	// waitSemaphoreInfoCount
	PWaitSemaphoreInfos []SemaphoreSubmitInfo
	// commandBufferInfoCount
	PCommandBufferInfos []CommandBufferSubmitInfo
	// signalSemaphoreInfoCount
	PSignalSemaphoreInfos []SemaphoreSubmitInfo
}

type _vkSubmitInfo2 struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	flags                    SubmitFlags
	waitSemaphoreInfoCount   uint32
	pWaitSemaphoreInfos      *_vkSemaphoreSubmitInfo
	commandBufferInfoCount   uint32
	pCommandBufferInfos      *_vkCommandBufferSubmitInfo
	signalSemaphoreInfoCount uint32
	pSignalSemaphoreInfos    *_vkSemaphoreSubmitInfo
}

func (s *_vkSubmitInfo2) Goify() *SubmitInfo2 {
	rval := &SubmitInfo2{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (SubmitFlags)(s.flags),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pWaitSemaphoreInfos in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pCommandBufferInfos in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSignalSemaphoreInfos in returned struct
	}
	return rval
}
func (s *SubmitInfo2) Vulkanize() *_vkSubmitInfo2 {
	if s == nil {
		return nil
	}

	var psl_pWaitSemaphoreInfos *_vkSemaphoreSubmitInfo
	if len(s.PWaitSemaphoreInfos) > 0 {
		sl_pWaitSemaphoreInfos := make([]_vkSemaphoreSubmitInfo, len(s.PWaitSemaphoreInfos))
		for i, v := range s.PWaitSemaphoreInfos {
			sl_pWaitSemaphoreInfos[i] = *(v.Vulkanize())
		}
		psl_pWaitSemaphoreInfos = &sl_pWaitSemaphoreInfos[0]
	}

	var psl_pCommandBufferInfos *_vkCommandBufferSubmitInfo
	if len(s.PCommandBufferInfos) > 0 {
		sl_pCommandBufferInfos := make([]_vkCommandBufferSubmitInfo, len(s.PCommandBufferInfos))
		for i, v := range s.PCommandBufferInfos {
			sl_pCommandBufferInfos[i] = *(v.Vulkanize())
		}
		psl_pCommandBufferInfos = &sl_pCommandBufferInfos[0]
	}

	var psl_pSignalSemaphoreInfos *_vkSemaphoreSubmitInfo
	if len(s.PSignalSemaphoreInfos) > 0 {
		sl_pSignalSemaphoreInfos := make([]_vkSemaphoreSubmitInfo, len(s.PSignalSemaphoreInfos))
		for i, v := range s.PSignalSemaphoreInfos {
			sl_pSignalSemaphoreInfos[i] = *(v.Vulkanize())
		}
		psl_pSignalSemaphoreInfos = &sl_pSignalSemaphoreInfos[0]
	}
	rval := &_vkSubmitInfo2{
		sType:                    STRUCTURE_TYPE_SUBMIT_INFO_2,         /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),            /*cb*/
		flags:                    (SubmitFlags)(s.Flags),               /*cb*/
		waitSemaphoreInfoCount:   uint32(len(s.PWaitSemaphoreInfos)),   /*c6-a*/
		pWaitSemaphoreInfos:      psl_pWaitSemaphoreInfos,              /*c rem*/
		commandBufferInfoCount:   uint32(len(s.PCommandBufferInfos)),   /*c6-a*/
		pCommandBufferInfos:      psl_pCommandBufferInfos,              /*c rem*/
		signalSemaphoreInfoCount: uint32(len(s.PSignalSemaphoreInfos)), /*c6-a*/
		pSignalSemaphoreInfos:    psl_pSignalSemaphoreInfos,            /*c rem*/
	}
	return rval
}

// SubmitInfo2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo2KHR.html
type SubmitInfo2KHR struct {
}

type _vkSubmitInfo2KHR = SubmitInfo2KHR

func (s *_vkSubmitInfo2KHR) Goify() *SubmitInfo2KHR {
	rval := (*SubmitInfo2KHR)(s)
	return rval
}
func (s *SubmitInfo2KHR) Vulkanize() *_vkSubmitInfo2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSubmitInfo2KHR)(s)
	return rval
}

// SubpassBeginInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassBeginInfo.html
type SubpassBeginInfo struct {
	// SType = STRUCTURE_TYPE_SUBPASS_BEGIN_INFO
	PNext    unsafe.Pointer
	Contents SubpassContents
}

type _vkSubpassBeginInfo struct {
	sType    StructureType
	pNext    unsafe.Pointer
	contents SubpassContents
}

func (s *_vkSubpassBeginInfo) Goify() *SubpassBeginInfo {
	rval := &SubpassBeginInfo{
		PNext:    (unsafe.Pointer)(s.pNext),
		Contents: (SubpassContents)(s.contents),
	}
	return rval
}
func (s *SubpassBeginInfo) Vulkanize() *_vkSubpassBeginInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSubpassBeginInfo{
		sType:    STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),         /*cb*/
		contents: (SubpassContents)(s.Contents),     /*cb*/
	}
	return rval
}

// SubpassBeginInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassBeginInfoKHR.html
type SubpassBeginInfoKHR struct {
}

type _vkSubpassBeginInfoKHR = SubpassBeginInfoKHR

func (s *_vkSubpassBeginInfoKHR) Goify() *SubpassBeginInfoKHR {
	rval := (*SubpassBeginInfoKHR)(s)
	return rval
}
func (s *SubpassBeginInfoKHR) Vulkanize() *_vkSubpassBeginInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSubpassBeginInfoKHR)(s)
	return rval
}

// SubpassDependency: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency.html
type SubpassDependency struct {
	SrcSubpass   uint32
	DstSubpass   uint32
	SrcStageMask PipelineStageFlags
	DstStageMask PipelineStageFlags
	//  Memory accesses from the source of the dependency to synchronize;
	SrcAccessMask AccessFlags
	//  Memory accesses from the destination of the dependency to synchronize;
	DstAccessMask   AccessFlags
	DependencyFlags DependencyFlags
}

type _vkSubpassDependency = SubpassDependency

func (s *_vkSubpassDependency) Goify() *SubpassDependency {
	rval := (*SubpassDependency)(s)
	return rval
}
func (s *SubpassDependency) Vulkanize() *_vkSubpassDependency {
	if s == nil {
		return nil
	}
	rval := (*_vkSubpassDependency)(s)
	return rval
}

// SubpassDependency2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency2.html
type SubpassDependency2 struct {
	// SType = STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2
	PNext           unsafe.Pointer
	SrcSubpass      uint32
	DstSubpass      uint32
	SrcStageMask    PipelineStageFlags
	DstStageMask    PipelineStageFlags
	SrcAccessMask   AccessFlags
	DstAccessMask   AccessFlags
	DependencyFlags DependencyFlags
	ViewOffset      int32
}

type _vkSubpassDependency2 struct {
	sType           StructureType
	pNext           unsafe.Pointer
	srcSubpass      uint32
	dstSubpass      uint32
	srcStageMask    PipelineStageFlags
	dstStageMask    PipelineStageFlags
	srcAccessMask   AccessFlags
	dstAccessMask   AccessFlags
	dependencyFlags DependencyFlags
	viewOffset      int32
}

func (s *_vkSubpassDependency2) Goify() *SubpassDependency2 {
	rval := &SubpassDependency2{
		PNext:           (unsafe.Pointer)(s.pNext),
		SrcSubpass:      (uint32)(s.srcSubpass),
		DstSubpass:      (uint32)(s.dstSubpass),
		SrcStageMask:    (PipelineStageFlags)(s.srcStageMask),
		DstStageMask:    (PipelineStageFlags)(s.dstStageMask),
		SrcAccessMask:   (AccessFlags)(s.srcAccessMask),
		DstAccessMask:   (AccessFlags)(s.dstAccessMask),
		DependencyFlags: (DependencyFlags)(s.dependencyFlags),
		ViewOffset:      (int32)(s.viewOffset),
	}
	return rval
}
func (s *SubpassDependency2) Vulkanize() *_vkSubpassDependency2 {
	if s == nil {
		return nil
	}
	rval := &_vkSubpassDependency2{
		sType:           STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,  /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),            /*cb*/
		srcSubpass:      (uint32)(s.SrcSubpass),               /*cb*/
		dstSubpass:      (uint32)(s.DstSubpass),               /*cb*/
		srcStageMask:    (PipelineStageFlags)(s.SrcStageMask), /*cb*/
		dstStageMask:    (PipelineStageFlags)(s.DstStageMask), /*cb*/
		srcAccessMask:   (AccessFlags)(s.SrcAccessMask),       /*cb*/
		dstAccessMask:   (AccessFlags)(s.DstAccessMask),       /*cb*/
		dependencyFlags: (DependencyFlags)(s.DependencyFlags), /*cb*/
		viewOffset:      (int32)(s.ViewOffset),                /*cb*/
	}
	return rval
}

// SubpassDependency2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency2KHR.html
type SubpassDependency2KHR struct {
}

type _vkSubpassDependency2KHR = SubpassDependency2KHR

func (s *_vkSubpassDependency2KHR) Goify() *SubpassDependency2KHR {
	rval := (*SubpassDependency2KHR)(s)
	return rval
}
func (s *SubpassDependency2KHR) Vulkanize() *_vkSubpassDependency2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSubpassDependency2KHR)(s)
	return rval
}

// SubpassDescription: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription.html
type SubpassDescription struct {
	Flags SubpassDescriptionFlags
	//  Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now;
	PipelineBindPoint PipelineBindPoint
	// inputAttachmentCount
	PInputAttachments []AttachmentReference
	// colorAttachmentCount
	PColorAttachments       []AttachmentReference
	PResolveAttachments     []AttachmentReference
	PDepthStencilAttachment *AttachmentReference
	// preserveAttachmentCount
	PPreserveAttachments []uint32
}

type _vkSubpassDescription struct {
	flags                   SubpassDescriptionFlags
	pipelineBindPoint       PipelineBindPoint
	inputAttachmentCount    uint32
	pInputAttachments       *_vkAttachmentReference
	colorAttachmentCount    uint32
	pColorAttachments       *_vkAttachmentReference
	pResolveAttachments     *_vkAttachmentReference
	pDepthStencilAttachment *_vkAttachmentReference
	preserveAttachmentCount uint32
	pPreserveAttachments    *uint32
}

func (s *_vkSubpassDescription) Goify() *SubpassDescription {
	rval := &SubpassDescription{
		Flags:             (SubpassDescriptionFlags)(s.flags),
		PipelineBindPoint: (PipelineBindPoint)(s.pipelineBindPoint),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pInputAttachments in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pColorAttachments in returned struct
		// Unexpected pointer member pResolveAttachments in returned struct
		PDepthStencilAttachment: (*AttachmentReference)(s.pDepthStencilAttachment),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPreserveAttachments in returned struct
	}
	return rval
}
func (s *SubpassDescription) Vulkanize() *_vkSubpassDescription {
	if s == nil {
		return nil
	}

	var psl_pInputAttachments *_vkAttachmentReference
	if len(s.PInputAttachments) > 0 {
		psl_pInputAttachments = &s.PInputAttachments[0]
	}

	var psl_pColorAttachments *_vkAttachmentReference
	if len(s.PColorAttachments) > 0 {
		psl_pColorAttachments = &s.PColorAttachments[0]
	}

	var psl_pResolveAttachments *_vkAttachmentReference
	if len(s.PResolveAttachments) > 0 {
		psl_pResolveAttachments = &s.PResolveAttachments[0]
	}

	var psl_pPreserveAttachments *uint32
	if len(s.PPreserveAttachments) > 0 {
		psl_pPreserveAttachments = &s.PPreserveAttachments[0]
	}
	rval := &_vkSubpassDescription{
		flags:                   (SubpassDescriptionFlags)(s.Flags),                   /*cb*/
		pipelineBindPoint:       (PipelineBindPoint)(s.PipelineBindPoint),             /*cb*/
		inputAttachmentCount:    uint32(len(s.PInputAttachments)),                     /*c6-a*/
		pInputAttachments:       psl_pInputAttachments,                                /*c rem*/
		pColorAttachments:       psl_pColorAttachments,                                /*c rem*/
		pResolveAttachments:     psl_pResolveAttachments,                              /*c rem*/
		pDepthStencilAttachment: (*_vkAttachmentReference)(s.PDepthStencilAttachment), /*cb*/
		preserveAttachmentCount: uint32(len(s.PPreserveAttachments)),                  /*c6-a*/
		pPreserveAttachments:    psl_pPreserveAttachments,                             /*c rem*/
	}
	rval.colorAttachmentCount = 0 // c6-b
	if uint32(len(s.PColorAttachments)) > rval.colorAttachmentCount {
		rval.colorAttachmentCount = uint32(len(s.PColorAttachments))
	}
	if uint32(len(s.PResolveAttachments)) > rval.colorAttachmentCount {
		rval.colorAttachmentCount = uint32(len(s.PResolveAttachments))
	}
	return rval
}

// SubpassDescription2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription2.html
type SubpassDescription2 struct {
	// SType = STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2
	PNext             unsafe.Pointer
	Flags             SubpassDescriptionFlags
	PipelineBindPoint PipelineBindPoint
	ViewMask          uint32
	// inputAttachmentCount
	PInputAttachments []AttachmentReference2
	// colorAttachmentCount
	PColorAttachments       []AttachmentReference2
	PResolveAttachments     []AttachmentReference2
	PDepthStencilAttachment *AttachmentReference2
	// preserveAttachmentCount
	PPreserveAttachments []uint32
}

type _vkSubpassDescription2 struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	flags                   SubpassDescriptionFlags
	pipelineBindPoint       PipelineBindPoint
	viewMask                uint32
	inputAttachmentCount    uint32
	pInputAttachments       *_vkAttachmentReference2
	colorAttachmentCount    uint32
	pColorAttachments       *_vkAttachmentReference2
	pResolveAttachments     *_vkAttachmentReference2
	pDepthStencilAttachment *_vkAttachmentReference2
	preserveAttachmentCount uint32
	pPreserveAttachments    *uint32
}

func (s *_vkSubpassDescription2) Goify() *SubpassDescription2 {
	rval := &SubpassDescription2{
		PNext:             (unsafe.Pointer)(s.pNext),
		Flags:             (SubpassDescriptionFlags)(s.flags),
		PipelineBindPoint: (PipelineBindPoint)(s.pipelineBindPoint),
		ViewMask:          (uint32)(s.viewMask),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pInputAttachments in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pColorAttachments in returned struct
		// Unexpected pointer member pResolveAttachments in returned struct
		// Unexpected pointer member pDepthStencilAttachment in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPreserveAttachments in returned struct
	}
	return rval
}
func (s *SubpassDescription2) Vulkanize() *_vkSubpassDescription2 {
	if s == nil {
		return nil
	}

	var psl_pInputAttachments *_vkAttachmentReference2
	if len(s.PInputAttachments) > 0 {
		sl_pInputAttachments := make([]_vkAttachmentReference2, len(s.PInputAttachments))
		for i, v := range s.PInputAttachments {
			sl_pInputAttachments[i] = *(v.Vulkanize())
		}
		psl_pInputAttachments = &sl_pInputAttachments[0]
	}

	var psl_pColorAttachments *_vkAttachmentReference2
	if len(s.PColorAttachments) > 0 {
		sl_pColorAttachments := make([]_vkAttachmentReference2, len(s.PColorAttachments))
		for i, v := range s.PColorAttachments {
			sl_pColorAttachments[i] = *(v.Vulkanize())
		}
		psl_pColorAttachments = &sl_pColorAttachments[0]
	}

	var psl_pResolveAttachments *_vkAttachmentReference2
	if len(s.PResolveAttachments) > 0 {
		sl_pResolveAttachments := make([]_vkAttachmentReference2, len(s.PResolveAttachments))
		for i, v := range s.PResolveAttachments {
			sl_pResolveAttachments[i] = *(v.Vulkanize())
		}
		psl_pResolveAttachments = &sl_pResolveAttachments[0]
	}

	var psl_pPreserveAttachments *uint32
	if len(s.PPreserveAttachments) > 0 {
		psl_pPreserveAttachments = &s.PPreserveAttachments[0]
	}
	rval := &_vkSubpassDescription2{
		sType:                   STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,     /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                /*cb*/
		flags:                   (SubpassDescriptionFlags)(s.Flags),       /*cb*/
		pipelineBindPoint:       (PipelineBindPoint)(s.PipelineBindPoint), /*cb*/
		viewMask:                (uint32)(s.ViewMask),                     /*cb*/
		inputAttachmentCount:    uint32(len(s.PInputAttachments)),         /*c6-a*/
		pInputAttachments:       psl_pInputAttachments,                    /*c rem*/
		pColorAttachments:       psl_pColorAttachments,                    /*c rem*/
		pResolveAttachments:     psl_pResolveAttachments,                  /*c rem*/
		pDepthStencilAttachment: (s.PDepthStencilAttachment.Vulkanize()),  /*c rem*/
		preserveAttachmentCount: uint32(len(s.PPreserveAttachments)),      /*c6-a*/
		pPreserveAttachments:    psl_pPreserveAttachments,                 /*c rem*/
	}
	rval.colorAttachmentCount = 0 // c6-b
	if uint32(len(s.PColorAttachments)) > rval.colorAttachmentCount {
		rval.colorAttachmentCount = uint32(len(s.PColorAttachments))
	}
	if uint32(len(s.PResolveAttachments)) > rval.colorAttachmentCount {
		rval.colorAttachmentCount = uint32(len(s.PResolveAttachments))
	}
	return rval
}

// SubpassDescription2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription2KHR.html
type SubpassDescription2KHR struct {
}

type _vkSubpassDescription2KHR = SubpassDescription2KHR

func (s *_vkSubpassDescription2KHR) Goify() *SubpassDescription2KHR {
	rval := (*SubpassDescription2KHR)(s)
	return rval
}
func (s *SubpassDescription2KHR) Vulkanize() *_vkSubpassDescription2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSubpassDescription2KHR)(s)
	return rval
}

// SubpassDescriptionDepthStencilResolve: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionDepthStencilResolve.html
type SubpassDescriptionDepthStencilResolve struct {
	// SType = STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE
	PNext unsafe.Pointer
	//  depth resolve mode;
	DepthResolveMode ResolveModeFlagBits
	//  stencil resolve mode;
	StencilResolveMode ResolveModeFlagBits
	//  depth/stencil resolve attachment;
	PDepthStencilResolveAttachment *AttachmentReference2
}

type _vkSubpassDescriptionDepthStencilResolve struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	depthResolveMode               ResolveModeFlagBits
	stencilResolveMode             ResolveModeFlagBits
	pDepthStencilResolveAttachment *_vkAttachmentReference2
}

func (s *_vkSubpassDescriptionDepthStencilResolve) Goify() *SubpassDescriptionDepthStencilResolve {
	rval := &SubpassDescriptionDepthStencilResolve{
		PNext:              (unsafe.Pointer)(s.pNext),
		DepthResolveMode:   (ResolveModeFlagBits)(s.depthResolveMode),
		StencilResolveMode: (ResolveModeFlagBits)(s.stencilResolveMode),
		// Unexpected pointer member pDepthStencilResolveAttachment in returned struct
	}
	return rval
}
func (s *SubpassDescriptionDepthStencilResolve) Vulkanize() *_vkSubpassDescriptionDepthStencilResolve {
	if s == nil {
		return nil
	}
	rval := &_vkSubpassDescriptionDepthStencilResolve{
		sType:                          STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                /*cb*/
		depthResolveMode:               (ResolveModeFlagBits)(s.DepthResolveMode),                /*cb*/
		stencilResolveMode:             (ResolveModeFlagBits)(s.StencilResolveMode),              /*cb*/
		pDepthStencilResolveAttachment: (s.PDepthStencilResolveAttachment.Vulkanize()),           /*c rem*/
	}
	return rval
}

// SubpassDescriptionDepthStencilResolveKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionDepthStencilResolveKHR.html
type SubpassDescriptionDepthStencilResolveKHR struct {
}

type _vkSubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolveKHR

func (s *_vkSubpassDescriptionDepthStencilResolveKHR) Goify() *SubpassDescriptionDepthStencilResolveKHR {
	rval := (*SubpassDescriptionDepthStencilResolveKHR)(s)
	return rval
}
func (s *SubpassDescriptionDepthStencilResolveKHR) Vulkanize() *_vkSubpassDescriptionDepthStencilResolveKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSubpassDescriptionDepthStencilResolveKHR)(s)
	return rval
}

// SubpassEndInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassEndInfo.html
type SubpassEndInfo struct {
	// SType = STRUCTURE_TYPE_SUBPASS_END_INFO
	PNext unsafe.Pointer
}

type _vkSubpassEndInfo struct {
	sType StructureType
	pNext unsafe.Pointer
}

func (s *_vkSubpassEndInfo) Goify() *SubpassEndInfo {
	rval := &SubpassEndInfo{
		PNext: (unsafe.Pointer)(s.pNext),
	}
	return rval
}
func (s *SubpassEndInfo) Vulkanize() *_vkSubpassEndInfo {
	if s == nil {
		return nil
	}
	rval := &_vkSubpassEndInfo{
		sType: STRUCTURE_TYPE_SUBPASS_END_INFO, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),       /*cb*/
	}
	return rval
}

// SubpassEndInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassEndInfoKHR.html
type SubpassEndInfoKHR struct {
}

type _vkSubpassEndInfoKHR = SubpassEndInfoKHR

func (s *_vkSubpassEndInfoKHR) Goify() *SubpassEndInfoKHR {
	rval := (*SubpassEndInfoKHR)(s)
	return rval
}
func (s *SubpassEndInfoKHR) Vulkanize() *_vkSubpassEndInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSubpassEndInfoKHR)(s)
	return rval
}

// SubpassFragmentDensityMapOffsetEndInfoQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassFragmentDensityMapOffsetEndInfoQCOM.html
type SubpassFragmentDensityMapOffsetEndInfoQCOM struct {
	// SType = STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM
	PNext unsafe.Pointer
	// fragmentDensityOffsetCount
	PFragmentDensityOffsets []Offset2D
}

type _vkSubpassFragmentDensityMapOffsetEndInfoQCOM struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	fragmentDensityOffsetCount uint32
	pFragmentDensityOffsets    *_vkOffset2D
}

func (s *_vkSubpassFragmentDensityMapOffsetEndInfoQCOM) Goify() *SubpassFragmentDensityMapOffsetEndInfoQCOM {
	rval := &SubpassFragmentDensityMapOffsetEndInfoQCOM{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pFragmentDensityOffsets in returned struct
	}
	return rval
}
func (s *SubpassFragmentDensityMapOffsetEndInfoQCOM) Vulkanize() *_vkSubpassFragmentDensityMapOffsetEndInfoQCOM {
	if s == nil {
		return nil
	}

	var psl_pFragmentDensityOffsets *_vkOffset2D
	if len(s.PFragmentDensityOffsets) > 0 {
		psl_pFragmentDensityOffsets = &s.PFragmentDensityOffsets[0]
	}
	rval := &_vkSubpassFragmentDensityMapOffsetEndInfoQCOM{
		sType:                      STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                        /*cb*/
		fragmentDensityOffsetCount: uint32(len(s.PFragmentDensityOffsets)),                           /*c6-a*/
		pFragmentDensityOffsets:    psl_pFragmentDensityOffsets,                                      /*c rem*/
	}
	return rval
}

// SubpassResolvePerformanceQueryEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassResolvePerformanceQueryEXT.html
type SubpassResolvePerformanceQueryEXT struct {
	// SType = STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT
	PNext   unsafe.Pointer
	Optimal bool
}

// WARNING - struct SubpassResolvePerformanceQueryEXT is returned only, which is not yet handled in the binding
type _vkSubpassResolvePerformanceQueryEXT struct {
	sType   StructureType
	pNext   unsafe.Pointer
	optimal Bool32
}

func (s *_vkSubpassResolvePerformanceQueryEXT) Goify() *SubpassResolvePerformanceQueryEXT {
	rval := &SubpassResolvePerformanceQueryEXT{
		PNext:   (unsafe.Pointer)(s.pNext),
		Optimal: translatePublic_Bool32(s.optimal), /*default*/
	}
	return rval
}
func (s *SubpassResolvePerformanceQueryEXT) Vulkanize() *_vkSubpassResolvePerformanceQueryEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSubpassResolvePerformanceQueryEXT{
		sType:   STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT, /*c1*/
		pNext:   (unsafe.Pointer)(s.PNext),                            /*cb*/
		optimal: translateInternal_Bool32(s.Optimal),                  /*default*/
	}
	return rval
}

// SubpassSampleLocationsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassSampleLocationsEXT.html
type SubpassSampleLocationsEXT struct {
	SubpassIndex        uint32
	SampleLocationsInfo SampleLocationsInfoEXT
}

type _vkSubpassSampleLocationsEXT struct {
	subpassIndex        uint32
	sampleLocationsInfo _vkSampleLocationsInfoEXT
}

func (s *_vkSubpassSampleLocationsEXT) Goify() *SubpassSampleLocationsEXT {
	rval := &SubpassSampleLocationsEXT{
		SubpassIndex:        (uint32)(s.subpassIndex),
		SampleLocationsInfo: *(s.sampleLocationsInfo.Goify()),
	}
	return rval
}
func (s *SubpassSampleLocationsEXT) Vulkanize() *_vkSubpassSampleLocationsEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSubpassSampleLocationsEXT{
		subpassIndex:        (uint32)(s.SubpassIndex),             /*cb*/
		sampleLocationsInfo: *(s.SampleLocationsInfo.Vulkanize()), /*c3*/
	}
	return rval
}

// SubpassShadingPipelineCreateInfoHUAWEI: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassShadingPipelineCreateInfoHUAWEI.html
type SubpassShadingPipelineCreateInfoHUAWEI struct {
	// SType = STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI
	PNext      unsafe.Pointer
	RenderPass RenderPass
	Subpass    uint32
}

// WARNING - struct SubpassShadingPipelineCreateInfoHUAWEI is returned only, which is not yet handled in the binding
type _vkSubpassShadingPipelineCreateInfoHUAWEI struct {
	sType      StructureType
	pNext      unsafe.Pointer
	renderPass RenderPass
	subpass    uint32
}

func (s *_vkSubpassShadingPipelineCreateInfoHUAWEI) Goify() *SubpassShadingPipelineCreateInfoHUAWEI {
	rval := &SubpassShadingPipelineCreateInfoHUAWEI{
		PNext:      (unsafe.Pointer)(s.pNext),
		RenderPass: (RenderPass)(s.renderPass),
		Subpass:    (uint32)(s.subpass),
	}
	return rval
}
func (s *SubpassShadingPipelineCreateInfoHUAWEI) Vulkanize() *_vkSubpassShadingPipelineCreateInfoHUAWEI {
	if s == nil {
		return nil
	}
	rval := &_vkSubpassShadingPipelineCreateInfoHUAWEI{
		sType:      STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI, /*c1*/
		pNext:      (unsafe.Pointer)(s.PNext),                                  /*cb*/
		renderPass: (RenderPass)(s.RenderPass),                                 /*cb*/
		subpass:    (uint32)(s.Subpass),                                        /*cb*/
	}
	return rval
}

// SubresourceHostMemcpySizeEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceHostMemcpySizeEXT.html
type SubresourceHostMemcpySizeEXT struct {
	// SType = STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT
	PNext unsafe.Pointer
	//  Specified in bytes;
	Size DeviceSize
}

// WARNING - struct SubresourceHostMemcpySizeEXT is returned only, which is not yet handled in the binding
type _vkSubresourceHostMemcpySizeEXT struct {
	sType StructureType
	pNext unsafe.Pointer
	size  DeviceSize
}

func (s *_vkSubresourceHostMemcpySizeEXT) Goify() *SubresourceHostMemcpySizeEXT {
	rval := &SubresourceHostMemcpySizeEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		Size:  (DeviceSize)(s.size),
	}
	return rval
}
func (s *SubresourceHostMemcpySizeEXT) Vulkanize() *_vkSubresourceHostMemcpySizeEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSubresourceHostMemcpySizeEXT{
		sType: STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                       /*cb*/
		size:  (DeviceSize)(s.Size),                            /*cb*/
	}
	return rval
}

// SubresourceLayout: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout.html
type SubresourceLayout struct {
	//  Specified in bytes;
	Offset DeviceSize
	//  Specified in bytes;
	Size DeviceSize
	//  Specified in bytes;
	RowPitch DeviceSize
	//  Specified in bytes;
	ArrayPitch DeviceSize
	//  Specified in bytes;
	DepthPitch DeviceSize
}

type _vkSubresourceLayout = SubresourceLayout

func (s *_vkSubresourceLayout) Goify() *SubresourceLayout {
	rval := (*SubresourceLayout)(s)
	return rval
}
func (s *SubresourceLayout) Vulkanize() *_vkSubresourceLayout {
	if s == nil {
		return nil
	}
	rval := (*_vkSubresourceLayout)(s)
	return rval
}

// SubresourceLayout2EXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout2EXT.html
type SubresourceLayout2EXT struct {
}

type _vkSubresourceLayout2EXT = SubresourceLayout2EXT

func (s *_vkSubresourceLayout2EXT) Goify() *SubresourceLayout2EXT {
	rval := (*SubresourceLayout2EXT)(s)
	return rval
}
func (s *SubresourceLayout2EXT) Vulkanize() *_vkSubresourceLayout2EXT {
	if s == nil {
		return nil
	}
	rval := (*_vkSubresourceLayout2EXT)(s)
	return rval
}

// SubresourceLayout2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout2KHR.html
type SubresourceLayout2KHR struct {
	// SType = STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR
	PNext             unsafe.Pointer
	SubresourceLayout SubresourceLayout
}

// WARNING - struct SubresourceLayout2KHR is returned only, which is not yet handled in the binding
type _vkSubresourceLayout2KHR struct {
	sType             StructureType
	pNext             unsafe.Pointer
	subresourceLayout _vkSubresourceLayout
}

func (s *_vkSubresourceLayout2KHR) Goify() *SubresourceLayout2KHR {
	rval := &SubresourceLayout2KHR{
		PNext:             (unsafe.Pointer)(s.pNext),
		SubresourceLayout: (SubresourceLayout)(s.subresourceLayout),
	}
	return rval
}
func (s *SubresourceLayout2KHR) Vulkanize() *_vkSubresourceLayout2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkSubresourceLayout2KHR{
		sType:             STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR,     /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                   /*cb*/
		subresourceLayout: (_vkSubresourceLayout)(s.SubresourceLayout), /*cb*/
	}
	return rval
}

// SurfaceCapabilities2EXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilities2EXT.html
type SurfaceCapabilities2EXT struct {
	// SType = STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
	PNext unsafe.Pointer
	//  Supported minimum number of images for the surface;
	MinImageCount uint32
	//  Supported maximum number of images for the surface, 0 for unlimited;
	MaxImageCount uint32
	//  Current image width and height for the surface, (0, 0) if undefined;
	CurrentExtent Extent2D
	//  Supported minimum image width and height for the surface;
	MinImageExtent Extent2D
	//  Supported maximum image width and height for the surface;
	MaxImageExtent Extent2D
	//  Supported maximum number of image layers for the surface;
	MaxImageArrayLayers uint32
	//  1 or more bits representing the transforms supported;
	SupportedTransforms SurfaceTransformFlagsKHR
	//  The surface's current transform relative to the device's natural orientation;
	CurrentTransform SurfaceTransformFlagBitsKHR
	//  1 or more bits representing the alpha compositing modes supported;
	SupportedCompositeAlpha CompositeAlphaFlagsKHR
	//  Supported image usage flags for the surface;
	SupportedUsageFlags      ImageUsageFlags
	SupportedSurfaceCounters SurfaceCounterFlagsEXT
}

// WARNING - struct SurfaceCapabilities2EXT is returned only, which is not yet handled in the binding
type _vkSurfaceCapabilities2EXT struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	minImageCount            uint32
	maxImageCount            uint32
	currentExtent            _vkExtent2D
	minImageExtent           _vkExtent2D
	maxImageExtent           _vkExtent2D
	maxImageArrayLayers      uint32
	supportedTransforms      SurfaceTransformFlagsKHR
	currentTransform         SurfaceTransformFlagBitsKHR
	supportedCompositeAlpha  CompositeAlphaFlagsKHR
	supportedUsageFlags      ImageUsageFlags
	supportedSurfaceCounters SurfaceCounterFlagsEXT
}

func (s *_vkSurfaceCapabilities2EXT) Goify() *SurfaceCapabilities2EXT {
	rval := &SurfaceCapabilities2EXT{
		PNext:                    (unsafe.Pointer)(s.pNext),
		MinImageCount:            (uint32)(s.minImageCount),
		MaxImageCount:            (uint32)(s.maxImageCount),
		CurrentExtent:            (Extent2D)(s.currentExtent),
		MinImageExtent:           (Extent2D)(s.minImageExtent),
		MaxImageExtent:           (Extent2D)(s.maxImageExtent),
		MaxImageArrayLayers:      (uint32)(s.maxImageArrayLayers),
		SupportedTransforms:      (SurfaceTransformFlagsKHR)(s.supportedTransforms),
		CurrentTransform:         (SurfaceTransformFlagBitsKHR)(s.currentTransform),
		SupportedCompositeAlpha:  (CompositeAlphaFlagsKHR)(s.supportedCompositeAlpha),
		SupportedUsageFlags:      (ImageUsageFlags)(s.supportedUsageFlags),
		SupportedSurfaceCounters: (SurfaceCounterFlagsEXT)(s.supportedSurfaceCounters),
	}
	return rval
}
func (s *SurfaceCapabilities2EXT) Vulkanize() *_vkSurfaceCapabilities2EXT {
	if s == nil {
		return nil
	}
	rval := &_vkSurfaceCapabilities2EXT{
		sType:                    STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,            /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                            /*cb*/
		minImageCount:            (uint32)(s.MinImageCount),                            /*cb*/
		maxImageCount:            (uint32)(s.MaxImageCount),                            /*cb*/
		currentExtent:            (_vkExtent2D)(s.CurrentExtent),                       /*cb*/
		minImageExtent:           (_vkExtent2D)(s.MinImageExtent),                      /*cb*/
		maxImageExtent:           (_vkExtent2D)(s.MaxImageExtent),                      /*cb*/
		maxImageArrayLayers:      (uint32)(s.MaxImageArrayLayers),                      /*cb*/
		supportedTransforms:      (SurfaceTransformFlagsKHR)(s.SupportedTransforms),    /*cb*/
		currentTransform:         (SurfaceTransformFlagBitsKHR)(s.CurrentTransform),    /*cb*/
		supportedCompositeAlpha:  (CompositeAlphaFlagsKHR)(s.SupportedCompositeAlpha),  /*cb*/
		supportedUsageFlags:      (ImageUsageFlags)(s.SupportedUsageFlags),             /*cb*/
		supportedSurfaceCounters: (SurfaceCounterFlagsEXT)(s.SupportedSurfaceCounters), /*cb*/
	}
	return rval
}

// SurfaceCapabilities2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilities2KHR.html
type SurfaceCapabilities2KHR struct {
	// SType = STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR
	PNext               unsafe.Pointer
	SurfaceCapabilities SurfaceCapabilitiesKHR
}

// WARNING - struct SurfaceCapabilities2KHR is returned only, which is not yet handled in the binding
type _vkSurfaceCapabilities2KHR struct {
	sType               StructureType
	pNext               unsafe.Pointer
	surfaceCapabilities _vkSurfaceCapabilitiesKHR
}

func (s *_vkSurfaceCapabilities2KHR) Goify() *SurfaceCapabilities2KHR {
	rval := &SurfaceCapabilities2KHR{
		PNext:               (unsafe.Pointer)(s.pNext),
		SurfaceCapabilities: *(s.surfaceCapabilities.Goify()),
	}
	return rval
}
func (s *SurfaceCapabilities2KHR) Vulkanize() *_vkSurfaceCapabilities2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkSurfaceCapabilities2KHR{
		sType:               STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                 /*cb*/
		surfaceCapabilities: *(s.SurfaceCapabilities.Vulkanize()),      /*c3*/
	}
	return rval
}

// SurfaceCapabilitiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesKHR.html
type SurfaceCapabilitiesKHR struct {
	//  Supported minimum number of images for the surface;
	MinImageCount uint32
	//  Supported maximum number of images for the surface, 0 for unlimited;
	MaxImageCount uint32
	//  Current image width and height for the surface, (0, 0) if undefined;
	CurrentExtent Extent2D
	//  Supported minimum image width and height for the surface;
	MinImageExtent Extent2D
	//  Supported maximum image width and height for the surface;
	MaxImageExtent Extent2D
	//  Supported maximum number of image layers for the surface;
	MaxImageArrayLayers uint32
	//  1 or more bits representing the transforms supported;
	SupportedTransforms SurfaceTransformFlagsKHR
	//  The surface's current transform relative to the device's natural orientation;
	CurrentTransform SurfaceTransformFlagBitsKHR
	//  1 or more bits representing the alpha compositing modes supported;
	SupportedCompositeAlpha CompositeAlphaFlagsKHR
	//  Supported image usage flags for the surface;
	SupportedUsageFlags ImageUsageFlags
}

// WARNING - struct SurfaceCapabilitiesKHR is returned only, which is not yet handled in the binding
type _vkSurfaceCapabilitiesKHR struct {
	minImageCount           uint32
	maxImageCount           uint32
	currentExtent           _vkExtent2D
	minImageExtent          _vkExtent2D
	maxImageExtent          _vkExtent2D
	maxImageArrayLayers     uint32
	supportedTransforms     SurfaceTransformFlagsKHR
	currentTransform        SurfaceTransformFlagBitsKHR
	supportedCompositeAlpha CompositeAlphaFlagsKHR
	supportedUsageFlags     ImageUsageFlags
}

func (s *_vkSurfaceCapabilitiesKHR) Goify() *SurfaceCapabilitiesKHR {
	rval := &SurfaceCapabilitiesKHR{
		MinImageCount:           (uint32)(s.minImageCount),
		MaxImageCount:           (uint32)(s.maxImageCount),
		CurrentExtent:           (Extent2D)(s.currentExtent),
		MinImageExtent:          (Extent2D)(s.minImageExtent),
		MaxImageExtent:          (Extent2D)(s.maxImageExtent),
		MaxImageArrayLayers:     (uint32)(s.maxImageArrayLayers),
		SupportedTransforms:     (SurfaceTransformFlagsKHR)(s.supportedTransforms),
		CurrentTransform:        (SurfaceTransformFlagBitsKHR)(s.currentTransform),
		SupportedCompositeAlpha: (CompositeAlphaFlagsKHR)(s.supportedCompositeAlpha),
		SupportedUsageFlags:     (ImageUsageFlags)(s.supportedUsageFlags),
	}
	return rval
}
func (s *SurfaceCapabilitiesKHR) Vulkanize() *_vkSurfaceCapabilitiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkSurfaceCapabilitiesKHR{
		minImageCount:           (uint32)(s.MinImageCount),                           /*cb*/
		maxImageCount:           (uint32)(s.MaxImageCount),                           /*cb*/
		currentExtent:           (_vkExtent2D)(s.CurrentExtent),                      /*cb*/
		minImageExtent:          (_vkExtent2D)(s.MinImageExtent),                     /*cb*/
		maxImageExtent:          (_vkExtent2D)(s.MaxImageExtent),                     /*cb*/
		maxImageArrayLayers:     (uint32)(s.MaxImageArrayLayers),                     /*cb*/
		supportedTransforms:     (SurfaceTransformFlagsKHR)(s.SupportedTransforms),   /*cb*/
		currentTransform:        (SurfaceTransformFlagBitsKHR)(s.CurrentTransform),   /*cb*/
		supportedCompositeAlpha: (CompositeAlphaFlagsKHR)(s.SupportedCompositeAlpha), /*cb*/
		supportedUsageFlags:     (ImageUsageFlags)(s.SupportedUsageFlags),            /*cb*/
	}
	return rval
}

// SurfaceCapabilitiesPresentBarrierNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesPresentBarrierNV.html
type SurfaceCapabilitiesPresentBarrierNV struct {
	// SType = STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV
	PNext                   unsafe.Pointer
	PresentBarrierSupported bool
}

type _vkSurfaceCapabilitiesPresentBarrierNV struct {
	sType                   StructureType
	pNext                   unsafe.Pointer
	presentBarrierSupported Bool32
}

func (s *_vkSurfaceCapabilitiesPresentBarrierNV) Goify() *SurfaceCapabilitiesPresentBarrierNV {
	rval := &SurfaceCapabilitiesPresentBarrierNV{
		PNext:                   (unsafe.Pointer)(s.pNext),
		PresentBarrierSupported: translatePublic_Bool32(s.presentBarrierSupported), /*default*/
	}
	return rval
}
func (s *SurfaceCapabilitiesPresentBarrierNV) Vulkanize() *_vkSurfaceCapabilitiesPresentBarrierNV {
	if s == nil {
		return nil
	}
	rval := &_vkSurfaceCapabilitiesPresentBarrierNV{
		sType:                   STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV, /*c1*/
		pNext:                   (unsafe.Pointer)(s.PNext),                              /*cb*/
		presentBarrierSupported: translateInternal_Bool32(s.PresentBarrierSupported),    /*default*/
	}
	return rval
}

// SurfaceFormat2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormat2KHR.html
type SurfaceFormat2KHR struct {
	// SType = STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR
	PNext         unsafe.Pointer
	SurfaceFormat SurfaceFormatKHR
}

// WARNING - struct SurfaceFormat2KHR is returned only, which is not yet handled in the binding
type _vkSurfaceFormat2KHR struct {
	sType         StructureType
	pNext         unsafe.Pointer
	surfaceFormat _vkSurfaceFormatKHR
}

func (s *_vkSurfaceFormat2KHR) Goify() *SurfaceFormat2KHR {
	rval := &SurfaceFormat2KHR{
		PNext:         (unsafe.Pointer)(s.pNext),
		SurfaceFormat: (SurfaceFormatKHR)(s.surfaceFormat),
	}
	return rval
}
func (s *SurfaceFormat2KHR) Vulkanize() *_vkSurfaceFormat2KHR {
	if s == nil {
		return nil
	}
	rval := &_vkSurfaceFormat2KHR{
		sType:         STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR,    /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),              /*cb*/
		surfaceFormat: (_vkSurfaceFormatKHR)(s.SurfaceFormat), /*cb*/
	}
	return rval
}

// SurfaceFormatKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormatKHR.html
type SurfaceFormatKHR struct {
	//  Supported pair of rendering format;
	Format Format
	//  and color space for the surface;
	ColorSpace ColorSpaceKHR
}

type _vkSurfaceFormatKHR = SurfaceFormatKHR

func (s *_vkSurfaceFormatKHR) Goify() *SurfaceFormatKHR {
	rval := (*SurfaceFormatKHR)(s)
	return rval
}
func (s *SurfaceFormatKHR) Vulkanize() *_vkSurfaceFormatKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkSurfaceFormatKHR)(s)
	return rval
}

// SurfacePresentModeCompatibilityEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfacePresentModeCompatibilityEXT.html
type SurfacePresentModeCompatibilityEXT struct {
	// SType = STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT
	PNext unsafe.Pointer
	// presentModeCount
	//  Output list of present modes compatible with the one specified in VkSurfacePresentModeEXT;
	PPresentModes []PresentModeKHR
}

type _vkSurfacePresentModeCompatibilityEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	presentModeCount uint32
	pPresentModes    *PresentModeKHR
}

func (s *_vkSurfacePresentModeCompatibilityEXT) Goify() *SurfacePresentModeCompatibilityEXT {
	rval := &SurfacePresentModeCompatibilityEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPresentModes in returned struct
	}
	return rval
}
func (s *SurfacePresentModeCompatibilityEXT) Vulkanize() *_vkSurfacePresentModeCompatibilityEXT {
	if s == nil {
		return nil
	}

	var psl_pPresentModes *PresentModeKHR
	if len(s.PPresentModes) > 0 {
		psl_pPresentModes = &s.PPresentModes[0]
	}
	rval := &_vkSurfacePresentModeCompatibilityEXT{
		sType:            STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                             /*cb*/
		presentModeCount: uint32(len(s.PPresentModes)),                          /*c6-a*/
		pPresentModes:    psl_pPresentModes,                                     /*c rem*/
	}
	return rval
}

// SurfacePresentModeEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfacePresentModeEXT.html
type SurfacePresentModeEXT struct {
	// SType = STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT
	PNext       unsafe.Pointer
	PresentMode PresentModeKHR
}

type _vkSurfacePresentModeEXT struct {
	sType       StructureType
	pNext       unsafe.Pointer
	presentMode PresentModeKHR
}

func (s *_vkSurfacePresentModeEXT) Goify() *SurfacePresentModeEXT {
	rval := &SurfacePresentModeEXT{
		PNext:       (unsafe.Pointer)(s.pNext),
		PresentMode: (PresentModeKHR)(s.presentMode),
	}
	return rval
}
func (s *SurfacePresentModeEXT) Vulkanize() *_vkSurfacePresentModeEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSurfacePresentModeEXT{
		sType:       STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),               /*cb*/
		presentMode: (PresentModeKHR)(s.PresentMode),         /*cb*/
	}
	return rval
}

// SurfacePresentScalingCapabilitiesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfacePresentScalingCapabilitiesEXT.html
type SurfacePresentScalingCapabilitiesEXT struct {
	// SType = STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT
	PNext                    unsafe.Pointer
	SupportedPresentScaling  PresentScalingFlagsEXT
	SupportedPresentGravityX PresentGravityFlagsEXT
	SupportedPresentGravityY PresentGravityFlagsEXT
	//  Supported minimum image width and height for the surface when scaling is used;
	MinScaledImageExtent Extent2D
	//  Supported maximum image width and height for the surface when scaling is used;
	MaxScaledImageExtent Extent2D
}

type _vkSurfacePresentScalingCapabilitiesEXT struct {
	sType                    StructureType
	pNext                    unsafe.Pointer
	supportedPresentScaling  PresentScalingFlagsEXT
	supportedPresentGravityX PresentGravityFlagsEXT
	supportedPresentGravityY PresentGravityFlagsEXT
	minScaledImageExtent     _vkExtent2D
	maxScaledImageExtent     _vkExtent2D
}

func (s *_vkSurfacePresentScalingCapabilitiesEXT) Goify() *SurfacePresentScalingCapabilitiesEXT {
	rval := &SurfacePresentScalingCapabilitiesEXT{
		PNext:                    (unsafe.Pointer)(s.pNext),
		SupportedPresentScaling:  (PresentScalingFlagsEXT)(s.supportedPresentScaling),
		SupportedPresentGravityX: (PresentGravityFlagsEXT)(s.supportedPresentGravityX),
		SupportedPresentGravityY: (PresentGravityFlagsEXT)(s.supportedPresentGravityY),
		MinScaledImageExtent:     (Extent2D)(s.minScaledImageExtent),
		MaxScaledImageExtent:     (Extent2D)(s.maxScaledImageExtent),
	}
	return rval
}
func (s *SurfacePresentScalingCapabilitiesEXT) Vulkanize() *_vkSurfacePresentScalingCapabilitiesEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSurfacePresentScalingCapabilitiesEXT{
		sType:                    STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT, /*c1*/
		pNext:                    (unsafe.Pointer)(s.PNext),                               /*cb*/
		supportedPresentScaling:  (PresentScalingFlagsEXT)(s.SupportedPresentScaling),     /*cb*/
		supportedPresentGravityX: (PresentGravityFlagsEXT)(s.SupportedPresentGravityX),    /*cb*/
		supportedPresentGravityY: (PresentGravityFlagsEXT)(s.SupportedPresentGravityY),    /*cb*/
		minScaledImageExtent:     (_vkExtent2D)(s.MinScaledImageExtent),                   /*cb*/
		maxScaledImageExtent:     (_vkExtent2D)(s.MaxScaledImageExtent),                   /*cb*/
	}
	return rval
}

// SurfaceProtectedCapabilitiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceProtectedCapabilitiesKHR.html
type SurfaceProtectedCapabilitiesKHR struct {
	// SType = STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR
	PNext unsafe.Pointer
	//  Represents if surface can be protected;
	SupportsProtected bool
}

type _vkSurfaceProtectedCapabilitiesKHR struct {
	sType             StructureType
	pNext             unsafe.Pointer
	supportsProtected Bool32
}

func (s *_vkSurfaceProtectedCapabilitiesKHR) Goify() *SurfaceProtectedCapabilitiesKHR {
	rval := &SurfaceProtectedCapabilitiesKHR{
		PNext:             (unsafe.Pointer)(s.pNext),
		SupportsProtected: translatePublic_Bool32(s.supportsProtected), /*default*/
	}
	return rval
}
func (s *SurfaceProtectedCapabilitiesKHR) Vulkanize() *_vkSurfaceProtectedCapabilitiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkSurfaceProtectedCapabilitiesKHR{
		sType:             STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                         /*cb*/
		supportsProtected: translateInternal_Bool32(s.SupportsProtected),     /*default*/
	}
	return rval
}

// SwapchainCounterCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCounterCreateInfoEXT.html
type SwapchainCounterCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT
	PNext           unsafe.Pointer
	SurfaceCounters SurfaceCounterFlagsEXT
}

type _vkSwapchainCounterCreateInfoEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	surfaceCounters SurfaceCounterFlagsEXT
}

func (s *_vkSwapchainCounterCreateInfoEXT) Goify() *SwapchainCounterCreateInfoEXT {
	rval := &SwapchainCounterCreateInfoEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		SurfaceCounters: (SurfaceCounterFlagsEXT)(s.surfaceCounters),
	}
	return rval
}
func (s *SwapchainCounterCreateInfoEXT) Vulkanize() *_vkSwapchainCounterCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSwapchainCounterCreateInfoEXT{
		sType:           STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                        /*cb*/
		surfaceCounters: (SurfaceCounterFlagsEXT)(s.SurfaceCounters),      /*cb*/
	}
	return rval
}

// SwapchainCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCreateInfoKHR.html
type SwapchainCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
	PNext unsafe.Pointer
	Flags SwapchainCreateFlagsKHR
	//  The swapchain's target surface;
	Surface SurfaceKHR
	//  Minimum number of presentation images the application needs;
	MinImageCount uint32
	//  Format of the presentation images;
	ImageFormat Format
	//  Colorspace of the presentation images;
	ImageColorSpace ColorSpaceKHR
	//  Dimensions of the presentation images;
	ImageExtent Extent2D
	//  Determines the number of views for multiview/stereo presentation;
	ImageArrayLayers uint32
	//  Bits indicating how the presentation images will be used;
	ImageUsage ImageUsageFlags
	//  Sharing mode used for the presentation images;
	ImageSharingMode SharingMode
	//  Number of queue families having access to the images in case of concurrent sharing mode;
	// queueFamilyIndexCount
	//  Array of queue family indices having access to the images in case of concurrent sharing mode;
	PQueueFamilyIndices []uint32
	//  The transform, relative to the device's natural orientation, applied to the image content prior to presentation;
	PreTransform SurfaceTransformFlagBitsKHR
	//  The alpha blending mode used when compositing this surface with other surfaces in the window system;
	CompositeAlpha CompositeAlphaFlagBitsKHR
	//  Which presentation mode to use for presents on this swap chain;
	PresentMode PresentModeKHR
	//  Specifies whether presentable images may be affected by window clip regions;
	Clipped bool
	//  Existing swap chain to replace, if any;
	OldSwapchain SwapchainKHR
}

type _vkSwapchainCreateInfoKHR struct {
	sType                 StructureType
	pNext                 unsafe.Pointer
	flags                 SwapchainCreateFlagsKHR
	surface               SurfaceKHR
	minImageCount         uint32
	imageFormat           Format
	imageColorSpace       ColorSpaceKHR
	imageExtent           _vkExtent2D
	imageArrayLayers      uint32
	imageUsage            ImageUsageFlags
	imageSharingMode      SharingMode
	queueFamilyIndexCount uint32
	pQueueFamilyIndices   *uint32
	preTransform          SurfaceTransformFlagBitsKHR
	compositeAlpha        CompositeAlphaFlagBitsKHR
	presentMode           PresentModeKHR
	clipped               Bool32
	oldSwapchain          SwapchainKHR
}

func (s *_vkSwapchainCreateInfoKHR) Goify() *SwapchainCreateInfoKHR {
	rval := &SwapchainCreateInfoKHR{
		PNext:            (unsafe.Pointer)(s.pNext),
		Flags:            (SwapchainCreateFlagsKHR)(s.flags),
		Surface:          (SurfaceKHR)(s.surface),
		MinImageCount:    (uint32)(s.minImageCount),
		ImageFormat:      (Format)(s.imageFormat),
		ImageColorSpace:  (ColorSpaceKHR)(s.imageColorSpace),
		ImageExtent:      (Extent2D)(s.imageExtent),
		ImageArrayLayers: (uint32)(s.imageArrayLayers),
		ImageUsage:       (ImageUsageFlags)(s.imageUsage),
		ImageSharingMode: (SharingMode)(s.imageSharingMode),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pQueueFamilyIndices in returned struct
		PreTransform:   (SurfaceTransformFlagBitsKHR)(s.preTransform),
		CompositeAlpha: (CompositeAlphaFlagBitsKHR)(s.compositeAlpha),
		PresentMode:    (PresentModeKHR)(s.presentMode),
		Clipped:        translatePublic_Bool32(s.clipped), /*default*/
		OldSwapchain:   (SwapchainKHR)(s.oldSwapchain),
	}
	return rval
}
func (s *SwapchainCreateInfoKHR) Vulkanize() *_vkSwapchainCreateInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pQueueFamilyIndices *uint32
	if len(s.PQueueFamilyIndices) > 0 {
		psl_pQueueFamilyIndices = &s.PQueueFamilyIndices[0]
	}
	rval := &_vkSwapchainCreateInfoKHR{
		sType:                 STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,      /*c1*/
		pNext:                 (unsafe.Pointer)(s.PNext),                     /*cb*/
		flags:                 (SwapchainCreateFlagsKHR)(s.Flags),            /*cb*/
		surface:               (SurfaceKHR)(s.Surface),                       /*cb*/
		minImageCount:         (uint32)(s.MinImageCount),                     /*cb*/
		imageFormat:           (Format)(s.ImageFormat),                       /*cb*/
		imageColorSpace:       (ColorSpaceKHR)(s.ImageColorSpace),            /*cb*/
		imageExtent:           (_vkExtent2D)(s.ImageExtent),                  /*cb*/
		imageArrayLayers:      (uint32)(s.ImageArrayLayers),                  /*cb*/
		imageUsage:            (ImageUsageFlags)(s.ImageUsage),               /*cb*/
		imageSharingMode:      (SharingMode)(s.ImageSharingMode),             /*cb*/
		queueFamilyIndexCount: uint32(len(s.PQueueFamilyIndices)),            /*c6-a*/
		pQueueFamilyIndices:   psl_pQueueFamilyIndices,                       /*c rem*/
		preTransform:          (SurfaceTransformFlagBitsKHR)(s.PreTransform), /*cb*/
		compositeAlpha:        (CompositeAlphaFlagBitsKHR)(s.CompositeAlpha), /*cb*/
		presentMode:           (PresentModeKHR)(s.PresentMode),               /*cb*/
		clipped:               translateInternal_Bool32(s.Clipped),           /*default*/
		oldSwapchain:          (SwapchainKHR)(s.OldSwapchain),                /*cb*/
	}
	return rval
}

// SwapchainDisplayNativeHdrCreateInfoAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html
type SwapchainDisplayNativeHdrCreateInfoAMD struct {
	// SType = STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD
	PNext              unsafe.Pointer
	LocalDimmingEnable bool
}

type _vkSwapchainDisplayNativeHdrCreateInfoAMD struct {
	sType              StructureType
	pNext              unsafe.Pointer
	localDimmingEnable Bool32
}

func (s *_vkSwapchainDisplayNativeHdrCreateInfoAMD) Goify() *SwapchainDisplayNativeHdrCreateInfoAMD {
	rval := &SwapchainDisplayNativeHdrCreateInfoAMD{
		PNext:              (unsafe.Pointer)(s.pNext),
		LocalDimmingEnable: translatePublic_Bool32(s.localDimmingEnable), /*default*/
	}
	return rval
}
func (s *SwapchainDisplayNativeHdrCreateInfoAMD) Vulkanize() *_vkSwapchainDisplayNativeHdrCreateInfoAMD {
	if s == nil {
		return nil
	}
	rval := &_vkSwapchainDisplayNativeHdrCreateInfoAMD{
		sType:              STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                   /*cb*/
		localDimmingEnable: translateInternal_Bool32(s.LocalDimmingEnable),              /*default*/
	}
	return rval
}

// SwapchainLatencyCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainLatencyCreateInfoNV.html
type SwapchainLatencyCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV
	PNext             unsafe.Pointer
	LatencyModeEnable bool
}

type _vkSwapchainLatencyCreateInfoNV struct {
	sType             StructureType
	pNext             unsafe.Pointer
	latencyModeEnable Bool32
}

func (s *_vkSwapchainLatencyCreateInfoNV) Goify() *SwapchainLatencyCreateInfoNV {
	rval := &SwapchainLatencyCreateInfoNV{
		PNext:             (unsafe.Pointer)(s.pNext),
		LatencyModeEnable: translatePublic_Bool32(s.latencyModeEnable), /*default*/
	}
	return rval
}
func (s *SwapchainLatencyCreateInfoNV) Vulkanize() *_vkSwapchainLatencyCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkSwapchainLatencyCreateInfoNV{
		sType:             STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                       /*cb*/
		latencyModeEnable: translateInternal_Bool32(s.LatencyModeEnable),   /*default*/
	}
	return rval
}

// SwapchainPresentBarrierCreateInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentBarrierCreateInfoNV.html
type SwapchainPresentBarrierCreateInfoNV struct {
	// SType = STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV
	PNext                unsafe.Pointer
	PresentBarrierEnable bool
}

type _vkSwapchainPresentBarrierCreateInfoNV struct {
	sType                StructureType
	pNext                unsafe.Pointer
	presentBarrierEnable Bool32
}

func (s *_vkSwapchainPresentBarrierCreateInfoNV) Goify() *SwapchainPresentBarrierCreateInfoNV {
	rval := &SwapchainPresentBarrierCreateInfoNV{
		PNext:                (unsafe.Pointer)(s.pNext),
		PresentBarrierEnable: translatePublic_Bool32(s.presentBarrierEnable), /*default*/
	}
	return rval
}
func (s *SwapchainPresentBarrierCreateInfoNV) Vulkanize() *_vkSwapchainPresentBarrierCreateInfoNV {
	if s == nil {
		return nil
	}
	rval := &_vkSwapchainPresentBarrierCreateInfoNV{
		sType:                STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                               /*cb*/
		presentBarrierEnable: translateInternal_Bool32(s.PresentBarrierEnable),        /*default*/
	}
	return rval
}

// SwapchainPresentFenceInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentFenceInfoEXT.html
type SwapchainPresentFenceInfoEXT struct {
	// SType = STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT
	PNext unsafe.Pointer
	//  Copy of VkPresentInfoKHR::swapchainCount;
	// swapchainCount
	//  Fence to signal for each swapchain;
	PFences []Fence
}

type _vkSwapchainPresentFenceInfoEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	swapchainCount uint32
	pFences        *Fence
}

func (s *_vkSwapchainPresentFenceInfoEXT) Goify() *SwapchainPresentFenceInfoEXT {
	rval := &SwapchainPresentFenceInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pFences in returned struct
	}
	return rval
}
func (s *SwapchainPresentFenceInfoEXT) Vulkanize() *_vkSwapchainPresentFenceInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pFences *Fence
	if len(s.PFences) > 0 {
		psl_pFences = &s.PFences[0]
	}
	rval := &_vkSwapchainPresentFenceInfoEXT{
		sType:          STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                       /*cb*/
		swapchainCount: uint32(len(s.PFences)),                          /*c6-a*/
		pFences:        psl_pFences,                                     /*c rem*/
	}
	return rval
}

// SwapchainPresentModeInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentModeInfoEXT.html
type SwapchainPresentModeInfoEXT struct {
	// SType = STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT
	PNext unsafe.Pointer
	//  Copy of VkPresentInfoKHR::swapchainCount;
	// swapchainCount
	//  Presentation mode for each swapchain;
	PPresentModes []PresentModeKHR
}

type _vkSwapchainPresentModeInfoEXT struct {
	sType          StructureType
	pNext          unsafe.Pointer
	swapchainCount uint32
	pPresentModes  *PresentModeKHR
}

func (s *_vkSwapchainPresentModeInfoEXT) Goify() *SwapchainPresentModeInfoEXT {
	rval := &SwapchainPresentModeInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPresentModes in returned struct
	}
	return rval
}
func (s *SwapchainPresentModeInfoEXT) Vulkanize() *_vkSwapchainPresentModeInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pPresentModes *PresentModeKHR
	if len(s.PPresentModes) > 0 {
		psl_pPresentModes = &s.PPresentModes[0]
	}
	rval := &_vkSwapchainPresentModeInfoEXT{
		sType:          STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT, /*c1*/
		pNext:          (unsafe.Pointer)(s.PNext),                      /*cb*/
		swapchainCount: uint32(len(s.PPresentModes)),                   /*c6-a*/
		pPresentModes:  psl_pPresentModes,                              /*c rem*/
	}
	return rval
}

// SwapchainPresentModesCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentModesCreateInfoEXT.html
type SwapchainPresentModesCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT
	PNext unsafe.Pointer
	// presentModeCount
	PPresentModes []PresentModeKHR
}

type _vkSwapchainPresentModesCreateInfoEXT struct {
	sType            StructureType
	pNext            unsafe.Pointer
	presentModeCount uint32
	pPresentModes    *PresentModeKHR
}

func (s *_vkSwapchainPresentModesCreateInfoEXT) Goify() *SwapchainPresentModesCreateInfoEXT {
	rval := &SwapchainPresentModesCreateInfoEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pPresentModes in returned struct
	}
	return rval
}
func (s *SwapchainPresentModesCreateInfoEXT) Vulkanize() *_vkSwapchainPresentModesCreateInfoEXT {
	if s == nil {
		return nil
	}

	var psl_pPresentModes *PresentModeKHR
	if len(s.PPresentModes) > 0 {
		psl_pPresentModes = &s.PPresentModes[0]
	}
	rval := &_vkSwapchainPresentModesCreateInfoEXT{
		sType:            STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                              /*cb*/
		presentModeCount: uint32(len(s.PPresentModes)),                           /*c6-a*/
		pPresentModes:    psl_pPresentModes,                                      /*c rem*/
	}
	return rval
}

// SwapchainPresentScalingCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentScalingCreateInfoEXT.html
type SwapchainPresentScalingCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT
	PNext           unsafe.Pointer
	ScalingBehavior PresentScalingFlagsEXT
	PresentGravityX PresentGravityFlagsEXT
	PresentGravityY PresentGravityFlagsEXT
}

type _vkSwapchainPresentScalingCreateInfoEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	scalingBehavior PresentScalingFlagsEXT
	presentGravityX PresentGravityFlagsEXT
	presentGravityY PresentGravityFlagsEXT
}

func (s *_vkSwapchainPresentScalingCreateInfoEXT) Goify() *SwapchainPresentScalingCreateInfoEXT {
	rval := &SwapchainPresentScalingCreateInfoEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		ScalingBehavior: (PresentScalingFlagsEXT)(s.scalingBehavior),
		PresentGravityX: (PresentGravityFlagsEXT)(s.presentGravityX),
		PresentGravityY: (PresentGravityFlagsEXT)(s.presentGravityY),
	}
	return rval
}
func (s *SwapchainPresentScalingCreateInfoEXT) Vulkanize() *_vkSwapchainPresentScalingCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkSwapchainPresentScalingCreateInfoEXT{
		sType:           STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                                /*cb*/
		scalingBehavior: (PresentScalingFlagsEXT)(s.ScalingBehavior),              /*cb*/
		presentGravityX: (PresentGravityFlagsEXT)(s.PresentGravityX),              /*cb*/
		presentGravityY: (PresentGravityFlagsEXT)(s.PresentGravityY),              /*cb*/
	}
	return rval
}

// TextureLODGatherFormatPropertiesAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTextureLODGatherFormatPropertiesAMD.html
type TextureLODGatherFormatPropertiesAMD struct {
	// SType = STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD
	PNext                           unsafe.Pointer
	SupportsTextureGatherLODBiasAMD bool
}

// WARNING - struct TextureLODGatherFormatPropertiesAMD is returned only, which is not yet handled in the binding
type _vkTextureLODGatherFormatPropertiesAMD struct {
	sType                           StructureType
	pNext                           unsafe.Pointer
	supportsTextureGatherLODBiasAMD Bool32
}

func (s *_vkTextureLODGatherFormatPropertiesAMD) Goify() *TextureLODGatherFormatPropertiesAMD {
	rval := &TextureLODGatherFormatPropertiesAMD{
		PNext:                           (unsafe.Pointer)(s.pNext),
		SupportsTextureGatherLODBiasAMD: translatePublic_Bool32(s.supportsTextureGatherLODBiasAMD), /*default*/
	}
	return rval
}
func (s *TextureLODGatherFormatPropertiesAMD) Vulkanize() *_vkTextureLODGatherFormatPropertiesAMD {
	if s == nil {
		return nil
	}
	rval := &_vkTextureLODGatherFormatPropertiesAMD{
		sType:                           STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,     /*c1*/
		pNext:                           (unsafe.Pointer)(s.PNext),                                   /*cb*/
		supportsTextureGatherLODBiasAMD: translateInternal_Bool32(s.SupportsTextureGatherLODBiasAMD), /*default*/
	}
	return rval
}

// TilePropertiesQCOM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTilePropertiesQCOM.html
type TilePropertiesQCOM struct {
	// SType = STRUCTURE_TYPE_TILE_PROPERTIES_QCOM
	PNext     unsafe.Pointer
	TileSize  Extent3D
	ApronSize Extent2D
	Origin    Offset2D
}

type _vkTilePropertiesQCOM struct {
	sType     StructureType
	pNext     unsafe.Pointer
	tileSize  _vkExtent3D
	apronSize _vkExtent2D
	origin    _vkOffset2D
}

func (s *_vkTilePropertiesQCOM) Goify() *TilePropertiesQCOM {
	rval := &TilePropertiesQCOM{
		PNext:     (unsafe.Pointer)(s.pNext),
		TileSize:  (Extent3D)(s.tileSize),
		ApronSize: (Extent2D)(s.apronSize),
		Origin:    (Offset2D)(s.origin),
	}
	return rval
}
func (s *TilePropertiesQCOM) Vulkanize() *_vkTilePropertiesQCOM {
	if s == nil {
		return nil
	}
	rval := &_vkTilePropertiesQCOM{
		sType:     STRUCTURE_TYPE_TILE_PROPERTIES_QCOM, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),           /*cb*/
		tileSize:  (_vkExtent3D)(s.TileSize),           /*cb*/
		apronSize: (_vkExtent2D)(s.ApronSize),          /*cb*/
		origin:    (_vkOffset2D)(s.Origin),             /*cb*/
	}
	return rval
}

// TimelineSemaphoreSubmitInfo: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTimelineSemaphoreSubmitInfo.html
type TimelineSemaphoreSubmitInfo struct {
	// SType = STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO
	PNext unsafe.Pointer
	// waitSemaphoreValueCount
	PWaitSemaphoreValues []uint64
	// signalSemaphoreValueCount
	PSignalSemaphoreValues []uint64
}

type _vkTimelineSemaphoreSubmitInfo struct {
	sType                     StructureType
	pNext                     unsafe.Pointer
	waitSemaphoreValueCount   uint32
	pWaitSemaphoreValues      *uint64
	signalSemaphoreValueCount uint32
	pSignalSemaphoreValues    *uint64
}

func (s *_vkTimelineSemaphoreSubmitInfo) Goify() *TimelineSemaphoreSubmitInfo {
	rval := &TimelineSemaphoreSubmitInfo{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pWaitSemaphoreValues in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSignalSemaphoreValues in returned struct
	}
	return rval
}
func (s *TimelineSemaphoreSubmitInfo) Vulkanize() *_vkTimelineSemaphoreSubmitInfo {
	if s == nil {
		return nil
	}

	var psl_pWaitSemaphoreValues *uint64
	if len(s.PWaitSemaphoreValues) > 0 {
		psl_pWaitSemaphoreValues = &s.PWaitSemaphoreValues[0]
	}

	var psl_pSignalSemaphoreValues *uint64
	if len(s.PSignalSemaphoreValues) > 0 {
		psl_pSignalSemaphoreValues = &s.PSignalSemaphoreValues[0]
	}
	rval := &_vkTimelineSemaphoreSubmitInfo{
		sType:                     STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, /*c1*/
		pNext:                     (unsafe.Pointer)(s.PNext),                     /*cb*/
		waitSemaphoreValueCount:   uint32(len(s.PWaitSemaphoreValues)),           /*c6-a*/
		pWaitSemaphoreValues:      psl_pWaitSemaphoreValues,                      /*c rem*/
		signalSemaphoreValueCount: uint32(len(s.PSignalSemaphoreValues)),         /*c6-a*/
		pSignalSemaphoreValues:    psl_pSignalSemaphoreValues,                    /*c rem*/
	}
	return rval
}

// TimelineSemaphoreSubmitInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTimelineSemaphoreSubmitInfoKHR.html
type TimelineSemaphoreSubmitInfoKHR struct {
}

type _vkTimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfoKHR

func (s *_vkTimelineSemaphoreSubmitInfoKHR) Goify() *TimelineSemaphoreSubmitInfoKHR {
	rval := (*TimelineSemaphoreSubmitInfoKHR)(s)
	return rval
}
func (s *TimelineSemaphoreSubmitInfoKHR) Vulkanize() *_vkTimelineSemaphoreSubmitInfoKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkTimelineSemaphoreSubmitInfoKHR)(s)
	return rval
}

// TraceRaysIndirectCommand2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTraceRaysIndirectCommand2KHR.html
type TraceRaysIndirectCommand2KHR struct {
	RaygenShaderRecordAddress         DeviceAddress
	RaygenShaderRecordSize            DeviceSize
	MissShaderBindingTableAddress     DeviceAddress
	MissShaderBindingTableSize        DeviceSize
	MissShaderBindingTableStride      DeviceSize
	HitShaderBindingTableAddress      DeviceAddress
	HitShaderBindingTableSize         DeviceSize
	HitShaderBindingTableStride       DeviceSize
	CallableShaderBindingTableAddress DeviceAddress
	CallableShaderBindingTableSize    DeviceSize
	CallableShaderBindingTableStride  DeviceSize
	Width                             uint32
	Height                            uint32
	Depth                             uint32
}

type _vkTraceRaysIndirectCommand2KHR = TraceRaysIndirectCommand2KHR

func (s *_vkTraceRaysIndirectCommand2KHR) Goify() *TraceRaysIndirectCommand2KHR {
	rval := (*TraceRaysIndirectCommand2KHR)(s)
	return rval
}
func (s *TraceRaysIndirectCommand2KHR) Vulkanize() *_vkTraceRaysIndirectCommand2KHR {
	if s == nil {
		return nil
	}
	rval := (*_vkTraceRaysIndirectCommand2KHR)(s)
	return rval
}

// TraceRaysIndirectCommandKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTraceRaysIndirectCommandKHR.html
type TraceRaysIndirectCommandKHR struct {
	Width  uint32
	Height uint32
	Depth  uint32
}

type _vkTraceRaysIndirectCommandKHR = TraceRaysIndirectCommandKHR

func (s *_vkTraceRaysIndirectCommandKHR) Goify() *TraceRaysIndirectCommandKHR {
	rval := (*TraceRaysIndirectCommandKHR)(s)
	return rval
}
func (s *TraceRaysIndirectCommandKHR) Vulkanize() *_vkTraceRaysIndirectCommandKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkTraceRaysIndirectCommandKHR)(s)
	return rval
}

// TransformMatrixKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTransformMatrixKHR.html
type TransformMatrixKHR struct {
	Matrix [3]float32
}

type _vkTransformMatrixKHR = TransformMatrixKHR

func (s *_vkTransformMatrixKHR) Goify() *TransformMatrixKHR {
	rval := (*TransformMatrixKHR)(s)
	return rval
}
func (s *TransformMatrixKHR) Vulkanize() *_vkTransformMatrixKHR {
	if s == nil {
		return nil
	}
	rval := (*_vkTransformMatrixKHR)(s)
	return rval
}

// TransformMatrixNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTransformMatrixNV.html
type TransformMatrixNV struct {
}

type _vkTransformMatrixNV = TransformMatrixNV

func (s *_vkTransformMatrixNV) Goify() *TransformMatrixNV {
	rval := (*TransformMatrixNV)(s)
	return rval
}
func (s *TransformMatrixNV) Vulkanize() *_vkTransformMatrixNV {
	if s == nil {
		return nil
	}
	rval := (*_vkTransformMatrixNV)(s)
	return rval
}

// ValidationCacheCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateInfoEXT.html
type ValidationCacheCreateInfoEXT struct {
	// SType = STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT
	PNext           unsafe.Pointer
	Flags           ValidationCacheCreateFlagsEXT
	InitialDataSize uintptr
	PInitialData    unsafe.Pointer
}

type _vkValidationCacheCreateInfoEXT struct {
	sType           StructureType
	pNext           unsafe.Pointer
	flags           ValidationCacheCreateFlagsEXT
	initialDataSize uintptr
	pInitialData    unsafe.Pointer
}

func (s *_vkValidationCacheCreateInfoEXT) Goify() *ValidationCacheCreateInfoEXT {
	rval := &ValidationCacheCreateInfoEXT{
		PNext:           (unsafe.Pointer)(s.pNext),
		Flags:           (ValidationCacheCreateFlagsEXT)(s.flags),
		InitialDataSize: (uintptr)(s.initialDataSize),
		PInitialData:    (unsafe.Pointer)(s.pInitialData),
	}
	return rval
}
func (s *ValidationCacheCreateInfoEXT) Vulkanize() *_vkValidationCacheCreateInfoEXT {
	if s == nil {
		return nil
	}
	rval := &_vkValidationCacheCreateInfoEXT{
		sType:           STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                       /*cb*/
		flags:           (ValidationCacheCreateFlagsEXT)(s.Flags),        /*cb*/
		initialDataSize: (uintptr)(s.InitialDataSize),                    /*cb*/
		pInitialData:    (unsafe.Pointer)(s.PInitialData),                /*cb*/
	}
	return rval
}

// ValidationFeaturesEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFeaturesEXT.html
type ValidationFeaturesEXT struct {
	//  Must be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
	// SType = STRUCTURE_TYPE_VALIDATION_FEATURES_EXT
	PNext unsafe.Pointer
	//  Number of validation features to enable;
	// enabledValidationFeatureCount
	//  Validation features to enable;
	PEnabledValidationFeatures []ValidationFeatureEnableEXT
	//  Number of validation features to disable;
	// disabledValidationFeatureCount
	//  Validation features to disable;
	PDisabledValidationFeatures []ValidationFeatureDisableEXT
}

type _vkValidationFeaturesEXT struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	enabledValidationFeatureCount  uint32
	pEnabledValidationFeatures     *ValidationFeatureEnableEXT
	disabledValidationFeatureCount uint32
	pDisabledValidationFeatures    *ValidationFeatureDisableEXT
}

func (s *_vkValidationFeaturesEXT) Goify() *ValidationFeaturesEXT {
	rval := &ValidationFeaturesEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pEnabledValidationFeatures in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDisabledValidationFeatures in returned struct
	}
	return rval
}
func (s *ValidationFeaturesEXT) Vulkanize() *_vkValidationFeaturesEXT {
	if s == nil {
		return nil
	}

	var psl_pEnabledValidationFeatures *ValidationFeatureEnableEXT
	if len(s.PEnabledValidationFeatures) > 0 {
		psl_pEnabledValidationFeatures = &s.PEnabledValidationFeatures[0]
	}

	var psl_pDisabledValidationFeatures *ValidationFeatureDisableEXT
	if len(s.PDisabledValidationFeatures) > 0 {
		psl_pDisabledValidationFeatures = &s.PDisabledValidationFeatures[0]
	}
	rval := &_vkValidationFeaturesEXT{
		sType:                          STRUCTURE_TYPE_VALIDATION_FEATURES_EXT,     /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                  /*cb*/
		enabledValidationFeatureCount:  uint32(len(s.PEnabledValidationFeatures)),  /*c6-a*/
		pEnabledValidationFeatures:     psl_pEnabledValidationFeatures,             /*c rem*/
		disabledValidationFeatureCount: uint32(len(s.PDisabledValidationFeatures)), /*c6-a*/
		pDisabledValidationFeatures:    psl_pDisabledValidationFeatures,            /*c rem*/
	}
	return rval
}

// ValidationFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFlagsEXT.html
type ValidationFlagsEXT struct {
	//  Must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
	// SType = STRUCTURE_TYPE_VALIDATION_FLAGS_EXT
	PNext unsafe.Pointer
	//  Number of validation checks to disable;
	// disabledValidationCheckCount
	//  Validation checks to disable;
	PDisabledValidationChecks []ValidationCheckEXT
}

type _vkValidationFlagsEXT struct {
	sType                        StructureType
	pNext                        unsafe.Pointer
	disabledValidationCheckCount uint32
	pDisabledValidationChecks    *ValidationCheckEXT
}

func (s *_vkValidationFlagsEXT) Goify() *ValidationFlagsEXT {
	rval := &ValidationFlagsEXT{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pDisabledValidationChecks in returned struct
	}
	return rval
}
func (s *ValidationFlagsEXT) Vulkanize() *_vkValidationFlagsEXT {
	if s == nil {
		return nil
	}

	var psl_pDisabledValidationChecks *ValidationCheckEXT
	if len(s.PDisabledValidationChecks) > 0 {
		psl_pDisabledValidationChecks = &s.PDisabledValidationChecks[0]
	}
	rval := &_vkValidationFlagsEXT{
		sType:                        STRUCTURE_TYPE_VALIDATION_FLAGS_EXT,      /*c1*/
		pNext:                        (unsafe.Pointer)(s.PNext),                /*cb*/
		disabledValidationCheckCount: uint32(len(s.PDisabledValidationChecks)), /*c6-a*/
		pDisabledValidationChecks:    psl_pDisabledValidationChecks,            /*c rem*/
	}
	return rval
}

// VertexInputAttributeDescription: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription.html
type VertexInputAttributeDescription struct {
	//  location of the shader vertex attrib;
	Location uint32
	//  Vertex buffer binding id;
	Binding uint32
	//  format of source data;
	Format Format
	//  Offset of first element in bytes from base of vertex;
	Offset uint32
}

type _vkVertexInputAttributeDescription = VertexInputAttributeDescription

func (s *_vkVertexInputAttributeDescription) Goify() *VertexInputAttributeDescription {
	rval := (*VertexInputAttributeDescription)(s)
	return rval
}
func (s *VertexInputAttributeDescription) Vulkanize() *_vkVertexInputAttributeDescription {
	if s == nil {
		return nil
	}
	rval := (*_vkVertexInputAttributeDescription)(s)
	return rval
}

// VertexInputAttributeDescription2EXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription2EXT.html
type VertexInputAttributeDescription2EXT struct {
	// SType = STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT
	PNext unsafe.Pointer
	//  location of the shader vertex attrib;
	Location uint32
	//  Vertex buffer binding id;
	Binding uint32
	//  format of source data;
	Format Format
	//  Offset of first element in bytes from base of vertex;
	Offset uint32
}

type _vkVertexInputAttributeDescription2EXT struct {
	sType    StructureType
	pNext    unsafe.Pointer
	location uint32
	binding  uint32
	format   Format
	offset   uint32
}

func (s *_vkVertexInputAttributeDescription2EXT) Goify() *VertexInputAttributeDescription2EXT {
	rval := &VertexInputAttributeDescription2EXT{
		PNext:    (unsafe.Pointer)(s.pNext),
		Location: (uint32)(s.location),
		Binding:  (uint32)(s.binding),
		Format:   (Format)(s.format),
		Offset:   (uint32)(s.offset),
	}
	return rval
}
func (s *VertexInputAttributeDescription2EXT) Vulkanize() *_vkVertexInputAttributeDescription2EXT {
	if s == nil {
		return nil
	}
	rval := &_vkVertexInputAttributeDescription2EXT{
		sType:    STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT, /*c1*/
		pNext:    (unsafe.Pointer)(s.PNext),                               /*cb*/
		location: (uint32)(s.Location),                                    /*cb*/
		binding:  (uint32)(s.Binding),                                     /*cb*/
		format:   (Format)(s.Format),                                      /*cb*/
		offset:   (uint32)(s.Offset),                                      /*cb*/
	}
	return rval
}

// VertexInputBindingDescription: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription.html
type VertexInputBindingDescription struct {
	//  Vertex buffer binding id;
	Binding uint32
	//  Distance between vertices in bytes (0 = no advancement);
	Stride uint32
	//  The rate at which the vertex data is consumed;
	InputRate VertexInputRate
}

type _vkVertexInputBindingDescription = VertexInputBindingDescription

func (s *_vkVertexInputBindingDescription) Goify() *VertexInputBindingDescription {
	rval := (*VertexInputBindingDescription)(s)
	return rval
}
func (s *VertexInputBindingDescription) Vulkanize() *_vkVertexInputBindingDescription {
	if s == nil {
		return nil
	}
	rval := (*_vkVertexInputBindingDescription)(s)
	return rval
}

// VertexInputBindingDescription2EXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription2EXT.html
type VertexInputBindingDescription2EXT struct {
	// SType = STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT
	PNext     unsafe.Pointer
	Binding   uint32
	Stride    uint32
	InputRate VertexInputRate
	Divisor   uint32
}

type _vkVertexInputBindingDescription2EXT struct {
	sType     StructureType
	pNext     unsafe.Pointer
	binding   uint32
	stride    uint32
	inputRate VertexInputRate
	divisor   uint32
}

func (s *_vkVertexInputBindingDescription2EXT) Goify() *VertexInputBindingDescription2EXT {
	rval := &VertexInputBindingDescription2EXT{
		PNext:     (unsafe.Pointer)(s.pNext),
		Binding:   (uint32)(s.binding),
		Stride:    (uint32)(s.stride),
		InputRate: (VertexInputRate)(s.inputRate),
		Divisor:   (uint32)(s.divisor),
	}
	return rval
}
func (s *VertexInputBindingDescription2EXT) Vulkanize() *_vkVertexInputBindingDescription2EXT {
	if s == nil {
		return nil
	}
	rval := &_vkVertexInputBindingDescription2EXT{
		sType:     STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT, /*c1*/
		pNext:     (unsafe.Pointer)(s.PNext),                             /*cb*/
		binding:   (uint32)(s.Binding),                                   /*cb*/
		stride:    (uint32)(s.Stride),                                    /*cb*/
		inputRate: (VertexInputRate)(s.InputRate),                        /*cb*/
		divisor:   (uint32)(s.Divisor),                                   /*cb*/
	}
	return rval
}

// VertexInputBindingDivisorDescriptionEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDivisorDescriptionEXT.html
type VertexInputBindingDivisorDescriptionEXT struct {
	Binding uint32
	Divisor uint32
}

type _vkVertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescriptionEXT

func (s *_vkVertexInputBindingDivisorDescriptionEXT) Goify() *VertexInputBindingDivisorDescriptionEXT {
	rval := (*VertexInputBindingDivisorDescriptionEXT)(s)
	return rval
}
func (s *VertexInputBindingDivisorDescriptionEXT) Vulkanize() *_vkVertexInputBindingDivisorDescriptionEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkVertexInputBindingDivisorDescriptionEXT)(s)
	return rval
}

// VideoBeginCodingInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingInfoKHR.html
type VideoBeginCodingInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR
	PNext                  unsafe.Pointer
	Flags                  VideoBeginCodingFlagsKHR
	VideoSession           VideoSessionKHR
	VideoSessionParameters VideoSessionParametersKHR
	// referenceSlotCount
	PReferenceSlots []VideoReferenceSlotInfoKHR
}

type _vkVideoBeginCodingInfoKHR struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	flags                  VideoBeginCodingFlagsKHR
	videoSession           VideoSessionKHR
	videoSessionParameters VideoSessionParametersKHR
	referenceSlotCount     uint32
	pReferenceSlots        *_vkVideoReferenceSlotInfoKHR
}

func (s *_vkVideoBeginCodingInfoKHR) Goify() *VideoBeginCodingInfoKHR {
	rval := &VideoBeginCodingInfoKHR{
		PNext:                  (unsafe.Pointer)(s.pNext),
		Flags:                  (VideoBeginCodingFlagsKHR)(s.flags),
		VideoSession:           (VideoSessionKHR)(s.videoSession),
		VideoSessionParameters: (VideoSessionParametersKHR)(s.videoSessionParameters),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pReferenceSlots in returned struct
	}
	return rval
}
func (s *VideoBeginCodingInfoKHR) Vulkanize() *_vkVideoBeginCodingInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pReferenceSlots *_vkVideoReferenceSlotInfoKHR
	if len(s.PReferenceSlots) > 0 {
		sl_pReferenceSlots := make([]_vkVideoReferenceSlotInfoKHR, len(s.PReferenceSlots))
		for i, v := range s.PReferenceSlots {
			sl_pReferenceSlots[i] = *(v.Vulkanize())
		}
		psl_pReferenceSlots = &sl_pReferenceSlots[0]
	}
	rval := &_vkVideoBeginCodingInfoKHR{
		sType:                  STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,            /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                             /*cb*/
		flags:                  (VideoBeginCodingFlagsKHR)(s.Flags),                   /*cb*/
		videoSession:           (VideoSessionKHR)(s.VideoSession),                     /*cb*/
		videoSessionParameters: (VideoSessionParametersKHR)(s.VideoSessionParameters), /*cb*/
		referenceSlotCount:     uint32(len(s.PReferenceSlots)),                        /*c6-a*/
		pReferenceSlots:        psl_pReferenceSlots,                                   /*c rem*/
	}
	return rval
}

// VideoCapabilitiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilitiesKHR.html
type VideoCapabilitiesKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR
	PNext                             unsafe.Pointer
	Flags                             VideoCapabilityFlagsKHR
	MinBitstreamBufferOffsetAlignment DeviceSize
	MinBitstreamBufferSizeAlignment   DeviceSize
	PictureAccessGranularity          Extent2D
	MinCodedExtent                    Extent2D
	MaxCodedExtent                    Extent2D
	MaxDpbSlots                       uint32
	MaxActiveReferencePictures        uint32
	StdHeaderVersion                  ExtensionProperties
}

// WARNING - struct VideoCapabilitiesKHR is returned only, which is not yet handled in the binding
type _vkVideoCapabilitiesKHR struct {
	sType                             StructureType
	pNext                             unsafe.Pointer
	flags                             VideoCapabilityFlagsKHR
	minBitstreamBufferOffsetAlignment DeviceSize
	minBitstreamBufferSizeAlignment   DeviceSize
	pictureAccessGranularity          _vkExtent2D
	minCodedExtent                    _vkExtent2D
	maxCodedExtent                    _vkExtent2D
	maxDpbSlots                       uint32
	maxActiveReferencePictures        uint32
	stdHeaderVersion                  _vkExtensionProperties
}

func (s *_vkVideoCapabilitiesKHR) Goify() *VideoCapabilitiesKHR {
	rval := &VideoCapabilitiesKHR{
		PNext:                             (unsafe.Pointer)(s.pNext),
		Flags:                             (VideoCapabilityFlagsKHR)(s.flags),
		MinBitstreamBufferOffsetAlignment: (DeviceSize)(s.minBitstreamBufferOffsetAlignment),
		MinBitstreamBufferSizeAlignment:   (DeviceSize)(s.minBitstreamBufferSizeAlignment),
		PictureAccessGranularity:          (Extent2D)(s.pictureAccessGranularity),
		MinCodedExtent:                    (Extent2D)(s.minCodedExtent),
		MaxCodedExtent:                    (Extent2D)(s.maxCodedExtent),
		MaxDpbSlots:                       (uint32)(s.maxDpbSlots),
		MaxActiveReferencePictures:        (uint32)(s.maxActiveReferencePictures),
		StdHeaderVersion:                  *(s.stdHeaderVersion.Goify()),
	}
	return rval
}
func (s *VideoCapabilitiesKHR) Vulkanize() *_vkVideoCapabilitiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoCapabilitiesKHR{
		sType:                             STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,             /*c1*/
		pNext:                             (unsafe.Pointer)(s.PNext),                         /*cb*/
		flags:                             (VideoCapabilityFlagsKHR)(s.Flags),                /*cb*/
		minBitstreamBufferOffsetAlignment: (DeviceSize)(s.MinBitstreamBufferOffsetAlignment), /*cb*/
		minBitstreamBufferSizeAlignment:   (DeviceSize)(s.MinBitstreamBufferSizeAlignment),   /*cb*/
		pictureAccessGranularity:          (_vkExtent2D)(s.PictureAccessGranularity),         /*cb*/
		minCodedExtent:                    (_vkExtent2D)(s.MinCodedExtent),                   /*cb*/
		maxCodedExtent:                    (_vkExtent2D)(s.MaxCodedExtent),                   /*cb*/
		maxDpbSlots:                       (uint32)(s.MaxDpbSlots),                           /*cb*/
		maxActiveReferencePictures:        (uint32)(s.MaxActiveReferencePictures),            /*cb*/
		stdHeaderVersion:                  *(s.StdHeaderVersion.Vulkanize()),                 /*c3*/
	}
	return rval
}

// VideoCodingControlInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlInfoKHR.html
type VideoCodingControlInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR
	PNext unsafe.Pointer
	Flags VideoCodingControlFlagsKHR
}

type _vkVideoCodingControlInfoKHR struct {
	sType StructureType
	pNext unsafe.Pointer
	flags VideoCodingControlFlagsKHR
}

func (s *_vkVideoCodingControlInfoKHR) Goify() *VideoCodingControlInfoKHR {
	rval := &VideoCodingControlInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (VideoCodingControlFlagsKHR)(s.flags),
	}
	return rval
}
func (s *VideoCodingControlInfoKHR) Vulkanize() *_vkVideoCodingControlInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoCodingControlInfoKHR{
		sType: STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                    /*cb*/
		flags: (VideoCodingControlFlagsKHR)(s.Flags),        /*cb*/
	}
	return rval
}

// VideoDecodeCapabilitiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeCapabilitiesKHR.html
type VideoDecodeCapabilitiesKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR
	PNext unsafe.Pointer
	Flags VideoDecodeCapabilityFlagsKHR
}

// WARNING - struct VideoDecodeCapabilitiesKHR is returned only, which is not yet handled in the binding
type _vkVideoDecodeCapabilitiesKHR struct {
	sType StructureType
	pNext unsafe.Pointer
	flags VideoDecodeCapabilityFlagsKHR
}

func (s *_vkVideoDecodeCapabilitiesKHR) Goify() *VideoDecodeCapabilitiesKHR {
	rval := &VideoDecodeCapabilitiesKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (VideoDecodeCapabilityFlagsKHR)(s.flags),
	}
	return rval
}
func (s *VideoDecodeCapabilitiesKHR) Vulkanize() *_vkVideoDecodeCapabilitiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeCapabilitiesKHR{
		sType: STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                    /*cb*/
		flags: (VideoDecodeCapabilityFlagsKHR)(s.Flags),     /*cb*/
	}
	return rval
}

// VideoDecodeH264CapabilitiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264CapabilitiesKHR.html
type VideoDecodeH264CapabilitiesKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR
	PNext                  unsafe.Pointer
	MaxLevelIdc            int32
	FieldOffsetGranularity Offset2D
}

// WARNING - struct VideoDecodeH264CapabilitiesKHR is returned only, which is not yet handled in the binding
type _vkVideoDecodeH264CapabilitiesKHR struct {
	sType                  StructureType
	pNext                  unsafe.Pointer
	maxLevelIdc            int32
	fieldOffsetGranularity _vkOffset2D
}

func (s *_vkVideoDecodeH264CapabilitiesKHR) Goify() *VideoDecodeH264CapabilitiesKHR {
	rval := &VideoDecodeH264CapabilitiesKHR{
		PNext:                  (unsafe.Pointer)(s.pNext),
		MaxLevelIdc:            (int32)(s.maxLevelIdc),
		FieldOffsetGranularity: (Offset2D)(s.fieldOffsetGranularity),
	}
	return rval
}
func (s *VideoDecodeH264CapabilitiesKHR) Vulkanize() *_vkVideoDecodeH264CapabilitiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeH264CapabilitiesKHR{
		sType:                  STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR, /*c1*/
		pNext:                  (unsafe.Pointer)(s.PNext),                         /*cb*/
		maxLevelIdc:            (int32)(s.MaxLevelIdc),                            /*cb*/
		fieldOffsetGranularity: (_vkOffset2D)(s.FieldOffsetGranularity),           /*cb*/
	}
	return rval
}

// VideoDecodeH264DpbSlotInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264DpbSlotInfoKHR.html
type VideoDecodeH264DpbSlotInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR
	PNext             unsafe.Pointer
	PStdReferenceInfo *int32
}

type _vkVideoDecodeH264DpbSlotInfoKHR struct {
	sType             StructureType
	pNext             unsafe.Pointer
	pStdReferenceInfo *int32
}

func (s *_vkVideoDecodeH264DpbSlotInfoKHR) Goify() *VideoDecodeH264DpbSlotInfoKHR {
	rval := &VideoDecodeH264DpbSlotInfoKHR{
		PNext:             (unsafe.Pointer)(s.pNext),
		PStdReferenceInfo: (*int32)(s.pStdReferenceInfo),
	}
	return rval
}
func (s *VideoDecodeH264DpbSlotInfoKHR) Vulkanize() *_vkVideoDecodeH264DpbSlotInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeH264DpbSlotInfoKHR{
		sType:             STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                          /*cb*/
		pStdReferenceInfo: (*int32)(s.PStdReferenceInfo),                      /*cb*/
	}
	return rval
}

// VideoDecodeH264PictureInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureInfoKHR.html
type VideoDecodeH264PictureInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR
	PNext           unsafe.Pointer
	PStdPictureInfo *int32
	// sliceCount
	PSliceOffsets []uint32
}

type _vkVideoDecodeH264PictureInfoKHR struct {
	sType           StructureType
	pNext           unsafe.Pointer
	pStdPictureInfo *int32
	sliceCount      uint32
	pSliceOffsets   *uint32
}

func (s *_vkVideoDecodeH264PictureInfoKHR) Goify() *VideoDecodeH264PictureInfoKHR {
	rval := &VideoDecodeH264PictureInfoKHR{
		PNext:           (unsafe.Pointer)(s.pNext),
		PStdPictureInfo: (*int32)(s.pStdPictureInfo),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSliceOffsets in returned struct
	}
	return rval
}
func (s *VideoDecodeH264PictureInfoKHR) Vulkanize() *_vkVideoDecodeH264PictureInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pSliceOffsets *uint32
	if len(s.PSliceOffsets) > 0 {
		psl_pSliceOffsets = &s.PSliceOffsets[0]
	}
	rval := &_vkVideoDecodeH264PictureInfoKHR{
		sType:           STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR, /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                         /*cb*/
		pStdPictureInfo: (*int32)(s.PStdPictureInfo),                       /*cb*/
		sliceCount:      uint32(len(s.PSliceOffsets)),                      /*c6-a*/
		pSliceOffsets:   psl_pSliceOffsets,                                 /*c rem*/
	}
	return rval
}

// VideoDecodeH264ProfileInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264ProfileInfoKHR.html
type VideoDecodeH264ProfileInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR
	PNext         unsafe.Pointer
	StdProfileIdc int32
	PictureLayout VideoDecodeH264PictureLayoutFlagBitsKHR
}

type _vkVideoDecodeH264ProfileInfoKHR struct {
	sType         StructureType
	pNext         unsafe.Pointer
	stdProfileIdc int32
	pictureLayout VideoDecodeH264PictureLayoutFlagBitsKHR
}

func (s *_vkVideoDecodeH264ProfileInfoKHR) Goify() *VideoDecodeH264ProfileInfoKHR {
	rval := &VideoDecodeH264ProfileInfoKHR{
		PNext:         (unsafe.Pointer)(s.pNext),
		StdProfileIdc: (int32)(s.stdProfileIdc),
		PictureLayout: (VideoDecodeH264PictureLayoutFlagBitsKHR)(s.pictureLayout),
	}
	return rval
}
func (s *VideoDecodeH264ProfileInfoKHR) Vulkanize() *_vkVideoDecodeH264ProfileInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeH264ProfileInfoKHR{
		sType:         STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR,          /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                                  /*cb*/
		stdProfileIdc: (int32)(s.StdProfileIdc),                                   /*cb*/
		pictureLayout: (VideoDecodeH264PictureLayoutFlagBitsKHR)(s.PictureLayout), /*cb*/
	}
	return rval
}

// VideoDecodeH264SessionParametersAddInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersAddInfoKHR.html
type VideoDecodeH264SessionParametersAddInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR
	PNext unsafe.Pointer
	// stdSPSCount
	PStdSPSs []int32
	// stdPPSCount
	//  List of Picture Parameters associated with the spsStd, above;
	PStdPPSs []int32
}

type _vkVideoDecodeH264SessionParametersAddInfoKHR struct {
	sType       StructureType
	pNext       unsafe.Pointer
	stdSPSCount uint32
	pStdSPSs    *int32
	stdPPSCount uint32
	pStdPPSs    *int32
}

func (s *_vkVideoDecodeH264SessionParametersAddInfoKHR) Goify() *VideoDecodeH264SessionParametersAddInfoKHR {
	rval := &VideoDecodeH264SessionParametersAddInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStdSPSs in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStdPPSs in returned struct
	}
	return rval
}
func (s *VideoDecodeH264SessionParametersAddInfoKHR) Vulkanize() *_vkVideoDecodeH264SessionParametersAddInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pStdSPSs *int32
	if len(s.PStdSPSs) > 0 {
		psl_pStdSPSs = &s.PStdSPSs[0]
	}

	var psl_pStdPPSs *int32
	if len(s.PStdPPSs) > 0 {
		psl_pStdPPSs = &s.PStdPPSs[0]
	}
	rval := &_vkVideoDecodeH264SessionParametersAddInfoKHR{
		sType:       STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                                        /*cb*/
		stdSPSCount: uint32(len(s.PStdSPSs)),                                          /*c6-a*/
		pStdSPSs:    psl_pStdSPSs,                                                     /*c rem*/
		stdPPSCount: uint32(len(s.PStdPPSs)),                                          /*c6-a*/
		pStdPPSs:    psl_pStdPPSs,                                                     /*c rem*/
	}
	return rval
}

// VideoDecodeH264SessionParametersCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersCreateInfoKHR.html
type VideoDecodeH264SessionParametersCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR
	PNext              unsafe.Pointer
	MaxStdSPSCount     uint32
	MaxStdPPSCount     uint32
	PParametersAddInfo *VideoDecodeH264SessionParametersAddInfoKHR
}

type _vkVideoDecodeH264SessionParametersCreateInfoKHR struct {
	sType              StructureType
	pNext              unsafe.Pointer
	maxStdSPSCount     uint32
	maxStdPPSCount     uint32
	pParametersAddInfo *_vkVideoDecodeH264SessionParametersAddInfoKHR
}

func (s *_vkVideoDecodeH264SessionParametersCreateInfoKHR) Goify() *VideoDecodeH264SessionParametersCreateInfoKHR {
	rval := &VideoDecodeH264SessionParametersCreateInfoKHR{
		PNext:          (unsafe.Pointer)(s.pNext),
		MaxStdSPSCount: (uint32)(s.maxStdSPSCount),
		MaxStdPPSCount: (uint32)(s.maxStdPPSCount),
		// Unexpected pointer member pParametersAddInfo in returned struct
	}
	return rval
}
func (s *VideoDecodeH264SessionParametersCreateInfoKHR) Vulkanize() *_vkVideoDecodeH264SessionParametersCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeH264SessionParametersCreateInfoKHR{
		sType:              STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                           /*cb*/
		maxStdSPSCount:     (uint32)(s.MaxStdSPSCount),                                          /*cb*/
		maxStdPPSCount:     (uint32)(s.MaxStdPPSCount),                                          /*cb*/
		pParametersAddInfo: (s.PParametersAddInfo.Vulkanize()),                                  /*c rem*/
	}
	return rval
}

// VideoDecodeH265CapabilitiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265CapabilitiesKHR.html
type VideoDecodeH265CapabilitiesKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR
	PNext       unsafe.Pointer
	MaxLevelIdc int32
}

// WARNING - struct VideoDecodeH265CapabilitiesKHR is returned only, which is not yet handled in the binding
type _vkVideoDecodeH265CapabilitiesKHR struct {
	sType       StructureType
	pNext       unsafe.Pointer
	maxLevelIdc int32
}

func (s *_vkVideoDecodeH265CapabilitiesKHR) Goify() *VideoDecodeH265CapabilitiesKHR {
	rval := &VideoDecodeH265CapabilitiesKHR{
		PNext:       (unsafe.Pointer)(s.pNext),
		MaxLevelIdc: (int32)(s.maxLevelIdc),
	}
	return rval
}
func (s *VideoDecodeH265CapabilitiesKHR) Vulkanize() *_vkVideoDecodeH265CapabilitiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeH265CapabilitiesKHR{
		sType:       STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                         /*cb*/
		maxLevelIdc: (int32)(s.MaxLevelIdc),                            /*cb*/
	}
	return rval
}

// VideoDecodeH265DpbSlotInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265DpbSlotInfoKHR.html
type VideoDecodeH265DpbSlotInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR
	PNext             unsafe.Pointer
	PStdReferenceInfo *int32
}

type _vkVideoDecodeH265DpbSlotInfoKHR struct {
	sType             StructureType
	pNext             unsafe.Pointer
	pStdReferenceInfo *int32
}

func (s *_vkVideoDecodeH265DpbSlotInfoKHR) Goify() *VideoDecodeH265DpbSlotInfoKHR {
	rval := &VideoDecodeH265DpbSlotInfoKHR{
		PNext:             (unsafe.Pointer)(s.pNext),
		PStdReferenceInfo: (*int32)(s.pStdReferenceInfo),
	}
	return rval
}
func (s *VideoDecodeH265DpbSlotInfoKHR) Vulkanize() *_vkVideoDecodeH265DpbSlotInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeH265DpbSlotInfoKHR{
		sType:             STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, /*c1*/
		pNext:             (unsafe.Pointer)(s.PNext),                          /*cb*/
		pStdReferenceInfo: (*int32)(s.PStdReferenceInfo),                      /*cb*/
	}
	return rval
}

// VideoDecodeH265PictureInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265PictureInfoKHR.html
type VideoDecodeH265PictureInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR
	PNext           unsafe.Pointer
	PStdPictureInfo *int32
	// sliceSegmentCount
	PSliceSegmentOffsets []uint32
}

type _vkVideoDecodeH265PictureInfoKHR struct {
	sType                StructureType
	pNext                unsafe.Pointer
	pStdPictureInfo      *int32
	sliceSegmentCount    uint32
	pSliceSegmentOffsets *uint32
}

func (s *_vkVideoDecodeH265PictureInfoKHR) Goify() *VideoDecodeH265PictureInfoKHR {
	rval := &VideoDecodeH265PictureInfoKHR{
		PNext:           (unsafe.Pointer)(s.pNext),
		PStdPictureInfo: (*int32)(s.pStdPictureInfo),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pSliceSegmentOffsets in returned struct
	}
	return rval
}
func (s *VideoDecodeH265PictureInfoKHR) Vulkanize() *_vkVideoDecodeH265PictureInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pSliceSegmentOffsets *uint32
	if len(s.PSliceSegmentOffsets) > 0 {
		psl_pSliceSegmentOffsets = &s.PSliceSegmentOffsets[0]
	}
	rval := &_vkVideoDecodeH265PictureInfoKHR{
		sType:                STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR, /*c1*/
		pNext:                (unsafe.Pointer)(s.PNext),                         /*cb*/
		pStdPictureInfo:      (*int32)(s.PStdPictureInfo),                       /*cb*/
		sliceSegmentCount:    uint32(len(s.PSliceSegmentOffsets)),               /*c6-a*/
		pSliceSegmentOffsets: psl_pSliceSegmentOffsets,                          /*c rem*/
	}
	return rval
}

// VideoDecodeH265ProfileInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265ProfileInfoKHR.html
type VideoDecodeH265ProfileInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR
	PNext         unsafe.Pointer
	StdProfileIdc int32
}

type _vkVideoDecodeH265ProfileInfoKHR struct {
	sType         StructureType
	pNext         unsafe.Pointer
	stdProfileIdc int32
}

func (s *_vkVideoDecodeH265ProfileInfoKHR) Goify() *VideoDecodeH265ProfileInfoKHR {
	rval := &VideoDecodeH265ProfileInfoKHR{
		PNext:         (unsafe.Pointer)(s.pNext),
		StdProfileIdc: (int32)(s.stdProfileIdc),
	}
	return rval
}
func (s *VideoDecodeH265ProfileInfoKHR) Vulkanize() *_vkVideoDecodeH265ProfileInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeH265ProfileInfoKHR{
		sType:         STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, /*c1*/
		pNext:         (unsafe.Pointer)(s.PNext),                         /*cb*/
		stdProfileIdc: (int32)(s.StdProfileIdc),                          /*cb*/
	}
	return rval
}

// VideoDecodeH265SessionParametersAddInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersAddInfoKHR.html
type VideoDecodeH265SessionParametersAddInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR
	PNext unsafe.Pointer
	// stdVPSCount
	PStdVPSs []int32
	// stdSPSCount
	PStdSPSs []int32
	// stdPPSCount
	//  List of Picture Parameters associated with the spsStd, above;
	PStdPPSs []int32
}

type _vkVideoDecodeH265SessionParametersAddInfoKHR struct {
	sType       StructureType
	pNext       unsafe.Pointer
	stdVPSCount uint32
	pStdVPSs    *int32
	stdSPSCount uint32
	pStdSPSs    *int32
	stdPPSCount uint32
	pStdPPSs    *int32
}

func (s *_vkVideoDecodeH265SessionParametersAddInfoKHR) Goify() *VideoDecodeH265SessionParametersAddInfoKHR {
	rval := &VideoDecodeH265SessionParametersAddInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStdVPSs in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStdSPSs in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pStdPPSs in returned struct
	}
	return rval
}
func (s *VideoDecodeH265SessionParametersAddInfoKHR) Vulkanize() *_vkVideoDecodeH265SessionParametersAddInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pStdVPSs *int32
	if len(s.PStdVPSs) > 0 {
		psl_pStdVPSs = &s.PStdVPSs[0]
	}

	var psl_pStdSPSs *int32
	if len(s.PStdSPSs) > 0 {
		psl_pStdSPSs = &s.PStdSPSs[0]
	}

	var psl_pStdPPSs *int32
	if len(s.PStdPPSs) > 0 {
		psl_pStdPPSs = &s.PStdPPSs[0]
	}
	rval := &_vkVideoDecodeH265SessionParametersAddInfoKHR{
		sType:       STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, /*c1*/
		pNext:       (unsafe.Pointer)(s.PNext),                                        /*cb*/
		stdVPSCount: uint32(len(s.PStdVPSs)),                                          /*c6-a*/
		pStdVPSs:    psl_pStdVPSs,                                                     /*c rem*/
		stdSPSCount: uint32(len(s.PStdSPSs)),                                          /*c6-a*/
		pStdSPSs:    psl_pStdSPSs,                                                     /*c rem*/
		stdPPSCount: uint32(len(s.PStdPPSs)),                                          /*c6-a*/
		pStdPPSs:    psl_pStdPPSs,                                                     /*c rem*/
	}
	return rval
}

// VideoDecodeH265SessionParametersCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersCreateInfoKHR.html
type VideoDecodeH265SessionParametersCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR
	PNext              unsafe.Pointer
	MaxStdVPSCount     uint32
	MaxStdSPSCount     uint32
	MaxStdPPSCount     uint32
	PParametersAddInfo *VideoDecodeH265SessionParametersAddInfoKHR
}

type _vkVideoDecodeH265SessionParametersCreateInfoKHR struct {
	sType              StructureType
	pNext              unsafe.Pointer
	maxStdVPSCount     uint32
	maxStdSPSCount     uint32
	maxStdPPSCount     uint32
	pParametersAddInfo *_vkVideoDecodeH265SessionParametersAddInfoKHR
}

func (s *_vkVideoDecodeH265SessionParametersCreateInfoKHR) Goify() *VideoDecodeH265SessionParametersCreateInfoKHR {
	rval := &VideoDecodeH265SessionParametersCreateInfoKHR{
		PNext:          (unsafe.Pointer)(s.pNext),
		MaxStdVPSCount: (uint32)(s.maxStdVPSCount),
		MaxStdSPSCount: (uint32)(s.maxStdSPSCount),
		MaxStdPPSCount: (uint32)(s.maxStdPPSCount),
		// Unexpected pointer member pParametersAddInfo in returned struct
	}
	return rval
}
func (s *VideoDecodeH265SessionParametersCreateInfoKHR) Vulkanize() *_vkVideoDecodeH265SessionParametersCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeH265SessionParametersCreateInfoKHR{
		sType:              STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                                           /*cb*/
		maxStdVPSCount:     (uint32)(s.MaxStdVPSCount),                                          /*cb*/
		maxStdSPSCount:     (uint32)(s.MaxStdSPSCount),                                          /*cb*/
		maxStdPPSCount:     (uint32)(s.MaxStdPPSCount),                                          /*cb*/
		pParametersAddInfo: (s.PParametersAddInfo.Vulkanize()),                                  /*c rem*/
	}
	return rval
}

// VideoDecodeInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeInfoKHR.html
type VideoDecodeInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR
	PNext               unsafe.Pointer
	Flags               VideoDecodeFlagsKHR
	SrcBuffer           Buffer
	SrcBufferOffset     DeviceSize
	SrcBufferRange      DeviceSize
	DstPictureResource  VideoPictureResourceInfoKHR
	PSetupReferenceSlot *VideoReferenceSlotInfoKHR
	// referenceSlotCount
	PReferenceSlots []VideoReferenceSlotInfoKHR
}

type _vkVideoDecodeInfoKHR struct {
	sType               StructureType
	pNext               unsafe.Pointer
	flags               VideoDecodeFlagsKHR
	srcBuffer           Buffer
	srcBufferOffset     DeviceSize
	srcBufferRange      DeviceSize
	dstPictureResource  _vkVideoPictureResourceInfoKHR
	pSetupReferenceSlot *_vkVideoReferenceSlotInfoKHR
	referenceSlotCount  uint32
	pReferenceSlots     *_vkVideoReferenceSlotInfoKHR
}

func (s *_vkVideoDecodeInfoKHR) Goify() *VideoDecodeInfoKHR {
	rval := &VideoDecodeInfoKHR{
		PNext:              (unsafe.Pointer)(s.pNext),
		Flags:              (VideoDecodeFlagsKHR)(s.flags),
		SrcBuffer:          (Buffer)(s.srcBuffer),
		SrcBufferOffset:    (DeviceSize)(s.srcBufferOffset),
		SrcBufferRange:     (DeviceSize)(s.srcBufferRange),
		DstPictureResource: *(s.dstPictureResource.Goify()),
		// Unexpected pointer member pSetupReferenceSlot in returned struct
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pReferenceSlots in returned struct
	}
	return rval
}
func (s *VideoDecodeInfoKHR) Vulkanize() *_vkVideoDecodeInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pReferenceSlots *_vkVideoReferenceSlotInfoKHR
	if len(s.PReferenceSlots) > 0 {
		sl_pReferenceSlots := make([]_vkVideoReferenceSlotInfoKHR, len(s.PReferenceSlots))
		for i, v := range s.PReferenceSlots {
			sl_pReferenceSlots[i] = *(v.Vulkanize())
		}
		psl_pReferenceSlots = &sl_pReferenceSlots[0]
	}
	rval := &_vkVideoDecodeInfoKHR{
		sType:               STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),            /*cb*/
		flags:               (VideoDecodeFlagsKHR)(s.Flags),       /*cb*/
		srcBuffer:           (Buffer)(s.SrcBuffer),                /*cb*/
		srcBufferOffset:     (DeviceSize)(s.SrcBufferOffset),      /*cb*/
		srcBufferRange:      (DeviceSize)(s.SrcBufferRange),       /*cb*/
		dstPictureResource:  *(s.DstPictureResource.Vulkanize()),  /*c3*/
		pSetupReferenceSlot: (s.PSetupReferenceSlot.Vulkanize()),  /*c rem*/
		referenceSlotCount:  uint32(len(s.PReferenceSlots)),       /*c6-a*/
		pReferenceSlots:     psl_pReferenceSlots,                  /*c rem*/
	}
	return rval
}

// VideoDecodeUsageInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeUsageInfoKHR.html
type VideoDecodeUsageInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR
	PNext           unsafe.Pointer
	VideoUsageHints VideoDecodeUsageFlagsKHR
}

type _vkVideoDecodeUsageInfoKHR struct {
	sType           StructureType
	pNext           unsafe.Pointer
	videoUsageHints VideoDecodeUsageFlagsKHR
}

func (s *_vkVideoDecodeUsageInfoKHR) Goify() *VideoDecodeUsageInfoKHR {
	rval := &VideoDecodeUsageInfoKHR{
		PNext:           (unsafe.Pointer)(s.pNext),
		VideoUsageHints: (VideoDecodeUsageFlagsKHR)(s.videoUsageHints),
	}
	return rval
}
func (s *VideoDecodeUsageInfoKHR) Vulkanize() *_vkVideoDecodeUsageInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoDecodeUsageInfoKHR{
		sType:           STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR,    /*c1*/
		pNext:           (unsafe.Pointer)(s.PNext),                     /*cb*/
		videoUsageHints: (VideoDecodeUsageFlagsKHR)(s.VideoUsageHints), /*cb*/
	}
	return rval
}

// VideoEndCodingInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingInfoKHR.html
type VideoEndCodingInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR
	PNext unsafe.Pointer
	Flags VideoEndCodingFlagsKHR
}

type _vkVideoEndCodingInfoKHR struct {
	sType StructureType
	pNext unsafe.Pointer
	flags VideoEndCodingFlagsKHR
}

func (s *_vkVideoEndCodingInfoKHR) Goify() *VideoEndCodingInfoKHR {
	rval := &VideoEndCodingInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		Flags: (VideoEndCodingFlagsKHR)(s.flags),
	}
	return rval
}
func (s *VideoEndCodingInfoKHR) Vulkanize() *_vkVideoEndCodingInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoEndCodingInfoKHR{
		sType: STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR, /*c1*/
		pNext: (unsafe.Pointer)(s.PNext),                /*cb*/
		flags: (VideoEndCodingFlagsKHR)(s.Flags),        /*cb*/
	}
	return rval
}

// VideoFormatPropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoFormatPropertiesKHR.html
type VideoFormatPropertiesKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR
	PNext            unsafe.Pointer
	Format           Format
	ComponentMapping ComponentMapping
	ImageCreateFlags ImageCreateFlags
	ImageType        ImageType
	ImageTiling      ImageTiling
	ImageUsageFlags  ImageUsageFlags
}

// WARNING - struct VideoFormatPropertiesKHR is returned only, which is not yet handled in the binding
type _vkVideoFormatPropertiesKHR struct {
	sType            StructureType
	pNext            unsafe.Pointer
	format           Format
	componentMapping _vkComponentMapping
	imageCreateFlags ImageCreateFlags
	imageType        ImageType
	imageTiling      ImageTiling
	imageUsageFlags  ImageUsageFlags
}

func (s *_vkVideoFormatPropertiesKHR) Goify() *VideoFormatPropertiesKHR {
	rval := &VideoFormatPropertiesKHR{
		PNext:            (unsafe.Pointer)(s.pNext),
		Format:           (Format)(s.format),
		ComponentMapping: (ComponentMapping)(s.componentMapping),
		ImageCreateFlags: (ImageCreateFlags)(s.imageCreateFlags),
		ImageType:        (ImageType)(s.imageType),
		ImageTiling:      (ImageTiling)(s.imageTiling),
		ImageUsageFlags:  (ImageUsageFlags)(s.imageUsageFlags),
	}
	return rval
}
func (s *VideoFormatPropertiesKHR) Vulkanize() *_vkVideoFormatPropertiesKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoFormatPropertiesKHR{
		sType:            STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                  /*cb*/
		format:           (Format)(s.Format),                         /*cb*/
		componentMapping: (_vkComponentMapping)(s.ComponentMapping),  /*cb*/
		imageCreateFlags: (ImageCreateFlags)(s.ImageCreateFlags),     /*cb*/
		imageType:        (ImageType)(s.ImageType),                   /*cb*/
		imageTiling:      (ImageTiling)(s.ImageTiling),               /*cb*/
		imageUsageFlags:  (ImageUsageFlags)(s.ImageUsageFlags),       /*cb*/
	}
	return rval
}

// VideoPictureResourceInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoPictureResourceInfoKHR.html
type VideoPictureResourceInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR
	PNext unsafe.Pointer
	//  The offset to be used for the picture resource, currently only used in field mode;
	CodedOffset Offset2D
	//  The extent to be used for the picture resource;
	CodedExtent Extent2D
	//  The first array layer to be accessed for the Decode or Encode Operations;
	BaseArrayLayer uint32
	//  The ImageView binding of the resource;
	ImageViewBinding ImageView
}

type _vkVideoPictureResourceInfoKHR struct {
	sType            StructureType
	pNext            unsafe.Pointer
	codedOffset      _vkOffset2D
	codedExtent      _vkExtent2D
	baseArrayLayer   uint32
	imageViewBinding ImageView
}

func (s *_vkVideoPictureResourceInfoKHR) Goify() *VideoPictureResourceInfoKHR {
	rval := &VideoPictureResourceInfoKHR{
		PNext:            (unsafe.Pointer)(s.pNext),
		CodedOffset:      (Offset2D)(s.codedOffset),
		CodedExtent:      (Extent2D)(s.codedExtent),
		BaseArrayLayer:   (uint32)(s.baseArrayLayer),
		ImageViewBinding: (ImageView)(s.imageViewBinding),
	}
	return rval
}
func (s *VideoPictureResourceInfoKHR) Vulkanize() *_vkVideoPictureResourceInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoPictureResourceInfoKHR{
		sType:            STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                      /*cb*/
		codedOffset:      (_vkOffset2D)(s.CodedOffset),                   /*cb*/
		codedExtent:      (_vkExtent2D)(s.CodedExtent),                   /*cb*/
		baseArrayLayer:   (uint32)(s.BaseArrayLayer),                     /*cb*/
		imageViewBinding: (ImageView)(s.ImageViewBinding),                /*cb*/
	}
	return rval
}

// VideoProfileInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileInfoKHR.html
type VideoProfileInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR
	PNext               unsafe.Pointer
	VideoCodecOperation VideoCodecOperationFlagBitsKHR
	ChromaSubsampling   VideoChromaSubsamplingFlagsKHR
	LumaBitDepth        VideoComponentBitDepthFlagsKHR
	ChromaBitDepth      VideoComponentBitDepthFlagsKHR
}

type _vkVideoProfileInfoKHR struct {
	sType               StructureType
	pNext               unsafe.Pointer
	videoCodecOperation VideoCodecOperationFlagBitsKHR
	chromaSubsampling   VideoChromaSubsamplingFlagsKHR
	lumaBitDepth        VideoComponentBitDepthFlagsKHR
	chromaBitDepth      VideoComponentBitDepthFlagsKHR
}

func (s *_vkVideoProfileInfoKHR) Goify() *VideoProfileInfoKHR {
	rval := &VideoProfileInfoKHR{
		PNext:               (unsafe.Pointer)(s.pNext),
		VideoCodecOperation: (VideoCodecOperationFlagBitsKHR)(s.videoCodecOperation),
		ChromaSubsampling:   (VideoChromaSubsamplingFlagsKHR)(s.chromaSubsampling),
		LumaBitDepth:        (VideoComponentBitDepthFlagsKHR)(s.lumaBitDepth),
		ChromaBitDepth:      (VideoComponentBitDepthFlagsKHR)(s.chromaBitDepth),
	}
	return rval
}
func (s *VideoProfileInfoKHR) Vulkanize() *_vkVideoProfileInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoProfileInfoKHR{
		sType:               STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,                   /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                               /*cb*/
		videoCodecOperation: (VideoCodecOperationFlagBitsKHR)(s.VideoCodecOperation), /*cb*/
		chromaSubsampling:   (VideoChromaSubsamplingFlagsKHR)(s.ChromaSubsampling),   /*cb*/
		lumaBitDepth:        (VideoComponentBitDepthFlagsKHR)(s.LumaBitDepth),        /*cb*/
		chromaBitDepth:      (VideoComponentBitDepthFlagsKHR)(s.ChromaBitDepth),      /*cb*/
	}
	return rval
}

// VideoProfileListInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileListInfoKHR.html
type VideoProfileListInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR
	PNext unsafe.Pointer
	// profileCount
	PProfiles []VideoProfileInfoKHR
}

type _vkVideoProfileListInfoKHR struct {
	sType        StructureType
	pNext        unsafe.Pointer
	profileCount uint32
	pProfiles    *_vkVideoProfileInfoKHR
}

func (s *_vkVideoProfileListInfoKHR) Goify() *VideoProfileListInfoKHR {
	rval := &VideoProfileListInfoKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pProfiles in returned struct
	}
	return rval
}
func (s *VideoProfileListInfoKHR) Vulkanize() *_vkVideoProfileListInfoKHR {
	if s == nil {
		return nil
	}

	var psl_pProfiles *_vkVideoProfileInfoKHR
	if len(s.PProfiles) > 0 {
		sl_pProfiles := make([]_vkVideoProfileInfoKHR, len(s.PProfiles))
		for i, v := range s.PProfiles {
			sl_pProfiles[i] = *(v.Vulkanize())
		}
		psl_pProfiles = &sl_pProfiles[0]
	}
	rval := &_vkVideoProfileListInfoKHR{
		sType:        STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, /*c1*/
		pNext:        (unsafe.Pointer)(s.PNext),                  /*cb*/
		profileCount: uint32(len(s.PProfiles)),                   /*c6-a*/
		pProfiles:    psl_pProfiles,                              /*c rem*/
	}
	return rval
}

// VideoReferenceSlotInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoReferenceSlotInfoKHR.html
type VideoReferenceSlotInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR
	PNext unsafe.Pointer
	//  The reference slot index;
	SlotIndex int32
	//  The reference picture resource;
	PPictureResource *VideoPictureResourceInfoKHR
}

type _vkVideoReferenceSlotInfoKHR struct {
	sType            StructureType
	pNext            unsafe.Pointer
	slotIndex        int32
	pPictureResource *_vkVideoPictureResourceInfoKHR
}

func (s *_vkVideoReferenceSlotInfoKHR) Goify() *VideoReferenceSlotInfoKHR {
	rval := &VideoReferenceSlotInfoKHR{
		PNext:     (unsafe.Pointer)(s.pNext),
		SlotIndex: (int32)(s.slotIndex),
		// Unexpected pointer member pPictureResource in returned struct
	}
	return rval
}
func (s *VideoReferenceSlotInfoKHR) Vulkanize() *_vkVideoReferenceSlotInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoReferenceSlotInfoKHR{
		sType:            STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),                    /*cb*/
		slotIndex:        (int32)(s.SlotIndex),                         /*cb*/
		pPictureResource: (s.PPictureResource.Vulkanize()),             /*c rem*/
	}
	return rval
}

// VideoSessionCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateInfoKHR.html
type VideoSessionCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR
	PNext                      unsafe.Pointer
	QueueFamilyIndex           uint32
	Flags                      VideoSessionCreateFlagsKHR
	PVideoProfile              *VideoProfileInfoKHR
	PictureFormat              Format
	MaxCodedExtent             Extent2D
	ReferencePictureFormat     Format
	MaxDpbSlots                uint32
	MaxActiveReferencePictures uint32
	PStdHeaderVersion          *ExtensionProperties
}

type _vkVideoSessionCreateInfoKHR struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	queueFamilyIndex           uint32
	flags                      VideoSessionCreateFlagsKHR
	pVideoProfile              *_vkVideoProfileInfoKHR
	pictureFormat              Format
	maxCodedExtent             _vkExtent2D
	referencePictureFormat     Format
	maxDpbSlots                uint32
	maxActiveReferencePictures uint32
	pStdHeaderVersion          *_vkExtensionProperties
}

func (s *_vkVideoSessionCreateInfoKHR) Goify() *VideoSessionCreateInfoKHR {
	rval := &VideoSessionCreateInfoKHR{
		PNext:            (unsafe.Pointer)(s.pNext),
		QueueFamilyIndex: (uint32)(s.queueFamilyIndex),
		Flags:            (VideoSessionCreateFlagsKHR)(s.flags),
		// Unexpected pointer member pVideoProfile in returned struct
		PictureFormat:              (Format)(s.pictureFormat),
		MaxCodedExtent:             (Extent2D)(s.maxCodedExtent),
		ReferencePictureFormat:     (Format)(s.referencePictureFormat),
		MaxDpbSlots:                (uint32)(s.maxDpbSlots),
		MaxActiveReferencePictures: (uint32)(s.maxActiveReferencePictures),
		// Unexpected pointer member pStdHeaderVersion in returned struct
	}
	return rval
}
func (s *VideoSessionCreateInfoKHR) Vulkanize() *_vkVideoSessionCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoSessionCreateInfoKHR{
		sType:                      STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                    /*cb*/
		queueFamilyIndex:           (uint32)(s.QueueFamilyIndex),                 /*cb*/
		flags:                      (VideoSessionCreateFlagsKHR)(s.Flags),        /*cb*/
		pVideoProfile:              (s.PVideoProfile.Vulkanize()),                /*c rem*/
		pictureFormat:              (Format)(s.PictureFormat),                    /*cb*/
		maxCodedExtent:             (_vkExtent2D)(s.MaxCodedExtent),              /*cb*/
		referencePictureFormat:     (Format)(s.ReferencePictureFormat),           /*cb*/
		maxDpbSlots:                (uint32)(s.MaxDpbSlots),                      /*cb*/
		maxActiveReferencePictures: (uint32)(s.MaxActiveReferencePictures),       /*cb*/
		pStdHeaderVersion:          (s.PStdHeaderVersion.Vulkanize()),            /*c rem*/
	}
	return rval
}

// VideoSessionMemoryRequirementsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionMemoryRequirementsKHR.html
type VideoSessionMemoryRequirementsKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR
	PNext              unsafe.Pointer
	MemoryBindIndex    uint32
	MemoryRequirements MemoryRequirements
}

// WARNING - struct VideoSessionMemoryRequirementsKHR is returned only, which is not yet handled in the binding
type _vkVideoSessionMemoryRequirementsKHR struct {
	sType              StructureType
	pNext              unsafe.Pointer
	memoryBindIndex    uint32
	memoryRequirements _vkMemoryRequirements
}

func (s *_vkVideoSessionMemoryRequirementsKHR) Goify() *VideoSessionMemoryRequirementsKHR {
	rval := &VideoSessionMemoryRequirementsKHR{
		PNext:              (unsafe.Pointer)(s.pNext),
		MemoryBindIndex:    (uint32)(s.memoryBindIndex),
		MemoryRequirements: (MemoryRequirements)(s.memoryRequirements),
	}
	return rval
}
func (s *VideoSessionMemoryRequirementsKHR) Vulkanize() *_vkVideoSessionMemoryRequirementsKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoSessionMemoryRequirementsKHR{
		sType:              STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR, /*c1*/
		pNext:              (unsafe.Pointer)(s.PNext),                            /*cb*/
		memoryBindIndex:    (uint32)(s.MemoryBindIndex),                          /*cb*/
		memoryRequirements: (_vkMemoryRequirements)(s.MemoryRequirements),        /*cb*/
	}
	return rval
}

// VideoSessionParametersCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateInfoKHR.html
type VideoSessionParametersCreateInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR
	PNext                          unsafe.Pointer
	Flags                          VideoSessionParametersCreateFlagsKHR
	VideoSessionParametersTemplate VideoSessionParametersKHR
	VideoSession                   VideoSessionKHR
}

type _vkVideoSessionParametersCreateInfoKHR struct {
	sType                          StructureType
	pNext                          unsafe.Pointer
	flags                          VideoSessionParametersCreateFlagsKHR
	videoSessionParametersTemplate VideoSessionParametersKHR
	videoSession                   VideoSessionKHR
}

func (s *_vkVideoSessionParametersCreateInfoKHR) Goify() *VideoSessionParametersCreateInfoKHR {
	rval := &VideoSessionParametersCreateInfoKHR{
		PNext:                          (unsafe.Pointer)(s.pNext),
		Flags:                          (VideoSessionParametersCreateFlagsKHR)(s.flags),
		VideoSessionParametersTemplate: (VideoSessionParametersKHR)(s.videoSessionParametersTemplate),
		VideoSession:                   (VideoSessionKHR)(s.videoSession),
	}
	return rval
}
func (s *VideoSessionParametersCreateInfoKHR) Vulkanize() *_vkVideoSessionParametersCreateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoSessionParametersCreateInfoKHR{
		sType:                          STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,       /*c1*/
		pNext:                          (unsafe.Pointer)(s.PNext),                                     /*cb*/
		flags:                          (VideoSessionParametersCreateFlagsKHR)(s.Flags),               /*cb*/
		videoSessionParametersTemplate: (VideoSessionParametersKHR)(s.VideoSessionParametersTemplate), /*cb*/
		videoSession:                   (VideoSessionKHR)(s.VideoSession),                             /*cb*/
	}
	return rval
}

// VideoSessionParametersUpdateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersUpdateInfoKHR.html
type VideoSessionParametersUpdateInfoKHR struct {
	// SType = STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR
	PNext               unsafe.Pointer
	UpdateSequenceCount uint32
}

type _vkVideoSessionParametersUpdateInfoKHR struct {
	sType               StructureType
	pNext               unsafe.Pointer
	updateSequenceCount uint32
}

func (s *_vkVideoSessionParametersUpdateInfoKHR) Goify() *VideoSessionParametersUpdateInfoKHR {
	rval := &VideoSessionParametersUpdateInfoKHR{
		PNext:               (unsafe.Pointer)(s.pNext),
		UpdateSequenceCount: (uint32)(s.updateSequenceCount),
	}
	return rval
}
func (s *VideoSessionParametersUpdateInfoKHR) Vulkanize() *_vkVideoSessionParametersUpdateInfoKHR {
	if s == nil {
		return nil
	}
	rval := &_vkVideoSessionParametersUpdateInfoKHR{
		sType:               STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR, /*c1*/
		pNext:               (unsafe.Pointer)(s.PNext),                               /*cb*/
		updateSequenceCount: (uint32)(s.UpdateSequenceCount),                         /*cb*/
	}
	return rval
}

// Viewport: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewport.html
type Viewport struct {
	X        float32
	Y        float32
	Width    float32
	Height   float32
	MinDepth float32
	MaxDepth float32
}

type _vkViewport = Viewport

func (s *_vkViewport) Goify() *Viewport {
	rval := (*Viewport)(s)
	return rval
}
func (s *Viewport) Vulkanize() *_vkViewport {
	if s == nil {
		return nil
	}
	rval := (*_vkViewport)(s)
	return rval
}

// ViewportSwizzleNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportSwizzleNV.html
type ViewportSwizzleNV struct {
	X ViewportCoordinateSwizzleNV
	Y ViewportCoordinateSwizzleNV
	Z ViewportCoordinateSwizzleNV
	W ViewportCoordinateSwizzleNV
}

type _vkViewportSwizzleNV = ViewportSwizzleNV

func (s *_vkViewportSwizzleNV) Goify() *ViewportSwizzleNV {
	rval := (*ViewportSwizzleNV)(s)
	return rval
}
func (s *ViewportSwizzleNV) Vulkanize() *_vkViewportSwizzleNV {
	if s == nil {
		return nil
	}
	rval := (*_vkViewportSwizzleNV)(s)
	return rval
}

// ViewportWScalingNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportWScalingNV.html
type ViewportWScalingNV struct {
	Xcoeff float32
	Ycoeff float32
}

type _vkViewportWScalingNV = ViewportWScalingNV

func (s *_vkViewportWScalingNV) Goify() *ViewportWScalingNV {
	rval := (*ViewportWScalingNV)(s)
	return rval
}
func (s *ViewportWScalingNV) Vulkanize() *_vkViewportWScalingNV {
	if s == nil {
		return nil
	}
	rval := (*_vkViewportWScalingNV)(s)
	return rval
}

// WriteDescriptorSet: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSet.html
type WriteDescriptorSet struct {
	// SType = STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
	PNext unsafe.Pointer
	//  Destination descriptor set;
	DstSet DescriptorSet
	//  Binding within the destination descriptor set to write;
	DstBinding uint32
	//  Array element within the destination binding to write;
	DstArrayElement uint32
	//  Number of descriptors to write (determines the size of the array pointed by pDescriptors);
	// descriptorCount
	//  Descriptor type to write (determines which members of the array pointed by pDescriptors are going to be used);
	DescriptorType DescriptorType
	//  Sampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types.;
	PImageInfo []DescriptorImageInfo
	//  Raw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types.;
	PBufferInfo []DescriptorBufferInfo
	//  Buffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types.;
	PTexelBufferView []BufferView
}

type _vkWriteDescriptorSet struct {
	sType            StructureType
	pNext            unsafe.Pointer
	dstSet           DescriptorSet
	dstBinding       uint32
	dstArrayElement  uint32
	descriptorCount  uint32
	descriptorType   DescriptorType
	pImageInfo       *_vkDescriptorImageInfo
	pBufferInfo      *_vkDescriptorBufferInfo
	pTexelBufferView *BufferView
}

func (s *_vkWriteDescriptorSet) Goify() *WriteDescriptorSet {
	rval := &WriteDescriptorSet{
		PNext:           (unsafe.Pointer)(s.pNext),
		DstSet:          (DescriptorSet)(s.dstSet),
		DstBinding:      (uint32)(s.dstBinding),
		DstArrayElement: (uint32)(s.dstArrayElement),
		// Unexpected 'isLenForAnotherMember'!
		DescriptorType: (DescriptorType)(s.descriptorType),
		// Unexpected pointer member pImageInfo in returned struct
		// Unexpected pointer member pBufferInfo in returned struct
		// Unexpected pointer member pTexelBufferView in returned struct
	}
	return rval
}
func (s *WriteDescriptorSet) Vulkanize() *_vkWriteDescriptorSet {
	if s == nil {
		return nil
	}

	var psl_pImageInfo *_vkDescriptorImageInfo
	if len(s.PImageInfo) > 0 {
		psl_pImageInfo = &s.PImageInfo[0]
	}

	var psl_pBufferInfo *_vkDescriptorBufferInfo
	if len(s.PBufferInfo) > 0 {
		psl_pBufferInfo = &s.PBufferInfo[0]
	}

	var psl_pTexelBufferView *BufferView
	if len(s.PTexelBufferView) > 0 {
		psl_pTexelBufferView = &s.PTexelBufferView[0]
	}
	rval := &_vkWriteDescriptorSet{
		sType:            STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, /*c1*/
		pNext:            (unsafe.Pointer)(s.PNext),           /*cb*/
		dstSet:           (DescriptorSet)(s.DstSet),           /*cb*/
		dstBinding:       (uint32)(s.DstBinding),              /*cb*/
		dstArrayElement:  (uint32)(s.DstArrayElement),         /*cb*/
		descriptorType:   (DescriptorType)(s.DescriptorType),  /*cb*/
		pImageInfo:       psl_pImageInfo,                      /*c rem*/
		pBufferInfo:      psl_pBufferInfo,                     /*c rem*/
		pTexelBufferView: psl_pTexelBufferView,                /*c rem*/
	}
	rval.descriptorCount = 0 // c6-b
	if uint32(len(s.PImageInfo)) > rval.descriptorCount {
		rval.descriptorCount = uint32(len(s.PImageInfo))
	}
	if uint32(len(s.PBufferInfo)) > rval.descriptorCount {
		rval.descriptorCount = uint32(len(s.PBufferInfo))
	}
	if uint32(len(s.PTexelBufferView)) > rval.descriptorCount {
		rval.descriptorCount = uint32(len(s.PTexelBufferView))
	}
	return rval
}

// WriteDescriptorSetAccelerationStructureKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html
type WriteDescriptorSetAccelerationStructureKHR struct {
	// SType = STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR
	PNext unsafe.Pointer
	// accelerationStructureCount
	PAccelerationStructures []AccelerationStructureKHR
}

type _vkWriteDescriptorSetAccelerationStructureKHR struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	accelerationStructureCount uint32
	pAccelerationStructures    *AccelerationStructureKHR
}

func (s *_vkWriteDescriptorSetAccelerationStructureKHR) Goify() *WriteDescriptorSetAccelerationStructureKHR {
	rval := &WriteDescriptorSetAccelerationStructureKHR{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAccelerationStructures in returned struct
	}
	return rval
}
func (s *WriteDescriptorSetAccelerationStructureKHR) Vulkanize() *_vkWriteDescriptorSetAccelerationStructureKHR {
	if s == nil {
		return nil
	}

	var psl_pAccelerationStructures *AccelerationStructureKHR
	if len(s.PAccelerationStructures) > 0 {
		psl_pAccelerationStructures = &s.PAccelerationStructures[0]
	}
	rval := &_vkWriteDescriptorSetAccelerationStructureKHR{
		sType:                      STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                      /*cb*/
		accelerationStructureCount: uint32(len(s.PAccelerationStructures)),                         /*c6-a*/
		pAccelerationStructures:    psl_pAccelerationStructures,                                    /*c rem*/
	}
	return rval
}

// WriteDescriptorSetAccelerationStructureNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureNV.html
type WriteDescriptorSetAccelerationStructureNV struct {
	// SType = STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV
	PNext unsafe.Pointer
	// accelerationStructureCount
	PAccelerationStructures []AccelerationStructureNV
}

type _vkWriteDescriptorSetAccelerationStructureNV struct {
	sType                      StructureType
	pNext                      unsafe.Pointer
	accelerationStructureCount uint32
	pAccelerationStructures    *AccelerationStructureNV
}

func (s *_vkWriteDescriptorSetAccelerationStructureNV) Goify() *WriteDescriptorSetAccelerationStructureNV {
	rval := &WriteDescriptorSetAccelerationStructureNV{
		PNext: (unsafe.Pointer)(s.pNext),
		// Unexpected 'isLenForAnotherMember'!
		// Unexpected pointer member pAccelerationStructures in returned struct
	}
	return rval
}
func (s *WriteDescriptorSetAccelerationStructureNV) Vulkanize() *_vkWriteDescriptorSetAccelerationStructureNV {
	if s == nil {
		return nil
	}

	var psl_pAccelerationStructures *AccelerationStructureNV
	if len(s.PAccelerationStructures) > 0 {
		psl_pAccelerationStructures = &s.PAccelerationStructures[0]
	}
	rval := &_vkWriteDescriptorSetAccelerationStructureNV{
		sType:                      STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, /*c1*/
		pNext:                      (unsafe.Pointer)(s.PNext),                                     /*cb*/
		accelerationStructureCount: uint32(len(s.PAccelerationStructures)),                        /*c6-a*/
		pAccelerationStructures:    psl_pAccelerationStructures,                                   /*c rem*/
	}
	return rval
}

// WriteDescriptorSetInlineUniformBlockEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetInlineUniformBlockEXT.html
type WriteDescriptorSetInlineUniformBlockEXT struct {
}

type _vkWriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlockEXT

func (s *_vkWriteDescriptorSetInlineUniformBlockEXT) Goify() *WriteDescriptorSetInlineUniformBlockEXT {
	rval := (*WriteDescriptorSetInlineUniformBlockEXT)(s)
	return rval
}
func (s *WriteDescriptorSetInlineUniformBlockEXT) Vulkanize() *_vkWriteDescriptorSetInlineUniformBlockEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkWriteDescriptorSetInlineUniformBlockEXT)(s)
	return rval
}

// XYColorEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXYColorEXT.html
type XYColorEXT struct {
	X float32
	Y float32
}

type _vkXYColorEXT = XYColorEXT

func (s *_vkXYColorEXT) Goify() *XYColorEXT {
	rval := (*XYColorEXT)(s)
	return rval
}
func (s *XYColorEXT) Vulkanize() *_vkXYColorEXT {
	if s == nil {
		return nil
	}
	rval := (*_vkXYColorEXT)(s)
	return rval
}
