Skip to content

Instantly share code, notes, and snippets.

@raizam

raizam/Vulkan.cs

Created February 26, 2019 06:51
Show Gist options
  • Save raizam/8b0819d64421cce8f41fcc75999ea7aa to your computer and use it in GitHub Desktop.
Save raizam/8b0819d64421cce8f41fcc75999ea7aa to your computer and use it in GitHub Desktop.
Download ZIP
Raw
Vulkan.cs
using System;
using System.Runtime.InteropServices;
using static LowSharp;
namespace LibVulkan
{
//VkAccelerationStructureMemoryRequirementsTypeNV
public enum VkAccelerationStructureMemoryRequirementsTypeNV : Int32
{
ObjectNv = 0,
BuildScratchNv = 1,
UpdateScratchNv = 2,
BeginRangeNv = 0,
EndRangeNv = 2,
RangeSizeNv = 3,
MaxEnumNv = 2147483647,
}
//VkAccelerationStructureTypeNV
public enum VkAccelerationStructureTypeNV : Int32
{
TopLevelNv = 0,
BottomLevelNv = 1,
BeginRangeNv = 0,
EndRangeNv = 1,
RangeSizeNv = 2,
MaxEnumNv = 2147483647,
}
//VkAttachmentLoadOp
public enum VkAttachmentLoadOp : Int32
{
Load = 0,
Clear = 1,
DontCare = 2,
BeginRange = 0,
EndRange = 2,
RangeSize = 3,
MaxEnum = 2147483647,
}
//VkAttachmentStoreOp
public enum VkAttachmentStoreOp : Int32
{
Store = 0,
DontCare = 1,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkBlendFactor
public enum VkBlendFactor : Int32
{
Zero = 0,
One = 1,
SrcColor = 2,
OneMinusSrcColor = 3,
DstColor = 4,
OneMinusDstColor = 5,
SrcAlpha = 6,
OneMinusSrcAlpha = 7,
DstAlpha = 8,
OneMinusDstAlpha = 9,
ConstantColor = 10,
OneMinusConstantColor = 11,
ConstantAlpha = 12,
OneMinusConstantAlpha = 13,
SrcAlphaSaturate = 14,
Src1Color = 15,
OneMinusSrc1Color = 16,
Src1Alpha = 17,
OneMinusSrc1Alpha = 18,
BeginRange = 0,
EndRange = 18,
RangeSize = 19,
MaxEnum = 2147483647,
}
//VkBlendOp
public enum VkBlendOp : Int32
{
Add = 0,
Subtract = 1,
ReverseSubtract = 2,
Min = 3,
Max = 4,
ZeroExt = 1000148000,
SrcExt = 1000148001,
DstExt = 1000148002,
SrcOverExt = 1000148003,
DstOverExt = 1000148004,
SrcInExt = 1000148005,
DstInExt = 1000148006,
SrcOutExt = 1000148007,
DstOutExt = 1000148008,
SrcAtopExt = 1000148009,
DstAtopExt = 1000148010,
XorExt = 1000148011,
MultiplyExt = 1000148012,
ScreenExt = 1000148013,
OverlayExt = 1000148014,
DarkenExt = 1000148015,
LightenExt = 1000148016,
ColordodgeExt = 1000148017,
ColorburnExt = 1000148018,
HardlightExt = 1000148019,
SoftlightExt = 1000148020,
DifferenceExt = 1000148021,
ExclusionExt = 1000148022,
InvertExt = 1000148023,
InvertRgbExt = 1000148024,
LineardodgeExt = 1000148025,
LinearburnExt = 1000148026,
VividlightExt = 1000148027,
LinearlightExt = 1000148028,
PinlightExt = 1000148029,
HardmixExt = 1000148030,
HslHueExt = 1000148031,
HslSaturationExt = 1000148032,
HslColorExt = 1000148033,
HslLuminosityExt = 1000148034,
PlusExt = 1000148035,
PlusClampedExt = 1000148036,
PlusClampedAlphaExt = 1000148037,
PlusDarkerExt = 1000148038,
MinusExt = 1000148039,
MinusClampedExt = 1000148040,
ContrastExt = 1000148041,
InvertOvgExt = 1000148042,
RedExt = 1000148043,
GreenExt = 1000148044,
BlueExt = 1000148045,
BeginRange = 0,
EndRange = 4,
RangeSize = 5,
MaxEnum = 2147483647,
}
//VkBorderColor
public enum VkBorderColor : Int32
{
FloatTransparentBlack = 0,
IntTransparentBlack = 1,
FloatOpaqueBlack = 2,
IntOpaqueBlack = 3,
FloatOpaqueWhite = 4,
IntOpaqueWhite = 5,
BeginRange = 0,
EndRange = 5,
RangeSize = 6,
MaxEnum = 2147483647,
}
//VkChromaLocation
public enum VkChromaLocation : Int32
{
CositedEven = 0,
Midpoint = 1,
CositedEvenKhr = 0,
MidpointKhr = 1,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkCoarseSampleOrderTypeNV
public enum VkCoarseSampleOrderTypeNV : Int32
{
DefaultNv = 0,
CustomNv = 1,
PixelMajorNv = 2,
SampleMajorNv = 3,
BeginRangeNv = 0,
EndRangeNv = 3,
RangeSizeNv = 4,
MaxEnumNv = 2147483647,
}
//VkColorSpaceKHR
public enum VkColorSpaceKHR : Int32
{
SpaceSrgbNonlinearKhr = 0,
SpaceDisplayP3NonlinearExt = 1000104001,
SpaceExtendedSrgbLinearExt = 1000104002,
SpaceDciP3LinearExt = 1000104003,
SpaceDciP3NonlinearExt = 1000104004,
SpaceBt709LinearExt = 1000104005,
SpaceBt709NonlinearExt = 1000104006,
SpaceBt2020LinearExt = 1000104007,
SpaceHdr10St2084Ext = 1000104008,
SpaceDolbyvisionExt = 1000104009,
SpaceHdr10HlgExt = 1000104010,
SpaceAdobergbLinearExt = 1000104011,
SpaceAdobergbNonlinearExt = 1000104012,
SpacePassThroughExt = 1000104013,
SpaceExtendedSrgbNonlinearExt = 1000104014,
SpaceBeginRangeKhr = 0,
SpaceEndRangeKhr = 0,
SpaceRangeSizeKhr = 1,
SpaceMaxEnumKhr = 2147483647,
}
//VkCommandBufferLevel
public enum VkCommandBufferLevel : Int32
{
Primary = 0,
Secondary = 1,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkCompareOp
public enum VkCompareOp : Int32
{
Never = 0,
Less = 1,
Equal = 2,
LessOrEqual = 3,
Greater = 4,
NotEqual = 5,
GreaterOrEqual = 6,
Always = 7,
BeginRange = 0,
EndRange = 7,
RangeSize = 8,
MaxEnum = 2147483647,
}
//VkComponentSwizzle
public enum VkComponentSwizzle : Int32
{
Identity = 0,
Zero = 1,
One = 2,
R = 3,
G = 4,
B = 5,
A = 6,
BeginRange = 0,
EndRange = 6,
RangeSize = 7,
MaxEnum = 2147483647,
}
//VkCompositeAlphaFlagBitsKHR
public enum VkCompositeAlphaFlagBitsKHR : Int32
{
OpaqueBitKhr = 1,
PreMultipliedBitKhr = 2,
PostMultipliedBitKhr = 4,
InheritBitKhr = 8,
FlagBitsMaxEnumKhr = 2147483647,
}
//VkCopyAccelerationStructureModeNV
public enum VkCopyAccelerationStructureModeNV : Int32
{
CloneNv = 0,
CompactNv = 1,
BeginRangeNv = 0,
EndRangeNv = 1,
RangeSizeNv = 2,
MaxEnumNv = 2147483647,
}
//VkDebugReportObjectTypeEXT
public enum VkDebugReportObjectTypeEXT : Int32
{
UnknownExt = 0,
InstanceExt = 1,
PhysicalDeviceExt = 2,
DeviceExt = 3,
QueueExt = 4,
SemaphoreExt = 5,
CommandBufferExt = 6,
FenceExt = 7,
DeviceMemoryExt = 8,
BufferExt = 9,
ImageExt = 10,
EventExt = 11,
QueryPoolExt = 12,
BufferViewExt = 13,
ImageViewExt = 14,
ShaderModuleExt = 15,
PipelineCacheExt = 16,
PipelineLayoutExt = 17,
RenderPassExt = 18,
PipelineExt = 19,
DescriptorSetLayoutExt = 20,
SamplerExt = 21,
DescriptorPoolExt = 22,
DescriptorSetExt = 23,
FramebufferExt = 24,
CommandPoolExt = 25,
SurfaceKhrExt = 26,
SwapchainKhrExt = 27,
DebugReportCallbackExtExt = 28,
DisplayKhrExt = 29,
DisplayModeKhrExt = 30,
ObjectTableNvxExt = 31,
IndirectCommandsLayoutNvxExt = 32,
ValidationCacheExtExt = 33,
SamplerYcbcrConversionExt = 1000156000,
DescriptorUpdateTemplateExt = 1000085000,
AccelerationStructureNvExt = 1000165000,
DebugReportExt = 28,
ValidationCacheExt = 33,
DescriptorUpdateTemplateKhrExt = 1000085000,
SamplerYcbcrConversionKhrExt = 1000156000,
BeginRangeExt = 0,
EndRangeExt = 33,
RangeSizeExt = 34,
MaxEnumExt = 2147483647,
}
//VkDebugUtilsMessageSeverityFlagBitsEXT
public enum VkDebugUtilsMessageSeverityFlagBitsEXT : Int32
{
VerboseBitExt = 1,
InfoBitExt = 16,
WarningBitExt = 256,
ErrorBitExt = 4096,
FlagBitsMaxEnumExt = 2147483647,
}
//VkDescriptorType
public enum VkDescriptorType : Int32
{
Sampler = 0,
CombinedImageSampler = 1,
SampledImage = 2,
StorageImage = 3,
UniformTexelBuffer = 4,
StorageTexelBuffer = 5,
UniformBuffer = 6,
StorageBuffer = 7,
UniformBufferDynamic = 8,
StorageBufferDynamic = 9,
InputAttachment = 10,
InlineUniformBlockExt = 1000138000,
AccelerationStructureNv = 1000165000,
BeginRange = 0,
EndRange = 10,
RangeSize = 11,
MaxEnum = 2147483647,
}
//VkDescriptorUpdateTemplateType
public enum VkDescriptorUpdateTemplateType : Int32
{
DescriptorSet = 0,
PushDescriptorsKhr = 1,
DescriptorSetKhr = 0,
BeginRange = 0,
EndRange = 0,
RangeSize = 1,
MaxEnum = 2147483647,
}
//VkDeviceEventTypeEXT
public enum VkDeviceEventTypeEXT : Int32
{
DisplayHotplugExt = 0,
BeginRangeExt = 0,
EndRangeExt = 0,
RangeSizeExt = 1,
MaxEnumExt = 2147483647,
}
//VkDisplayEventTypeEXT
public enum VkDisplayEventTypeEXT : Int32
{
FirstPixelOutExt = 0,
BeginRangeExt = 0,
EndRangeExt = 0,
RangeSizeExt = 1,
MaxEnumExt = 2147483647,
}
//VkDisplayPlaneAlphaFlagBitsKHR
public enum VkDisplayPlaneAlphaFlagBitsKHR : Int32
{
OpaqueBitKhr = 1,
GlobalBitKhr = 2,
PerPixelBitKhr = 4,
PerPixelPremultipliedBitKhr = 8,
FlagBitsMaxEnumKhr = 2147483647,
}
//VkDisplayPowerStateEXT
public enum VkDisplayPowerStateEXT : Int32
{
OffExt = 0,
SuspendExt = 1,
OnExt = 2,
BeginRangeExt = 0,
EndRangeExt = 2,
RangeSizeExt = 3,
MaxEnumExt = 2147483647,
}
//VkDynamicState
public enum VkDynamicState : Int32
{
Viewport = 0,
Scissor = 1,
LineWidth = 2,
DepthBias = 3,
BlendConstants = 4,
DepthBounds = 5,
StencilCompareMask = 6,
StencilWriteMask = 7,
StencilReference = 8,
ViewportWScalingNv = 1000087000,
DiscardRectangleExt = 1000099000,
SampleLocationsExt = 1000143000,
ViewportShadingRatePaletteNv = 1000164004,
ViewportCoarseSampleOrderNv = 1000164006,
ExclusiveScissorNv = 1000205001,
BeginRange = 0,
EndRange = 8,
RangeSize = 9,
MaxEnum = 2147483647,
}
//VkExternalFenceHandleTypeFlagBits
public enum VkExternalFenceHandleTypeFlagBits : Int32
{
OpaqueFdBit = 1,
OpaqueWin32Bit = 2,
OpaqueWin32KmtBit = 4,
SyncFdBit = 8,
OpaqueFdBitKhr = 1,
OpaqueWin32BitKhr = 2,
OpaqueWin32KmtBitKhr = 4,
SyncFdBitKhr = 8,
FlagBitsMaxEnum = 2147483647,
}
//VkExternalMemoryHandleTypeFlagBits
public enum VkExternalMemoryHandleTypeFlagBits : Int32
{
OpaqueFdBit = 1,
OpaqueWin32Bit = 2,
OpaqueWin32KmtBit = 4,
D3d11TextureBit = 8,
D3d11TextureKmtBit = 16,
D3d12HeapBit = 32,
D3d12ResourceBit = 64,
DmaBufBitExt = 512,
AndroidHardwareBufferBitAndroid = 1024,
HostAllocationBitExt = 128,
HostMappedForeignMemoryBitExt = 256,
OpaqueFdBitKhr = 1,
OpaqueWin32BitKhr = 2,
OpaqueWin32KmtBitKhr = 4,
D3d11TextureBitKhr = 8,
D3d11TextureKmtBitKhr = 16,
D3d12HeapBitKhr = 32,
D3d12ResourceBitKhr = 64,
FlagBitsMaxEnum = 2147483647,
}
//VkExternalSemaphoreHandleTypeFlagBits
public enum VkExternalSemaphoreHandleTypeFlagBits : Int32
{
OpaqueFdBit = 1,
OpaqueWin32Bit = 2,
OpaqueWin32KmtBit = 4,
D3d12FenceBit = 8,
SyncFdBit = 16,
OpaqueFdBitKhr = 1,
OpaqueWin32BitKhr = 2,
OpaqueWin32KmtBitKhr = 4,
D3d12FenceBitKhr = 8,
SyncFdBitKhr = 16,
FlagBitsMaxEnum = 2147483647,
}
//VkFilter
public enum VkFilter : Int32
{
Nearest = 0,
Linear = 1,
CubicImg = 1000015000,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkFormat
public enum VkFormat : Int32
{
Undefined = 0,
R4g4UnormPack8 = 1,
R4g4b4a4UnormPack16 = 2,
B4g4r4a4UnormPack16 = 3,
R5g6b5UnormPack16 = 4,
B5g6r5UnormPack16 = 5,
R5g5b5a1UnormPack16 = 6,
B5g5r5a1UnormPack16 = 7,
A1r5g5b5UnormPack16 = 8,
R8Unorm = 9,
R8Snorm = 10,
R8Uscaled = 11,
R8Sscaled = 12,
R8Uint = 13,
R8Sint = 14,
R8Srgb = 15,
R8g8Unorm = 16,
R8g8Snorm = 17,
R8g8Uscaled = 18,
R8g8Sscaled = 19,
R8g8Uint = 20,
R8g8Sint = 21,
R8g8Srgb = 22,
R8g8b8Unorm = 23,
R8g8b8Snorm = 24,
R8g8b8Uscaled = 25,
R8g8b8Sscaled = 26,
R8g8b8Uint = 27,
R8g8b8Sint = 28,
R8g8b8Srgb = 29,
B8g8r8Unorm = 30,
B8g8r8Snorm = 31,
B8g8r8Uscaled = 32,
B8g8r8Sscaled = 33,
B8g8r8Uint = 34,
B8g8r8Sint = 35,
B8g8r8Srgb = 36,
R8g8b8a8Unorm = 37,
R8g8b8a8Snorm = 38,
R8g8b8a8Uscaled = 39,
R8g8b8a8Sscaled = 40,
R8g8b8a8Uint = 41,
R8g8b8a8Sint = 42,
R8g8b8a8Srgb = 43,
B8g8r8a8Unorm = 44,
B8g8r8a8Snorm = 45,
B8g8r8a8Uscaled = 46,
B8g8r8a8Sscaled = 47,
B8g8r8a8Uint = 48,
B8g8r8a8Sint = 49,
B8g8r8a8Srgb = 50,
A8b8g8r8UnormPack32 = 51,
A8b8g8r8SnormPack32 = 52,
A8b8g8r8UscaledPack32 = 53,
A8b8g8r8SscaledPack32 = 54,
A8b8g8r8UintPack32 = 55,
A8b8g8r8SintPack32 = 56,
A8b8g8r8SrgbPack32 = 57,
A2r10g10b10UnormPack32 = 58,
A2r10g10b10SnormPack32 = 59,
A2r10g10b10UscaledPack32 = 60,
A2r10g10b10SscaledPack32 = 61,
A2r10g10b10UintPack32 = 62,
A2r10g10b10SintPack32 = 63,
A2b10g10r10UnormPack32 = 64,
A2b10g10r10SnormPack32 = 65,
A2b10g10r10UscaledPack32 = 66,
A2b10g10r10SscaledPack32 = 67,
A2b10g10r10UintPack32 = 68,
A2b10g10r10SintPack32 = 69,
R16Unorm = 70,
R16Snorm = 71,
R16Uscaled = 72,
R16Sscaled = 73,
R16Uint = 74,
R16Sint = 75,
R16Sfloat = 76,
R16g16Unorm = 77,
R16g16Snorm = 78,
R16g16Uscaled = 79,
R16g16Sscaled = 80,
R16g16Uint = 81,
R16g16Sint = 82,
R16g16Sfloat = 83,
R16g16b16Unorm = 84,
R16g16b16Snorm = 85,
R16g16b16Uscaled = 86,
R16g16b16Sscaled = 87,
R16g16b16Uint = 88,
R16g16b16Sint = 89,
R16g16b16Sfloat = 90,
R16g16b16a16Unorm = 91,
R16g16b16a16Snorm = 92,
R16g16b16a16Uscaled = 93,
R16g16b16a16Sscaled = 94,
R16g16b16a16Uint = 95,
R16g16b16a16Sint = 96,
R16g16b16a16Sfloat = 97,
R32Uint = 98,
R32Sint = 99,
R32Sfloat = 100,
R32g32Uint = 101,
R32g32Sint = 102,
R32g32Sfloat = 103,
R32g32b32Uint = 104,
R32g32b32Sint = 105,
R32g32b32Sfloat = 106,
R32g32b32a32Uint = 107,
R32g32b32a32Sint = 108,
R32g32b32a32Sfloat = 109,
R64Uint = 110,
R64Sint = 111,
R64Sfloat = 112,
R64g64Uint = 113,
R64g64Sint = 114,
R64g64Sfloat = 115,
R64g64b64Uint = 116,
R64g64b64Sint = 117,
R64g64b64Sfloat = 118,
R64g64b64a64Uint = 119,
R64g64b64a64Sint = 120,
R64g64b64a64Sfloat = 121,
B10g11r11UfloatPack32 = 122,
E5b9g9r9UfloatPack32 = 123,
D16Unorm = 124,
X8D24UnormPack32 = 125,
D32Sfloat = 126,
S8Uint = 127,
D16UnormS8Uint = 128,
D24UnormS8Uint = 129,
D32SfloatS8Uint = 130,
Bc1RgbUnormBlock = 131,
Bc1RgbSrgbBlock = 132,
Bc1RgbaUnormBlock = 133,
Bc1RgbaSrgbBlock = 134,
Bc2UnormBlock = 135,
Bc2SrgbBlock = 136,
Bc3UnormBlock = 137,
Bc3SrgbBlock = 138,
Bc4UnormBlock = 139,
Bc4SnormBlock = 140,
Bc5UnormBlock = 141,
Bc5SnormBlock = 142,
Bc6hUfloatBlock = 143,
Bc6hSfloatBlock = 144,
Bc7UnormBlock = 145,
Bc7SrgbBlock = 146,
Etc2R8g8b8UnormBlock = 147,
Etc2R8g8b8SrgbBlock = 148,
Etc2R8g8b8a1UnormBlock = 149,
Etc2R8g8b8a1SrgbBlock = 150,
Etc2R8g8b8a8UnormBlock = 151,
Etc2R8g8b8a8SrgbBlock = 152,
EacR11UnormBlock = 153,
EacR11SnormBlock = 154,
EacR11g11UnormBlock = 155,
EacR11g11SnormBlock = 156,
Astc4x4UnormBlock = 157,
Astc4x4SrgbBlock = 158,
Astc5x4UnormBlock = 159,
Astc5x4SrgbBlock = 160,
Astc5x5UnormBlock = 161,
Astc5x5SrgbBlock = 162,
Astc6x5UnormBlock = 163,
Astc6x5SrgbBlock = 164,
Astc6x6UnormBlock = 165,
Astc6x6SrgbBlock = 166,
Astc8x5UnormBlock = 167,
Astc8x5SrgbBlock = 168,
Astc8x6UnormBlock = 169,
Astc8x6SrgbBlock = 170,
Astc8x8UnormBlock = 171,
Astc8x8SrgbBlock = 172,
Astc10x5UnormBlock = 173,
Astc10x5SrgbBlock = 174,
Astc10x6UnormBlock = 175,
Astc10x6SrgbBlock = 176,
Astc10x8UnormBlock = 177,
Astc10x8SrgbBlock = 178,
Astc10x10UnormBlock = 179,
Astc10x10SrgbBlock = 180,
Astc12x10UnormBlock = 181,
Astc12x10SrgbBlock = 182,
Astc12x12UnormBlock = 183,
Astc12x12SrgbBlock = 184,
G8b8g8r8422Unorm = 1000156000,
B8g8r8g8422Unorm = 1000156001,
G8B8R83plane420Unorm = 1000156002,
G8B8r82plane420Unorm = 1000156003,
G8B8R83plane422Unorm = 1000156004,
G8B8r82plane422Unorm = 1000156005,
G8B8R83plane444Unorm = 1000156006,
R10x6UnormPack16 = 1000156007,
R10x6g10x6Unorm2pack16 = 1000156008,
R10x6g10x6b10x6a10x6Unorm4pack16 = 1000156009,
G10x6b10x6g10x6r10x6422Unorm4pack16 = 1000156010,
B10x6g10x6r10x6g10x6422Unorm4pack16 = 1000156011,
G10x6B10x6R10x63plane420Unorm3pack16 = 1000156012,
G10x6B10x6r10x62plane420Unorm3pack16 = 1000156013,
G10x6B10x6R10x63plane422Unorm3pack16 = 1000156014,
G10x6B10x6r10x62plane422Unorm3pack16 = 1000156015,
G10x6B10x6R10x63plane444Unorm3pack16 = 1000156016,
R12x4UnormPack16 = 1000156017,
R12x4g12x4Unorm2pack16 = 1000156018,
R12x4g12x4b12x4a12x4Unorm4pack16 = 1000156019,
G12x4b12x4g12x4r12x4422Unorm4pack16 = 1000156020,
B12x4g12x4r12x4g12x4422Unorm4pack16 = 1000156021,
G12x4B12x4R12x43plane420Unorm3pack16 = 1000156022,
G12x4B12x4r12x42plane420Unorm3pack16 = 1000156023,
G12x4B12x4R12x43plane422Unorm3pack16 = 1000156024,
G12x4B12x4r12x42plane422Unorm3pack16 = 1000156025,
G12x4B12x4R12x43plane444Unorm3pack16 = 1000156026,
G16b16g16r16422Unorm = 1000156027,
B16g16r16g16422Unorm = 1000156028,
G16B16R163plane420Unorm = 1000156029,
G16B16r162plane420Unorm = 1000156030,
G16B16R163plane422Unorm = 1000156031,
G16B16r162plane422Unorm = 1000156032,
G16B16R163plane444Unorm = 1000156033,
Pvrtc12bppUnormBlockImg = 1000054000,
Pvrtc14bppUnormBlockImg = 1000054001,
Pvrtc22bppUnormBlockImg = 1000054002,
Pvrtc24bppUnormBlockImg = 1000054003,
Pvrtc12bppSrgbBlockImg = 1000054004,
Pvrtc14bppSrgbBlockImg = 1000054005,
Pvrtc22bppSrgbBlockImg = 1000054006,
Pvrtc24bppSrgbBlockImg = 1000054007,
G8b8g8r8422UnormKhr = 1000156000,
B8g8r8g8422UnormKhr = 1000156001,
G8B8R83plane420UnormKhr = 1000156002,
G8B8r82plane420UnormKhr = 1000156003,
G8B8R83plane422UnormKhr = 1000156004,
G8B8r82plane422UnormKhr = 1000156005,
G8B8R83plane444UnormKhr = 1000156006,
R10x6UnormPack16Khr = 1000156007,
R10x6g10x6Unorm2pack16Khr = 1000156008,
R10x6g10x6b10x6a10x6Unorm4pack16Khr = 1000156009,
G10x6b10x6g10x6r10x6422Unorm4pack16Khr = 1000156010,
B10x6g10x6r10x6g10x6422Unorm4pack16Khr = 1000156011,
G10x6B10x6R10x63plane420Unorm3pack16Khr = 1000156012,
G10x6B10x6r10x62plane420Unorm3pack16Khr = 1000156013,
G10x6B10x6R10x63plane422Unorm3pack16Khr = 1000156014,
G10x6B10x6r10x62plane422Unorm3pack16Khr = 1000156015,
G10x6B10x6R10x63plane444Unorm3pack16Khr = 1000156016,
R12x4UnormPack16Khr = 1000156017,
R12x4g12x4Unorm2pack16Khr = 1000156018,
R12x4g12x4b12x4a12x4Unorm4pack16Khr = 1000156019,
G12x4b12x4g12x4r12x4422Unorm4pack16Khr = 1000156020,
B12x4g12x4r12x4g12x4422Unorm4pack16Khr = 1000156021,
G12x4B12x4R12x43plane420Unorm3pack16Khr = 1000156022,
G12x4B12x4r12x42plane420Unorm3pack16Khr = 1000156023,
G12x4B12x4R12x43plane422Unorm3pack16Khr = 1000156024,
G12x4B12x4r12x42plane422Unorm3pack16Khr = 1000156025,
G12x4B12x4R12x43plane444Unorm3pack16Khr = 1000156026,
G16b16g16r16422UnormKhr = 1000156027,
B16g16r16g16422UnormKhr = 1000156028,
G16B16R163plane420UnormKhr = 1000156029,
G16B16r162plane420UnormKhr = 1000156030,
G16B16R163plane422UnormKhr = 1000156031,
G16B16r162plane422UnormKhr = 1000156032,
G16B16R163plane444UnormKhr = 1000156033,
BeginRange = 0,
EndRange = 184,
RangeSize = 185,
MaxEnum = 2147483647,
}
//VkFrontFace
public enum VkFrontFace : Int32
{
CounterClockwise = 0,
Clockwise = 1,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkGeometryTypeNV
public enum VkGeometryTypeNV : Int32
{
TrianglesNv = 0,
AabbsNv = 1,
BeginRangeNv = 0,
EndRangeNv = 1,
RangeSizeNv = 2,
MaxEnumNv = 2147483647,
}
//VkImageLayout
public enum VkImageLayout : Int32
{
Undefined = 0,
General = 1,
ColorAttachmentOptimal = 2,
DepthStencilAttachmentOptimal = 3,
DepthStencilReadOnlyOptimal = 4,
ShaderReadOnlyOptimal = 5,
TransferSrcOptimal = 6,
TransferDstOptimal = 7,
Preinitialized = 8,
DepthReadOnlyStencilAttachmentOptimal = 1000117000,
DepthAttachmentStencilReadOnlyOptimal = 1000117001,
PresentSrcKhr = 1000001002,
SharedPresentKhr = 1000111000,
ShadingRateOptimalNv = 1000164003,
FragmentDensityMapOptimalExt = 1000218000,
DepthReadOnlyStencilAttachmentOptimalKhr = 1000117000,
DepthAttachmentStencilReadOnlyOptimalKhr = 1000117001,
BeginRange = 0,
EndRange = 8,
RangeSize = 9,
MaxEnum = 2147483647,
}
//VkImageTiling
public enum VkImageTiling : Int32
{
Optimal = 0,
Linear = 1,
DrmFormatModifierExt = 1000158000,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkImageType
public enum VkImageType : Int32
{
_1d = 0,
_2d = 1,
_3d = 2,
BeginRange = 0,
EndRange = 2,
RangeSize = 3,
MaxEnum = 2147483647,
}
//VkImageViewType
public enum VkImageViewType : Int32
{
_1d = 0,
_2d = 1,
_3d = 2,
Cube = 3,
_1dArray = 4,
_2dArray = 5,
CubeArray = 6,
BeginRange = 0,
EndRange = 6,
RangeSize = 7,
MaxEnum = 2147483647,
}
//VkIndexType
public enum VkIndexType : Int32
{
Uint16 = 0,
Uint32 = 1,
NoneNv = 1000165000,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkIndirectCommandsTokenTypeNVX
public enum VkIndirectCommandsTokenTypeNVX : Int32
{
PipelineNvx = 0,
DescriptorSetNvx = 1,
IndexBufferNvx = 2,
VertexBufferNvx = 3,
PushConstantNvx = 4,
DrawIndexedNvx = 5,
DrawNvx = 6,
DispatchNvx = 7,
BeginRangeNvx = 0,
EndRangeNvx = 7,
RangeSizeNvx = 8,
MaxEnumNvx = 2147483647,
}
//VkInternalAllocationType
public enum VkInternalAllocationType : Int32
{
Executable = 0,
BeginRange = 0,
EndRange = 0,
RangeSize = 1,
MaxEnum = 2147483647,
}
//VkLogicOp
public enum VkLogicOp : Int32
{
Clear = 0,
And = 1,
AndReverse = 2,
Copy = 3,
AndInverted = 4,
NoOp = 5,
Xor = 6,
Or = 7,
Nor = 8,
Equivalent = 9,
Invert = 10,
OrReverse = 11,
CopyInverted = 12,
OrInverted = 13,
Nand = 14,
Set = 15,
BeginRange = 0,
EndRange = 15,
RangeSize = 16,
MaxEnum = 2147483647,
}
//VkObjectEntryTypeNVX
public enum VkObjectEntryTypeNVX : Int32
{
DescriptorSetNvx = 0,
PipelineNvx = 1,
IndexBufferNvx = 2,
VertexBufferNvx = 3,
PushConstantNvx = 4,
BeginRangeNvx = 0,
EndRangeNvx = 4,
RangeSizeNvx = 5,
MaxEnumNvx = 2147483647,
}
//VkObjectType
public enum VkObjectType : Int32
{
Unknown = 0,
Instance = 1,
PhysicalDevice = 2,
Device = 3,
Queue = 4,
Semaphore = 5,
CommandBuffer = 6,
Fence = 7,
DeviceMemory = 8,
Buffer = 9,
Image = 10,
Event = 11,
QueryPool = 12,
BufferView = 13,
ImageView = 14,
ShaderModule = 15,
PipelineCache = 16,
PipelineLayout = 17,
RenderPass = 18,
Pipeline = 19,
DescriptorSetLayout = 20,
Sampler = 21,
DescriptorPool = 22,
DescriptorSet = 23,
Framebuffer = 24,
CommandPool = 25,
SamplerYcbcrConversion = 1000156000,
DescriptorUpdateTemplate = 1000085000,
SurfaceKhr = 1000000000,
SwapchainKhr = 1000001000,
DisplayKhr = 1000002000,
DisplayModeKhr = 1000002001,
DebugReportCallbackExt = 1000011000,
ObjectTableNvx = 1000086000,
IndirectCommandsLayoutNvx = 1000086001,
DebugUtilsMessengerExt = 1000128000,
ValidationCacheExt = 1000160000,
AccelerationStructureNv = 1000165000,
DescriptorUpdateTemplateKhr = 1000085000,
SamplerYcbcrConversionKhr = 1000156000,
BeginRange = 0,
EndRange = 25,
RangeSize = 26,
MaxEnum = 2147483647,
}
//VkPhysicalDeviceType
public enum VkPhysicalDeviceType : Int32
{
Other = 0,
IntegratedGpu = 1,
DiscreteGpu = 2,
VirtualGpu = 3,
Cpu = 4,
BeginRange = 0,
EndRange = 4,
RangeSize = 5,
MaxEnum = 2147483647,
}
//VkPipelineBindPoint
public enum VkPipelineBindPoint : Int32
{
Graphics = 0,
Compute = 1,
RayTracingNv = 1000165000,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkPipelineStageFlagBits
public enum VkPipelineStageFlagBits : Int32
{
TopOfPipeBit = 1,
DrawIndirectBit = 2,
VertexInputBit = 4,
VertexShaderBit = 8,
TessellationControlShaderBit = 16,
TessellationEvaluationShaderBit = 32,
GeometryShaderBit = 64,
FragmentShaderBit = 128,
EarlyFragmentTestsBit = 256,
LateFragmentTestsBit = 512,
ColorAttachmentOutputBit = 1024,
ComputeShaderBit = 2048,
TransferBit = 4096,
BottomOfPipeBit = 8192,
HostBit = 16384,
AllGraphicsBit = 32768,
AllCommandsBit = 65536,
TransformFeedbackBitExt = 16777216,
ConditionalRenderingBitExt = 262144,
CommandProcessBitNvx = 131072,
ShadingRateImageBitNv = 4194304,
RayTracingShaderBitNv = 2097152,
AccelerationStructureBuildBitNv = 33554432,
TaskShaderBitNv = 524288,
MeshShaderBitNv = 1048576,
FragmentDensityProcessBitExt = 8388608,
FlagBitsMaxEnum = 2147483647,
}
//VkPolygonMode
public enum VkPolygonMode : Int32
{
Fill = 0,
Line = 1,
Point = 2,
FillRectangleNv = 1000153000,
BeginRange = 0,
EndRange = 2,
RangeSize = 3,
MaxEnum = 2147483647,
}
//VkPresentModeKHR
public enum VkPresentModeKHR : Int32
{
ImmediateKhr = 0,
MailboxKhr = 1,
FifoKhr = 2,
FifoRelaxedKhr = 3,
SharedDemandRefreshKhr = 1000111000,
SharedContinuousRefreshKhr = 1000111001,
BeginRangeKhr = 0,
EndRangeKhr = 3,
RangeSizeKhr = 4,
MaxEnumKhr = 2147483647,
}
//VkPrimitiveTopology
public enum VkPrimitiveTopology : Int32
{
PointList = 0,
LineList = 1,
LineStrip = 2,
TriangleList = 3,
TriangleStrip = 4,
TriangleFan = 5,
LineListWithAdjacency = 6,
LineStripWithAdjacency = 7,
TriangleListWithAdjacency = 8,
TriangleStripWithAdjacency = 9,
PatchList = 10,
BeginRange = 0,
EndRange = 10,
RangeSize = 11,
MaxEnum = 2147483647,
}
//VkQueryType
public enum VkQueryType : Int32
{
Occlusion = 0,
PipelineStatistics = 1,
Timestamp = 2,
TransformFeedbackStreamExt = 1000028004,
AccelerationStructureCompactedSizeNv = 1000165000,
BeginRange = 0,
EndRange = 2,
RangeSize = 3,
MaxEnum = 2147483647,
}
//VkRayTracingShaderGroupTypeNV
public enum VkRayTracingShaderGroupTypeNV : Int32
{
GeneralNv = 0,
TrianglesHitGroupNv = 1,
ProceduralHitGroupNv = 2,
BeginRangeNv = 0,
EndRangeNv = 2,
RangeSizeNv = 3,
MaxEnumNv = 2147483647,
}
//VkResult
public enum VkResult : Int32
{
Success = 0,
NotReady = 1,
Timeout = 2,
EventSet = 3,
EventReset = 4,
Incomplete = 5,
ErrorOutOfHostMemory = -1,
ErrorOutOfDeviceMemory = -2,
ErrorInitializationFailed = -3,
ErrorDeviceLost = -4,
ErrorMemoryMapFailed = -5,
ErrorLayerNotPresent = -6,
ErrorExtensionNotPresent = -7,
ErrorFeatureNotPresent = -8,
ErrorIncompatibleDriver = -9,
ErrorTooManyObjects = -10,
ErrorFormatNotSupported = -11,
ErrorFragmentedPool = -12,
ErrorOutOfPoolMemory = -1000069000,
ErrorInvalidExternalHandle = -1000072003,
ErrorSurfaceLostKhr = -1000000000,
ErrorNativeWindowInUseKhr = -1000000001,
SuboptimalKhr = 1000001003,
ErrorOutOfDateKhr = -1000001004,
ErrorIncompatibleDisplayKhr = -1000003001,
ErrorValidationFailedExt = -1000011001,
ErrorInvalidShaderNv = -1000012000,
ErrorInvalidDrmFormatModifierPlaneLayoutExt = -1000158000,
ErrorFragmentationExt = -1000161000,
ErrorNotPermittedExt = -1000174001,
ErrorInvalidDeviceAddressExt = -1000244000,
ErrorOutOfPoolMemoryKhr = -1000069000,
ErrorInvalidExternalHandleKhr = -1000072003,
ResultBeginRange = -12,
ResultEndRange = 5,
ResultRangeSize = 18,
ResultMaxEnum = 2147483647,
}
//VkSampleCountFlagBits
public enum VkSampleCountFlagBits : Int32
{
_1Bit = 1,
_2Bit = 2,
_4Bit = 4,
_8Bit = 8,
_16Bit = 16,
_32Bit = 32,
_64Bit = 64,
FlagBitsMaxEnum = 2147483647,
}
//VkSamplerAddressMode
public enum VkSamplerAddressMode : Int32
{
Repeat = 0,
MirroredRepeat = 1,
ClampToEdge = 2,
ClampToBorder = 3,
MirrorClampToEdge = 4,
BeginRange = 0,
EndRange = 3,
RangeSize = 4,
MaxEnum = 2147483647,
}
//VkSamplerMipmapMode
public enum VkSamplerMipmapMode : Int32
{
Nearest = 0,
Linear = 1,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkSamplerYcbcrModelConversion
public enum VkSamplerYcbcrModelConversion : Int32
{
RgbIdentity = 0,
YcbcrIdentity = 1,
Ycbcr709 = 2,
Ycbcr601 = 3,
Ycbcr2020 = 4,
RgbIdentityKhr = 0,
YcbcrIdentityKhr = 1,
Ycbcr709Khr = 2,
Ycbcr601Khr = 3,
Ycbcr2020Khr = 4,
BeginRange = 0,
EndRange = 4,
RangeSize = 5,
MaxEnum = 2147483647,
}
//VkSamplerYcbcrRange
public enum VkSamplerYcbcrRange : Int32
{
ItuFull = 0,
ItuNarrow = 1,
ItuFullKhr = 0,
ItuNarrowKhr = 1,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkShaderInfoTypeAMD
public enum VkShaderInfoTypeAMD : Int32
{
StatisticsAmd = 0,
BinaryAmd = 1,
DisassemblyAmd = 2,
BeginRangeAmd = 0,
EndRangeAmd = 2,
RangeSizeAmd = 3,
MaxEnumAmd = 2147483647,
}
//VkShaderStageFlagBits
public enum VkShaderStageFlagBits : Int32
{
VertexBit = 1,
TessellationControlBit = 2,
TessellationEvaluationBit = 4,
GeometryBit = 8,
FragmentBit = 16,
ComputeBit = 32,
AllGraphics = 31,
All = 2147483647,
RaygenBitNv = 256,
AnyHitBitNv = 512,
ClosestHitBitNv = 1024,
MissBitNv = 2048,
IntersectionBitNv = 4096,
CallableBitNv = 8192,
TaskBitNv = 64,
MeshBitNv = 128,
FlagBitsMaxEnum = 2147483647,
}
//VkShadingRatePaletteEntryNV
public enum VkShadingRatePaletteEntryNV : Int32
{
NoInvocationsNv = 0,
_16InvocationsPerPixelNv = 1,
_8InvocationsPerPixelNv = 2,
_4InvocationsPerPixelNv = 3,
_2InvocationsPerPixelNv = 4,
_1InvocationPerPixelNv = 5,
_1InvocationPer2x1PixelsNv = 6,
_1InvocationPer1x2PixelsNv = 7,
_1InvocationPer2x2PixelsNv = 8,
_1InvocationPer4x2PixelsNv = 9,
_1InvocationPer2x4PixelsNv = 10,
_1InvocationPer4x4PixelsNv = 11,
BeginRangeNv = 0,
EndRangeNv = 11,
RangeSizeNv = 12,
MaxEnumNv = 2147483647,
}
//VkSharingMode
public enum VkSharingMode : Int32
{
Exclusive = 0,
Concurrent = 1,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkStencilOp
public enum VkStencilOp : Int32
{
Keep = 0,
Zero = 1,
Replace = 2,
IncrementAndClamp = 3,
DecrementAndClamp = 4,
Invert = 5,
IncrementAndWrap = 6,
DecrementAndWrap = 7,
BeginRange = 0,
EndRange = 7,
RangeSize = 8,
MaxEnum = 2147483647,
}
//VkStructureType
public enum VkStructureType : Int32
{
ApplicationInfo = 0,
InstanceCreateInfo = 1,
DeviceQueueCreateInfo = 2,
DeviceCreateInfo = 3,
SubmitInfo = 4,
MemoryAllocateInfo = 5,
MappedMemoryRange = 6,
BindSparseInfo = 7,
FenceCreateInfo = 8,
SemaphoreCreateInfo = 9,
EventCreateInfo = 10,
QueryPoolCreateInfo = 11,
BufferCreateInfo = 12,
BufferViewCreateInfo = 13,
ImageCreateInfo = 14,
ImageViewCreateInfo = 15,
ShaderModuleCreateInfo = 16,
PipelineCacheCreateInfo = 17,
PipelineShaderStageCreateInfo = 18,
PipelineVertexInputStateCreateInfo = 19,
PipelineInputAssemblyStateCreateInfo = 20,
PipelineTessellationStateCreateInfo = 21,
PipelineViewportStateCreateInfo = 22,
PipelineRasterizationStateCreateInfo = 23,
PipelineMultisampleStateCreateInfo = 24,
PipelineDepthStencilStateCreateInfo = 25,
PipelineColorBlendStateCreateInfo = 26,
PipelineDynamicStateCreateInfo = 27,
GraphicsPipelineCreateInfo = 28,
ComputePipelineCreateInfo = 29,
PipelineLayoutCreateInfo = 30,
SamplerCreateInfo = 31,
DescriptorSetLayoutCreateInfo = 32,
DescriptorPoolCreateInfo = 33,
DescriptorSetAllocateInfo = 34,
WriteDescriptorSet = 35,
CopyDescriptorSet = 36,
FramebufferCreateInfo = 37,
RenderPassCreateInfo = 38,
CommandPoolCreateInfo = 39,
CommandBufferAllocateInfo = 40,
CommandBufferInheritanceInfo = 41,
CommandBufferBeginInfo = 42,
RenderPassBeginInfo = 43,
BufferMemoryBarrier = 44,
ImageMemoryBarrier = 45,
MemoryBarrier = 46,
LoaderInstanceCreateInfo = 47,
LoaderDeviceCreateInfo = 48,
PhysicalDeviceSubgroupProperties = 1000094000,
BindBufferMemoryInfo = 1000157000,
BindImageMemoryInfo = 1000157001,
PhysicalDevice16bitStorageFeatures = 1000083000,
MemoryDedicatedRequirements = 1000127000,
MemoryDedicatedAllocateInfo = 1000127001,
MemoryAllocateFlagsInfo = 1000060000,
DeviceGroupRenderPassBeginInfo = 1000060003,
DeviceGroupCommandBufferBeginInfo = 1000060004,
DeviceGroupSubmitInfo = 1000060005,
DeviceGroupBindSparseInfo = 1000060006,
BindBufferMemoryDeviceGroupInfo = 1000060013,
BindImageMemoryDeviceGroupInfo = 1000060014,
PhysicalDeviceGroupProperties = 1000070000,
DeviceGroupDeviceCreateInfo = 1000070001,
BufferMemoryRequirementsInfo2 = 1000146000,
ImageMemoryRequirementsInfo2 = 1000146001,
ImageSparseMemoryRequirementsInfo2 = 1000146002,
MemoryRequirements2 = 1000146003,
SparseImageMemoryRequirements2 = 1000146004,
PhysicalDeviceFeatures2 = 1000059000,
PhysicalDeviceProperties2 = 1000059001,
FormatProperties2 = 1000059002,
ImageFormatProperties2 = 1000059003,
PhysicalDeviceImageFormatInfo2 = 1000059004,
QueueFamilyProperties2 = 1000059005,
PhysicalDeviceMemoryProperties2 = 1000059006,
SparseImageFormatProperties2 = 1000059007,
PhysicalDeviceSparseImageFormatInfo2 = 1000059008,
PhysicalDevicePointClippingProperties = 1000117000,
RenderPassInputAttachmentAspectCreateInfo = 1000117001,
ImageViewUsageCreateInfo = 1000117002,
PipelineTessellationDomainOriginStateCreateInfo = 1000117003,
RenderPassMultiviewCreateInfo = 1000053000,
PhysicalDeviceMultiviewFeatures = 1000053001,
PhysicalDeviceMultiviewProperties = 1000053002,
PhysicalDeviceVariablePointerFeatures = 1000120000,
ProtectedSubmitInfo = 1000145000,
PhysicalDeviceProtectedMemoryFeatures = 1000145001,
PhysicalDeviceProtectedMemoryProperties = 1000145002,
DeviceQueueInfo2 = 1000145003,
SamplerYcbcrConversionCreateInfo = 1000156000,
SamplerYcbcrConversionInfo = 1000156001,
BindImagePlaneMemoryInfo = 1000156002,
ImagePlaneMemoryRequirementsInfo = 1000156003,
PhysicalDeviceSamplerYcbcrConversionFeatures = 1000156004,
SamplerYcbcrConversionImageFormatProperties = 1000156005,
DescriptorUpdateTemplateCreateInfo = 1000085000,
PhysicalDeviceExternalImageFormatInfo = 1000071000,
ExternalImageFormatProperties = 1000071001,
PhysicalDeviceExternalBufferInfo = 1000071002,
ExternalBufferProperties = 1000071003,
PhysicalDeviceIdProperties = 1000071004,
ExternalMemoryBufferCreateInfo = 1000072000,
ExternalMemoryImageCreateInfo = 1000072001,
ExportMemoryAllocateInfo = 1000072002,
PhysicalDeviceExternalFenceInfo = 1000112000,
ExternalFenceProperties = 1000112001,
ExportFenceCreateInfo = 1000113000,
ExportSemaphoreCreateInfo = 1000077000,
PhysicalDeviceExternalSemaphoreInfo = 1000076000,
ExternalSemaphoreProperties = 1000076001,
PhysicalDeviceMaintenance3Properties = 1000168000,
DescriptorSetLayoutSupport = 1000168001,
PhysicalDeviceShaderDrawParameterFeatures = 1000063000,
SwapchainCreateInfoKhr = 1000001000,
PresentInfoKhr = 1000001001,
DeviceGroupPresentCapabilitiesKhr = 1000060007,
ImageSwapchainCreateInfoKhr = 1000060008,
BindImageMemorySwapchainInfoKhr = 1000060009,
AcquireNextImageInfoKhr = 1000060010,
DeviceGroupPresentInfoKhr = 1000060011,
DeviceGroupSwapchainCreateInfoKhr = 1000060012,
DisplayModeCreateInfoKhr = 1000002000,
DisplaySurfaceCreateInfoKhr = 1000002001,
DisplayPresentInfoKhr = 1000003000,
XlibSurfaceCreateInfoKhr = 1000004000,
XcbSurfaceCreateInfoKhr = 1000005000,
WaylandSurfaceCreateInfoKhr = 1000006000,
AndroidSurfaceCreateInfoKhr = 1000008000,
Win32SurfaceCreateInfoKhr = 1000009000,
DebugReportCallbackCreateInfoExt = 1000011000,
PipelineRasterizationStateRasterizationOrderAmd = 1000018000,
DebugMarkerObjectNameInfoExt = 1000022000,
DebugMarkerObjectTagInfoExt = 1000022001,
DebugMarkerMarkerInfoExt = 1000022002,
DedicatedAllocationImageCreateInfoNv = 1000026000,
DedicatedAllocationBufferCreateInfoNv = 1000026001,
DedicatedAllocationMemoryAllocateInfoNv = 1000026002,
PhysicalDeviceTransformFeedbackFeaturesExt = 1000028000,
PhysicalDeviceTransformFeedbackPropertiesExt = 1000028001,
PipelineRasterizationStateStreamCreateInfoExt = 1000028002,
TextureLodGatherFormatPropertiesAmd = 1000041000,
PhysicalDeviceCornerSampledImageFeaturesNv = 1000050000,
ExternalMemoryImageCreateInfoNv = 1000056000,
ExportMemoryAllocateInfoNv = 1000056001,
ImportMemoryWin32HandleInfoNv = 1000057000,
ExportMemoryWin32HandleInfoNv = 1000057001,
Win32KeyedMutexAcquireReleaseInfoNv = 1000058000,
ValidationFlagsExt = 1000061000,
ViSurfaceCreateInfoNn = 1000062000,
ImageViewAstcDecodeModeExt = 1000067000,
PhysicalDeviceAstcDecodeFeaturesExt = 1000067001,
ImportMemoryWin32HandleInfoKhr = 1000073000,
ExportMemoryWin32HandleInfoKhr = 1000073001,
MemoryWin32HandlePropertiesKhr = 1000073002,
MemoryGetWin32HandleInfoKhr = 1000073003,
ImportMemoryFdInfoKhr = 1000074000,
MemoryFdPropertiesKhr = 1000074001,
MemoryGetFdInfoKhr = 1000074002,
Win32KeyedMutexAcquireReleaseInfoKhr = 1000075000,
ImportSemaphoreWin32HandleInfoKhr = 1000078000,
ExportSemaphoreWin32HandleInfoKhr = 1000078001,
D3d12FenceSubmitInfoKhr = 1000078002,
SemaphoreGetWin32HandleInfoKhr = 1000078003,
ImportSemaphoreFdInfoKhr = 1000079000,
SemaphoreGetFdInfoKhr = 1000079001,
PhysicalDevicePushDescriptorPropertiesKhr = 1000080000,
CommandBufferInheritanceConditionalRenderingInfoExt = 1000081000,
PhysicalDeviceConditionalRenderingFeaturesExt = 1000081001,
ConditionalRenderingBeginInfoExt = 1000081002,
PhysicalDeviceFloat16Int8FeaturesKhr = 1000082000,
PresentRegionsKhr = 1000084000,
ObjectTableCreateInfoNvx = 1000086000,
IndirectCommandsLayoutCreateInfoNvx = 1000086001,
CmdProcessCommandsInfoNvx = 1000086002,
CmdReserveSpaceForCommandsInfoNvx = 1000086003,
DeviceGeneratedCommandsLimitsNvx = 1000086004,
DeviceGeneratedCommandsFeaturesNvx = 1000086005,
PipelineViewportWScalingStateCreateInfoNv = 1000087000,
SurfaceCapabilities2Ext = 1000090000,
DisplayPowerInfoExt = 1000091000,
DeviceEventInfoExt = 1000091001,
DisplayEventInfoExt = 1000091002,
SwapchainCounterCreateInfoExt = 1000091003,
PresentTimesInfoGoogle = 1000092000,
PhysicalDeviceMultiviewPerViewAttributesPropertiesNvx = 1000097000,
PipelineViewportSwizzleStateCreateInfoNv = 1000098000,
PhysicalDeviceDiscardRectanglePropertiesExt = 1000099000,
PipelineDiscardRectangleStateCreateInfoExt = 1000099001,
PhysicalDeviceConservativeRasterizationPropertiesExt = 1000101000,
PipelineRasterizationConservativeStateCreateInfoExt = 1000101001,
HdrMetadataExt = 1000105000,
AttachmentDescription2Khr = 1000109000,
AttachmentReference2Khr = 1000109001,
SubpassDescription2Khr = 1000109002,
SubpassDependency2Khr = 1000109003,
RenderPassCreateInfo2Khr = 1000109004,
SubpassBeginInfoKhr = 1000109005,
SubpassEndInfoKhr = 1000109006,
SharedPresentSurfaceCapabilitiesKhr = 1000111000,
ImportFenceWin32HandleInfoKhr = 1000114000,
ExportFenceWin32HandleInfoKhr = 1000114001,
FenceGetWin32HandleInfoKhr = 1000114002,
ImportFenceFdInfoKhr = 1000115000,
FenceGetFdInfoKhr = 1000115001,
PhysicalDeviceSurfaceInfo2Khr = 1000119000,
SurfaceCapabilities2Khr = 1000119001,
SurfaceFormat2Khr = 1000119002,
DisplayProperties2Khr = 1000121000,
DisplayPlaneProperties2Khr = 1000121001,
DisplayModeProperties2Khr = 1000121002,
DisplayPlaneInfo2Khr = 1000121003,
DisplayPlaneCapabilities2Khr = 1000121004,
IosSurfaceCreateInfoMvk = 1000122000,
MacosSurfaceCreateInfoMvk = 1000123000,
DebugUtilsObjectNameInfoExt = 1000128000,
DebugUtilsObjectTagInfoExt = 1000128001,
DebugUtilsLabelExt = 1000128002,
DebugUtilsMessengerCallbackDataExt = 1000128003,
DebugUtilsMessengerCreateInfoExt = 1000128004,
AndroidHardwareBufferUsageAndroid = 1000129000,
AndroidHardwareBufferPropertiesAndroid = 1000129001,
AndroidHardwareBufferFormatPropertiesAndroid = 1000129002,
ImportAndroidHardwareBufferInfoAndroid = 1000129003,
MemoryGetAndroidHardwareBufferInfoAndroid = 1000129004,
ExternalFormatAndroid = 1000129005,
PhysicalDeviceSamplerFilterMinmaxPropertiesExt = 1000130000,
SamplerReductionModeCreateInfoExt = 1000130001,
PhysicalDeviceInlineUniformBlockFeaturesExt = 1000138000,
PhysicalDeviceInlineUniformBlockPropertiesExt = 1000138001,
WriteDescriptorSetInlineUniformBlockExt = 1000138002,
DescriptorPoolInlineUniformBlockCreateInfoExt = 1000138003,
SampleLocationsInfoExt = 1000143000,
RenderPassSampleLocationsBeginInfoExt = 1000143001,
PipelineSampleLocationsStateCreateInfoExt = 1000143002,
PhysicalDeviceSampleLocationsPropertiesExt = 1000143003,
MultisamplePropertiesExt = 1000143004,
ImageFormatListCreateInfoKhr = 1000147000,
PhysicalDeviceBlendOperationAdvancedFeaturesExt = 1000148000,
PhysicalDeviceBlendOperationAdvancedPropertiesExt = 1000148001,
PipelineColorBlendAdvancedStateCreateInfoExt = 1000148002,
PipelineCoverageToColorStateCreateInfoNv = 1000149000,
PipelineCoverageModulationStateCreateInfoNv = 1000152000,
DrmFormatModifierPropertiesListExt = 1000158000,
DrmFormatModifierPropertiesExt = 1000158001,
PhysicalDeviceImageDrmFormatModifierInfoExt = 1000158002,
ImageDrmFormatModifierListCreateInfoExt = 1000158003,
ImageDrmFormatModifierExplicitCreateInfoExt = 1000158004,
ImageDrmFormatModifierPropertiesExt = 1000158005,
ValidationCacheCreateInfoExt = 1000160000,
ShaderModuleValidationCacheCreateInfoExt = 1000160001,
DescriptorSetLayoutBindingFlagsCreateInfoExt = 1000161000,
PhysicalDeviceDescriptorIndexingFeaturesExt = 1000161001,
PhysicalDeviceDescriptorIndexingPropertiesExt = 1000161002,
DescriptorSetVariableDescriptorCountAllocateInfoExt = 1000161003,
DescriptorSetVariableDescriptorCountLayoutSupportExt = 1000161004,
PipelineViewportShadingRateImageStateCreateInfoNv = 1000164000,
PhysicalDeviceShadingRateImageFeaturesNv = 1000164001,
PhysicalDeviceShadingRateImagePropertiesNv = 1000164002,
PipelineViewportCoarseSampleOrderStateCreateInfoNv = 1000164005,
RayTracingPipelineCreateInfoNv = 1000165000,
AccelerationStructureCreateInfoNv = 1000165001,
GeometryNv = 1000165003,
GeometryTrianglesNv = 1000165004,
GeometryAabbNv = 1000165005,
BindAccelerationStructureMemoryInfoNv = 1000165006,
WriteDescriptorSetAccelerationStructureNv = 1000165007,
AccelerationStructureMemoryRequirementsInfoNv = 1000165008,
PhysicalDeviceRayTracingPropertiesNv = 1000165009,
RayTracingShaderGroupCreateInfoNv = 1000165011,
AccelerationStructureInfoNv = 1000165012,
PhysicalDeviceRepresentativeFragmentTestFeaturesNv = 1000166000,
PipelineRepresentativeFragmentTestStateCreateInfoNv = 1000166001,
DeviceQueueGlobalPriorityCreateInfoExt = 1000174000,
PhysicalDevice8bitStorageFeaturesKhr = 1000177000,
ImportMemoryHostPointerInfoExt = 1000178000,
MemoryHostPointerPropertiesExt = 1000178001,
PhysicalDeviceExternalMemoryHostPropertiesExt = 1000178002,
PhysicalDeviceShaderAtomicInt64FeaturesKhr = 1000180000,
CalibratedTimestampInfoExt = 1000184000,
PhysicalDeviceShaderCorePropertiesAmd = 1000185000,
DeviceMemoryOverallocationCreateInfoAmd = 1000189000,
PhysicalDeviceVertexAttributeDivisorPropertiesExt = 1000190000,
PipelineVertexInputDivisorStateCreateInfoExt = 1000190001,
PhysicalDeviceVertexAttributeDivisorFeaturesExt = 1000190002,
PhysicalDeviceDriverPropertiesKhr = 1000196000,
PhysicalDeviceFloatControlsPropertiesKhr = 1000197000,
PhysicalDeviceDepthStencilResolvePropertiesKhr = 1000199000,
SubpassDescriptionDepthStencilResolveKhr = 1000199001,
PhysicalDeviceComputeShaderDerivativesFeaturesNv = 1000201000,
PhysicalDeviceMeshShaderFeaturesNv = 1000202000,
PhysicalDeviceMeshShaderPropertiesNv = 1000202001,
PhysicalDeviceFragmentShaderBarycentricFeaturesNv = 1000203000,
PhysicalDeviceShaderImageFootprintFeaturesNv = 1000204000,
PipelineViewportExclusiveScissorStateCreateInfoNv = 1000205000,
PhysicalDeviceExclusiveScissorFeaturesNv = 1000205002,
CheckpointDataNv = 1000206000,
QueueFamilyCheckpointPropertiesNv = 1000206001,
PhysicalDeviceVulkanMemoryModelFeaturesKhr = 1000211000,
PhysicalDevicePciBusInfoPropertiesExt = 1000212000,
ImagepipeSurfaceCreateInfoFuchsia = 1000214000,
PhysicalDeviceFragmentDensityMapFeaturesExt = 1000218000,
PhysicalDeviceFragmentDensityMapPropertiesExt = 1000218001,
RenderPassFragmentDensityMapCreateInfoExt = 1000218002,
PhysicalDeviceScalarBlockLayoutFeaturesExt = 1000221000,
PhysicalDeviceMemoryBudgetPropertiesExt = 1000237000,
PhysicalDeviceMemoryPriorityFeaturesExt = 1000238000,
MemoryPriorityAllocateInfoExt = 1000238001,
PhysicalDeviceBufferAddressFeaturesExt = 1000244000,
BufferDeviceAddressInfoExt = 1000244001,
BufferDeviceAddressCreateInfoExt = 1000244002,
ImageStencilUsageCreateInfoExt = 1000246000,
ValidationFeaturesExt = 1000247000,
DebugReportCreateInfoExt = 1000011000,
RenderPassMultiviewCreateInfoKhr = 1000053000,
PhysicalDeviceMultiviewFeaturesKhr = 1000053001,
PhysicalDeviceMultiviewPropertiesKhr = 1000053002,
PhysicalDeviceFeatures2Khr = 1000059000,
PhysicalDeviceProperties2Khr = 1000059001,
FormatProperties2Khr = 1000059002,
ImageFormatProperties2Khr = 1000059003,
PhysicalDeviceImageFormatInfo2Khr = 1000059004,
QueueFamilyProperties2Khr = 1000059005,
PhysicalDeviceMemoryProperties2Khr = 1000059006,
SparseImageFormatProperties2Khr = 1000059007,
PhysicalDeviceSparseImageFormatInfo2Khr = 1000059008,
MemoryAllocateFlagsInfoKhr = 1000060000,
DeviceGroupRenderPassBeginInfoKhr = 1000060003,
DeviceGroupCommandBufferBeginInfoKhr = 1000060004,
DeviceGroupSubmitInfoKhr = 1000060005,
DeviceGroupBindSparseInfoKhr = 1000060006,
BindBufferMemoryDeviceGroupInfoKhr = 1000060013,
BindImageMemoryDeviceGroupInfoKhr = 1000060014,
PhysicalDeviceGroupPropertiesKhr = 1000070000,
DeviceGroupDeviceCreateInfoKhr = 1000070001,
PhysicalDeviceExternalImageFormatInfoKhr = 1000071000,
ExternalImageFormatPropertiesKhr = 1000071001,
PhysicalDeviceExternalBufferInfoKhr = 1000071002,
ExternalBufferPropertiesKhr = 1000071003,
PhysicalDeviceIdPropertiesKhr = 1000071004,
ExternalMemoryBufferCreateInfoKhr = 1000072000,
ExternalMemoryImageCreateInfoKhr = 1000072001,
ExportMemoryAllocateInfoKhr = 1000072002,
PhysicalDeviceExternalSemaphoreInfoKhr = 1000076000,
ExternalSemaphorePropertiesKhr = 1000076001,
ExportSemaphoreCreateInfoKhr = 1000077000,
PhysicalDevice16bitStorageFeaturesKhr = 1000083000,
DescriptorUpdateTemplateCreateInfoKhr = 1000085000,
PhysicalDeviceExternalFenceInfoKhr = 1000112000,
ExternalFencePropertiesKhr = 1000112001,
ExportFenceCreateInfoKhr = 1000113000,
PhysicalDevicePointClippingPropertiesKhr = 1000117000,
RenderPassInputAttachmentAspectCreateInfoKhr = 1000117001,
ImageViewUsageCreateInfoKhr = 1000117002,
PipelineTessellationDomainOriginStateCreateInfoKhr = 1000117003,
PhysicalDeviceVariablePointerFeaturesKhr = 1000120000,
MemoryDedicatedRequirementsKhr = 1000127000,
MemoryDedicatedAllocateInfoKhr = 1000127001,
BufferMemoryRequirementsInfo2Khr = 1000146000,
ImageMemoryRequirementsInfo2Khr = 1000146001,
ImageSparseMemoryRequirementsInfo2Khr = 1000146002,
MemoryRequirements2Khr = 1000146003,
SparseImageMemoryRequirements2Khr = 1000146004,
SamplerYcbcrConversionCreateInfoKhr = 1000156000,
SamplerYcbcrConversionInfoKhr = 1000156001,
BindImagePlaneMemoryInfoKhr = 1000156002,
ImagePlaneMemoryRequirementsInfoKhr = 1000156003,
PhysicalDeviceSamplerYcbcrConversionFeaturesKhr = 1000156004,
SamplerYcbcrConversionImageFormatPropertiesKhr = 1000156005,
BindBufferMemoryInfoKhr = 1000157000,
BindImageMemoryInfoKhr = 1000157001,
PhysicalDeviceMaintenance3PropertiesKhr = 1000168000,
DescriptorSetLayoutSupportKhr = 1000168001,
BeginRange = 0,
EndRange = 48,
RangeSize = 49,
MaxEnum = 2147483647,
}
//VkSubpassContents
public enum VkSubpassContents : Int32
{
Inline = 0,
SecondaryCommandBuffers = 1,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkSurfaceCounterFlagBitsEXT
public enum VkSurfaceCounterFlagBitsEXT : Int32
{
VblankExt = 1,
FlagBitsMaxEnumExt = 2147483647,
}
//VkSurfaceTransformFlagBitsKHR
public enum VkSurfaceTransformFlagBitsKHR : Int32
{
IdentityBitKhr = 1,
Rotate90BitKhr = 2,
Rotate180BitKhr = 4,
Rotate270BitKhr = 8,
HorizontalMirrorBitKhr = 16,
HorizontalMirrorRotate90BitKhr = 32,
HorizontalMirrorRotate180BitKhr = 64,
HorizontalMirrorRotate270BitKhr = 128,
InheritBitKhr = 256,
FlagBitsMaxEnumKhr = 2147483647,
}
//VkSystemAllocationScope
public enum VkSystemAllocationScope : Int32
{
Command = 0,
Object = 1,
Cache = 2,
Device = 3,
Instance = 4,
BeginRange = 0,
EndRange = 4,
RangeSize = 5,
MaxEnum = 2147483647,
}
//VkTimeDomainEXT
public enum VkTimeDomainEXT : Int32
{
DeviceExt = 0,
ClockMonotonicExt = 1,
ClockMonotonicRawExt = 2,
QueryPerformanceCounterExt = 3,
BeginRangeExt = 0,
EndRangeExt = 3,
RangeSizeExt = 4,
MaxEnumExt = 2147483647,
}
//VkVertexInputRate
public enum VkVertexInputRate : Int32
{
Vertex = 0,
Instance = 1,
BeginRange = 0,
EndRange = 1,
RangeSize = 2,
MaxEnum = 2147483647,
}
//VkAccelerationStructureNV
public unsafe partial struct VkAccelerationStructureNV
{
IntPtr ptr;
public VkAccelerationStructureNV(IntPtr ptr) => this.ptr = ptr;
}
//VkBuffer
public unsafe partial struct VkBuffer
{
IntPtr ptr;
public VkBuffer(IntPtr ptr) => this.ptr = ptr;
}
//VkBufferView
public unsafe partial struct VkBufferView
{
IntPtr ptr;
public VkBufferView(IntPtr ptr) => this.ptr = ptr;
}
//VkCommandBuffer
public unsafe partial struct VkCommandBuffer
{
IntPtr ptr;
public VkCommandBuffer(IntPtr ptr) => this.ptr = ptr;
}
//VkCommandPool
public unsafe partial struct VkCommandPool
{
IntPtr ptr;
public VkCommandPool(IntPtr ptr) => this.ptr = ptr;
}
//VkDebugReportCallbackEXT
public unsafe partial struct VkDebugReportCallbackEXT
{
IntPtr ptr;
public VkDebugReportCallbackEXT(IntPtr ptr) => this.ptr = ptr;
}
//VkDebugUtilsMessengerEXT
public unsafe partial struct VkDebugUtilsMessengerEXT
{
IntPtr ptr;
public VkDebugUtilsMessengerEXT(IntPtr ptr) => this.ptr = ptr;
}
//VkDescriptorPool
public unsafe partial struct VkDescriptorPool
{
IntPtr ptr;
public VkDescriptorPool(IntPtr ptr) => this.ptr = ptr;
}
//VkDescriptorSet
public unsafe partial struct VkDescriptorSet
{
IntPtr ptr;
public VkDescriptorSet(IntPtr ptr) => this.ptr = ptr;
}
//VkDescriptorSetLayout
public unsafe partial struct VkDescriptorSetLayout
{
IntPtr ptr;
public VkDescriptorSetLayout(IntPtr ptr) => this.ptr = ptr;
}
//VkDescriptorUpdateTemplate
public unsafe partial struct VkDescriptorUpdateTemplate
{
IntPtr ptr;
public VkDescriptorUpdateTemplate(IntPtr ptr) => this.ptr = ptr;
}
//VkDevice
public unsafe partial struct VkDevice
{
IntPtr ptr;
public VkDevice(IntPtr ptr) => this.ptr = ptr;
}
//VkDeviceMemory
public unsafe partial struct VkDeviceMemory
{
IntPtr ptr;
public VkDeviceMemory(IntPtr ptr) => this.ptr = ptr;
}
//VkDisplayKHR
public unsafe partial struct VkDisplayKHR
{
IntPtr ptr;
public VkDisplayKHR(IntPtr ptr) => this.ptr = ptr;
}
//VkDisplayModeKHR
public unsafe partial struct VkDisplayModeKHR
{
IntPtr ptr;
public VkDisplayModeKHR(IntPtr ptr) => this.ptr = ptr;
}
//VkEvent
public unsafe partial struct VkEvent
{
IntPtr ptr;
public VkEvent(IntPtr ptr) => this.ptr = ptr;
}
//VkFence
public unsafe partial struct VkFence
{
IntPtr ptr;
public VkFence(IntPtr ptr) => this.ptr = ptr;
}
//VkFramebuffer
public unsafe partial struct VkFramebuffer
{
IntPtr ptr;
public VkFramebuffer(IntPtr ptr) => this.ptr = ptr;
}
//VkImage
public unsafe partial struct VkImage
{
IntPtr ptr;
public VkImage(IntPtr ptr) => this.ptr = ptr;
}
//VkImageView
public unsafe partial struct VkImageView
{
IntPtr ptr;
public VkImageView(IntPtr ptr) => this.ptr = ptr;
}
//VkIndirectCommandsLayoutNVX
public unsafe partial struct VkIndirectCommandsLayoutNVX
{
IntPtr ptr;
public VkIndirectCommandsLayoutNVX(IntPtr ptr) => this.ptr = ptr;
}
//VkInstance
public unsafe partial struct VkInstance
{
IntPtr ptr;
public VkInstance(IntPtr ptr) => this.ptr = ptr;
}
//VkObjectTableNVX
public unsafe partial struct VkObjectTableNVX
{
IntPtr ptr;
public VkObjectTableNVX(IntPtr ptr) => this.ptr = ptr;
}
//VkPhysicalDevice
public unsafe partial struct VkPhysicalDevice
{
IntPtr ptr;
public VkPhysicalDevice(IntPtr ptr) => this.ptr = ptr;
}
//VkPipeline
public unsafe partial struct VkPipeline
{
IntPtr ptr;
public VkPipeline(IntPtr ptr) => this.ptr = ptr;
}
//VkPipelineCache
public unsafe partial struct VkPipelineCache
{
IntPtr ptr;
public VkPipelineCache(IntPtr ptr) => this.ptr = ptr;
}
//VkPipelineLayout
public unsafe partial struct VkPipelineLayout
{
IntPtr ptr;
public VkPipelineLayout(IntPtr ptr) => this.ptr = ptr;
}
//VkQueryPool
public unsafe partial struct VkQueryPool
{
IntPtr ptr;
public VkQueryPool(IntPtr ptr) => this.ptr = ptr;
}
//VkQueue
public unsafe partial struct VkQueue
{
IntPtr ptr;
public VkQueue(IntPtr ptr) => this.ptr = ptr;
}
//VkRenderPass
public unsafe partial struct VkRenderPass
{
IntPtr ptr;
public VkRenderPass(IntPtr ptr) => this.ptr = ptr;
}
//VkSampler
public unsafe partial struct VkSampler
{
IntPtr ptr;
public VkSampler(IntPtr ptr) => this.ptr = ptr;
}
//VkSamplerYcbcrConversion
public unsafe partial struct VkSamplerYcbcrConversion
{
IntPtr ptr;
public VkSamplerYcbcrConversion(IntPtr ptr) => this.ptr = ptr;
}
//VkSemaphore
public unsafe partial struct VkSemaphore
{
IntPtr ptr;
public VkSemaphore(IntPtr ptr) => this.ptr = ptr;
}
//VkShaderModule
public unsafe partial struct VkShaderModule
{
IntPtr ptr;
public VkShaderModule(IntPtr ptr) => this.ptr = ptr;
}
//VkSurfaceKHR
public unsafe partial struct VkSurfaceKHR
{
IntPtr ptr;
public VkSurfaceKHR(IntPtr ptr) => this.ptr = ptr;
}
//VkSwapchainKHR
public unsafe partial struct VkSwapchainKHR
{
IntPtr ptr;
public VkSwapchainKHR(IntPtr ptr) => this.ptr = ptr;
}
//VkValidationCacheEXT
public unsafe partial struct VkValidationCacheEXT
{
IntPtr ptr;
public VkValidationCacheEXT(IntPtr ptr) => this.ptr = ptr;
}
public unsafe partial struct VkAccelerationStructureCreateInfoNV : IDisposable
{
//VkAccelerationStructureCreateInfoNV
private VkAccelerationStructureCreateInfoNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkAccelerationStructureCreateInfoNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkAccelerationStructureCreateInfoNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkAccelerationStructureCreateInfoNV AsPtr() { fixed(Data* ptr = &this) return new VkAccelerationStructureCreateInfoNV(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDeviceSize CompactedSize;
public VkAccelerationStructureInfoNV Info;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDeviceSize CompactedSize => ptr->CompactedSize;
public void SetCompactedSize(VkDeviceSize value) => ptr->CompactedSize = value;
public VkAccelerationStructureInfoNV Info => ptr->Info;
public void SetInfo(VkAccelerationStructureInfoNV value) => ptr->Info = value;
}
public unsafe partial struct VkAccelerationStructureInfoNV
{
//VkAccelerationStructureInfoNV
public VkStructureType SType;
public IntPtr PNext;
public VkAccelerationStructureTypeNV Type;
public VkBuildAccelerationStructureFlagsNV Flags;
public uint InstanceCount;
public uint GeometryCount;
public VkGeometryNV PGeometries;
}
public unsafe partial struct VkAccelerationStructureMemoryRequirementsInfoNV : IDisposable
{
//VkAccelerationStructureMemoryRequirementsInfoNV
private VkAccelerationStructureMemoryRequirementsInfoNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkAccelerationStructureMemoryRequirementsInfoNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkAccelerationStructureMemoryRequirementsInfoNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkAccelerationStructureMemoryRequirementsInfoNV AsPtr() { fixed(Data* ptr = &this) return new VkAccelerationStructureMemoryRequirementsInfoNV(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkAccelerationStructureMemoryRequirementsTypeNV Type;
public VkAccelerationStructureNV AccelerationStructure;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkAccelerationStructureMemoryRequirementsTypeNV Type => ptr->Type;
public void SetType(VkAccelerationStructureMemoryRequirementsTypeNV value) => ptr->Type = value;
public VkAccelerationStructureNV AccelerationStructure => ptr->AccelerationStructure;
public void SetAccelerationStructure(VkAccelerationStructureNV value) => ptr->AccelerationStructure = value;
}
public unsafe partial struct VkAcquireNextImageInfoKHR : IDisposable
{
//VkAcquireNextImageInfoKHR
private VkAcquireNextImageInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkAcquireNextImageInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkAcquireNextImageInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkAcquireNextImageInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkAcquireNextImageInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSwapchainKHR Swapchain;
public ulong Timeout;
public VkSemaphore Semaphore;
public VkFence Fence;
public uint DeviceMask;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSwapchainKHR Swapchain => ptr->Swapchain;
public void SetSwapchain(VkSwapchainKHR value) => ptr->Swapchain = value;
public ulong Timeout => ptr->Timeout;
public void SetTimeout(ulong value) => ptr->Timeout = value;
public VkSemaphore Semaphore => ptr->Semaphore;
public void SetSemaphore(VkSemaphore value) => ptr->Semaphore = value;
public VkFence Fence => ptr->Fence;
public void SetFence(VkFence value) => ptr->Fence = value;
public uint DeviceMask => ptr->DeviceMask;
public void SetDeviceMask(uint value) => ptr->DeviceMask = value;
}
public unsafe partial struct VkAllocationCallbacks : IDisposable
{
//VkAllocationCallbacks
private VkAllocationCallbacks(Data* ptr)
{
this.ptr = ptr;
}
public static VkAllocationCallbacks New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkAllocationCallbacks(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkAllocationCallbacks AsPtr() { fixed(Data* ptr = &this) return new VkAllocationCallbacks(ptr); }
public IntPtr PUserData;
internal IntPtr _PfnAllocation;
public void SetPfnAllocation(PFNVkAllocationFunctionDelegate value) => _PfnAllocation = Marshal.GetFunctionPointerForDelegate(value);
internal IntPtr _PfnReallocation;
public void SetPfnReallocation(PFNVkReallocationFunctionDelegate value) => _PfnReallocation = Marshal.GetFunctionPointerForDelegate(value);
internal IntPtr _PfnFree;
public void SetPfnFree(PFNVkFreeFunctionDelegate value) => _PfnFree = Marshal.GetFunctionPointerForDelegate(value);
internal IntPtr _PfnInternalAllocation;
public void SetPfnInternalAllocation(PFNVkInternalAllocationNotificationDelegate value) => _PfnInternalAllocation = Marshal.GetFunctionPointerForDelegate(value);
internal IntPtr _PfnInternalFree;
public void SetPfnInternalFree(PFNVkInternalFreeNotificationDelegate value) => _PfnInternalFree = Marshal.GetFunctionPointerForDelegate(value);
}
public IntPtr PUserData => ptr->PUserData;
public void SetPUserData(IntPtr value) => ptr->PUserData = value;
public PFNVkAllocationFunctionDelegate PfnAllocation => Marshal.GetDelegateForFunctionPointer<PFNVkAllocationFunctionDelegate>(ptr->_PfnAllocation);
public void SetPfnAllocation(PFNVkAllocationFunctionDelegate value) => ptr->_PfnAllocation = Marshal.GetFunctionPointerForDelegate(value);
public PFNVkReallocationFunctionDelegate PfnReallocation => Marshal.GetDelegateForFunctionPointer<PFNVkReallocationFunctionDelegate>(ptr->_PfnReallocation);
public void SetPfnReallocation(PFNVkReallocationFunctionDelegate value) => ptr->_PfnReallocation = Marshal.GetFunctionPointerForDelegate(value);
public PFNVkFreeFunctionDelegate PfnFree => Marshal.GetDelegateForFunctionPointer<PFNVkFreeFunctionDelegate>(ptr->_PfnFree);
public void SetPfnFree(PFNVkFreeFunctionDelegate value) => ptr->_PfnFree = Marshal.GetFunctionPointerForDelegate(value);
public PFNVkInternalAllocationNotificationDelegate PfnInternalAllocation => Marshal.GetDelegateForFunctionPointer<PFNVkInternalAllocationNotificationDelegate>(ptr->_PfnInternalAllocation);
public void SetPfnInternalAllocation(PFNVkInternalAllocationNotificationDelegate value) => ptr->_PfnInternalAllocation = Marshal.GetFunctionPointerForDelegate(value);
public PFNVkInternalFreeNotificationDelegate PfnInternalFree => Marshal.GetDelegateForFunctionPointer<PFNVkInternalFreeNotificationDelegate>(ptr->_PfnInternalFree);
public void SetPfnInternalFree(PFNVkInternalFreeNotificationDelegate value) => ptr->_PfnInternalFree = Marshal.GetFunctionPointerForDelegate(value);
}
public unsafe partial struct VkApplicationInfo : IDisposable
{
//VkApplicationInfo
private VkApplicationInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkApplicationInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkApplicationInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkApplicationInfo AsPtr() { fixed(Data* ptr = &this) return new VkApplicationInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public CString PApplicationName;
public uint ApplicationVersion;
public CString PEngineName;
public uint EngineVersion;
public uint ApiVersion;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public CString PApplicationName => ptr->PApplicationName;
public void SetPApplicationName(CString value) => ptr->PApplicationName = value;
public uint ApplicationVersion => ptr->ApplicationVersion;
public void SetApplicationVersion(uint value) => ptr->ApplicationVersion = value;
public CString PEngineName => ptr->PEngineName;
public void SetPEngineName(CString value) => ptr->PEngineName = value;
public uint EngineVersion => ptr->EngineVersion;
public void SetEngineVersion(uint value) => ptr->EngineVersion = value;
public uint ApiVersion => ptr->ApiVersion;
public void SetApiVersion(uint value) => ptr->ApiVersion = value;
}
public unsafe partial struct VkAttachmentDescription : IDisposable
{
//VkAttachmentDescription
private VkAttachmentDescription(Data* ptr)
{
this.ptr = ptr;
}
public static VkAttachmentDescription New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkAttachmentDescription(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkAttachmentDescription AsPtr() { fixed(Data* ptr = &this) return new VkAttachmentDescription(ptr); }
public VkAttachmentDescriptionFlags Flags;
public VkFormat Format;
public VkSampleCountFlagBits Samples;
public VkAttachmentLoadOp LoadOp;
public VkAttachmentStoreOp StoreOp;
public VkAttachmentLoadOp StencilLoadOp;
public VkAttachmentStoreOp StencilStoreOp;
public VkImageLayout InitialLayout;
public VkImageLayout FinalLayout;
}
public VkAttachmentDescriptionFlags Flags => ptr->Flags;
public void SetFlags(VkAttachmentDescriptionFlags value) => ptr->Flags = value;
public VkFormat Format => ptr->Format;
public void SetFormat(VkFormat value) => ptr->Format = value;
public VkSampleCountFlagBits Samples => ptr->Samples;
public void SetSamples(VkSampleCountFlagBits value) => ptr->Samples = value;
public VkAttachmentLoadOp LoadOp => ptr->LoadOp;
public void SetLoadOp(VkAttachmentLoadOp value) => ptr->LoadOp = value;
public VkAttachmentStoreOp StoreOp => ptr->StoreOp;
public void SetStoreOp(VkAttachmentStoreOp value) => ptr->StoreOp = value;
public VkAttachmentLoadOp StencilLoadOp => ptr->StencilLoadOp;
public void SetStencilLoadOp(VkAttachmentLoadOp value) => ptr->StencilLoadOp = value;
public VkAttachmentStoreOp StencilStoreOp => ptr->StencilStoreOp;
public void SetStencilStoreOp(VkAttachmentStoreOp value) => ptr->StencilStoreOp = value;
public VkImageLayout InitialLayout => ptr->InitialLayout;
public void SetInitialLayout(VkImageLayout value) => ptr->InitialLayout = value;
public VkImageLayout FinalLayout => ptr->FinalLayout;
public void SetFinalLayout(VkImageLayout value) => ptr->FinalLayout = value;
}
public unsafe partial struct VkAttachmentDescription2KHR : IDisposable
{
//VkAttachmentDescription2KHR
private VkAttachmentDescription2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkAttachmentDescription2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkAttachmentDescription2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkAttachmentDescription2KHR AsPtr() { fixed(Data* ptr = &this) return new VkAttachmentDescription2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkAttachmentDescriptionFlags Flags;
public VkFormat Format;
public VkSampleCountFlagBits Samples;
public VkAttachmentLoadOp LoadOp;
public VkAttachmentStoreOp StoreOp;
public VkAttachmentLoadOp StencilLoadOp;
public VkAttachmentStoreOp StencilStoreOp;
public VkImageLayout InitialLayout;
public VkImageLayout FinalLayout;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkAttachmentDescriptionFlags Flags => ptr->Flags;
public void SetFlags(VkAttachmentDescriptionFlags value) => ptr->Flags = value;
public VkFormat Format => ptr->Format;
public void SetFormat(VkFormat value) => ptr->Format = value;
public VkSampleCountFlagBits Samples => ptr->Samples;
public void SetSamples(VkSampleCountFlagBits value) => ptr->Samples = value;
public VkAttachmentLoadOp LoadOp => ptr->LoadOp;
public void SetLoadOp(VkAttachmentLoadOp value) => ptr->LoadOp = value;
public VkAttachmentStoreOp StoreOp => ptr->StoreOp;
public void SetStoreOp(VkAttachmentStoreOp value) => ptr->StoreOp = value;
public VkAttachmentLoadOp StencilLoadOp => ptr->StencilLoadOp;
public void SetStencilLoadOp(VkAttachmentLoadOp value) => ptr->StencilLoadOp = value;
public VkAttachmentStoreOp StencilStoreOp => ptr->StencilStoreOp;
public void SetStencilStoreOp(VkAttachmentStoreOp value) => ptr->StencilStoreOp = value;
public VkImageLayout InitialLayout => ptr->InitialLayout;
public void SetInitialLayout(VkImageLayout value) => ptr->InitialLayout = value;
public VkImageLayout FinalLayout => ptr->FinalLayout;
public void SetFinalLayout(VkImageLayout value) => ptr->FinalLayout = value;
}
public unsafe partial struct VkAttachmentReference : IDisposable
{
//VkAttachmentReference
private VkAttachmentReference(Data* ptr)
{
this.ptr = ptr;
}
public static VkAttachmentReference New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkAttachmentReference(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkAttachmentReference AsPtr() { fixed(Data* ptr = &this) return new VkAttachmentReference(ptr); }
public uint Attachment;
public VkImageLayout Layout;
}
public uint Attachment => ptr->Attachment;
public void SetAttachment(uint value) => ptr->Attachment = value;
public VkImageLayout Layout => ptr->Layout;
public void SetLayout(VkImageLayout value) => ptr->Layout = value;
}
public unsafe partial struct VkAttachmentReference2KHR : IDisposable
{
//VkAttachmentReference2KHR
private VkAttachmentReference2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkAttachmentReference2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkAttachmentReference2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkAttachmentReference2KHR AsPtr() { fixed(Data* ptr = &this) return new VkAttachmentReference2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint Attachment;
public VkImageLayout Layout;
public VkImageAspectFlags AspectMask;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint Attachment => ptr->Attachment;
public void SetAttachment(uint value) => ptr->Attachment = value;
public VkImageLayout Layout => ptr->Layout;
public void SetLayout(VkImageLayout value) => ptr->Layout = value;
public VkImageAspectFlags AspectMask => ptr->AspectMask;
public void SetAspectMask(VkImageAspectFlags value) => ptr->AspectMask = value;
}
public unsafe partial struct VkBindAccelerationStructureMemoryInfoNV : IDisposable
{
//VkBindAccelerationStructureMemoryInfoNV
private VkBindAccelerationStructureMemoryInfoNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkBindAccelerationStructureMemoryInfoNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBindAccelerationStructureMemoryInfoNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBindAccelerationStructureMemoryInfoNV AsPtr() { fixed(Data* ptr = &this) return new VkBindAccelerationStructureMemoryInfoNV(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkAccelerationStructureNV AccelerationStructure;
public VkDeviceMemory Memory;
public VkDeviceSize MemoryOffset;
public uint DeviceIndexCount;
public uint* PDeviceIndices;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkAccelerationStructureNV AccelerationStructure => ptr->AccelerationStructure;
public void SetAccelerationStructure(VkAccelerationStructureNV value) => ptr->AccelerationStructure = value;
public VkDeviceMemory Memory => ptr->Memory;
public void SetMemory(VkDeviceMemory value) => ptr->Memory = value;
public VkDeviceSize MemoryOffset => ptr->MemoryOffset;
public void SetMemoryOffset(VkDeviceSize value) => ptr->MemoryOffset = value;
public uint DeviceIndexCount => ptr->DeviceIndexCount;
public void SetDeviceIndexCount(uint value) => ptr->DeviceIndexCount = value;
public uint* PDeviceIndices => ptr->PDeviceIndices;
public void SetPDeviceIndices(uint* value) => ptr->PDeviceIndices = value;
}
public unsafe partial struct VkBindBufferMemoryInfo : IDisposable
{
//VkBindBufferMemoryInfo
private VkBindBufferMemoryInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkBindBufferMemoryInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBindBufferMemoryInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBindBufferMemoryInfo AsPtr() { fixed(Data* ptr = &this) return new VkBindBufferMemoryInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkBuffer Buffer;
public VkDeviceMemory Memory;
public VkDeviceSize MemoryOffset;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkBuffer Buffer => ptr->Buffer;
public void SetBuffer(VkBuffer value) => ptr->Buffer = value;
public VkDeviceMemory Memory => ptr->Memory;
public void SetMemory(VkDeviceMemory value) => ptr->Memory = value;
public VkDeviceSize MemoryOffset => ptr->MemoryOffset;
public void SetMemoryOffset(VkDeviceSize value) => ptr->MemoryOffset = value;
}
public unsafe partial struct VkBindImageMemoryInfo : IDisposable
{
//VkBindImageMemoryInfo
private VkBindImageMemoryInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkBindImageMemoryInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBindImageMemoryInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBindImageMemoryInfo AsPtr() { fixed(Data* ptr = &this) return new VkBindImageMemoryInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkImage Image;
public VkDeviceMemory Memory;
public VkDeviceSize MemoryOffset;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkImage Image => ptr->Image;
public void SetImage(VkImage value) => ptr->Image = value;
public VkDeviceMemory Memory => ptr->Memory;
public void SetMemory(VkDeviceMemory value) => ptr->Memory = value;
public VkDeviceSize MemoryOffset => ptr->MemoryOffset;
public void SetMemoryOffset(VkDeviceSize value) => ptr->MemoryOffset = value;
}
public unsafe partial struct VkBindSparseInfo : IDisposable
{
//VkBindSparseInfo
private VkBindSparseInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkBindSparseInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBindSparseInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBindSparseInfo AsPtr() { fixed(Data* ptr = &this) return new VkBindSparseInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint WaitSemaphoreCount;
public VkSemaphore* PWaitSemaphores;
public uint BufferBindCount;
public VkSparseBufferMemoryBindInfo PBufferBinds;
public uint ImageOpaqueBindCount;
public VkSparseImageOpaqueMemoryBindInfo PImageOpaqueBinds;
public uint ImageBindCount;
public VkSparseImageMemoryBindInfo PImageBinds;
public uint SignalSemaphoreCount;
public VkSemaphore* PSignalSemaphores;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint WaitSemaphoreCount => ptr->WaitSemaphoreCount;
public void SetWaitSemaphoreCount(uint value) => ptr->WaitSemaphoreCount = value;
public VkSemaphore* PWaitSemaphores => ptr->PWaitSemaphores;
public void SetPWaitSemaphores(VkSemaphore* value) => ptr->PWaitSemaphores = value;
public uint BufferBindCount => ptr->BufferBindCount;
public void SetBufferBindCount(uint value) => ptr->BufferBindCount = value;
public VkSparseBufferMemoryBindInfo PBufferBinds => ptr->PBufferBinds;
public void SetPBufferBinds(VkSparseBufferMemoryBindInfo value) => ptr->PBufferBinds = value;
public uint ImageOpaqueBindCount => ptr->ImageOpaqueBindCount;
public void SetImageOpaqueBindCount(uint value) => ptr->ImageOpaqueBindCount = value;
public VkSparseImageOpaqueMemoryBindInfo PImageOpaqueBinds => ptr->PImageOpaqueBinds;
public void SetPImageOpaqueBinds(VkSparseImageOpaqueMemoryBindInfo value) => ptr->PImageOpaqueBinds = value;
public uint ImageBindCount => ptr->ImageBindCount;
public void SetImageBindCount(uint value) => ptr->ImageBindCount = value;
public VkSparseImageMemoryBindInfo PImageBinds => ptr->PImageBinds;
public void SetPImageBinds(VkSparseImageMemoryBindInfo value) => ptr->PImageBinds = value;
public uint SignalSemaphoreCount => ptr->SignalSemaphoreCount;
public void SetSignalSemaphoreCount(uint value) => ptr->SignalSemaphoreCount = value;
public VkSemaphore* PSignalSemaphores => ptr->PSignalSemaphores;
public void SetPSignalSemaphores(VkSemaphore* value) => ptr->PSignalSemaphores = value;
}
public unsafe partial struct VkBufferCopy : IDisposable
{
//VkBufferCopy
private VkBufferCopy(Data* ptr)
{
this.ptr = ptr;
}
public static VkBufferCopy New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBufferCopy(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBufferCopy AsPtr() { fixed(Data* ptr = &this) return new VkBufferCopy(ptr); }
public VkDeviceSize SrcOffset;
public VkDeviceSize DstOffset;
public VkDeviceSize Size;
}
public VkDeviceSize SrcOffset => ptr->SrcOffset;
public void SetSrcOffset(VkDeviceSize value) => ptr->SrcOffset = value;
public VkDeviceSize DstOffset => ptr->DstOffset;
public void SetDstOffset(VkDeviceSize value) => ptr->DstOffset = value;
public VkDeviceSize Size => ptr->Size;
public void SetSize(VkDeviceSize value) => ptr->Size = value;
}
public unsafe partial struct VkBufferCreateInfo : IDisposable
{
//VkBufferCreateInfo
private VkBufferCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkBufferCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBufferCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBufferCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkBufferCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkBufferCreateFlags Flags;
public VkDeviceSize Size;
public VkBufferUsageFlags Usage;
public VkSharingMode SharingMode;
public uint QueueFamilyIndexCount;
public uint* PQueueFamilyIndices;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkBufferCreateFlags Flags => ptr->Flags;
public void SetFlags(VkBufferCreateFlags value) => ptr->Flags = value;
public VkDeviceSize Size => ptr->Size;
public void SetSize(VkDeviceSize value) => ptr->Size = value;
public VkBufferUsageFlags Usage => ptr->Usage;
public void SetUsage(VkBufferUsageFlags value) => ptr->Usage = value;
public VkSharingMode SharingMode => ptr->SharingMode;
public void SetSharingMode(VkSharingMode value) => ptr->SharingMode = value;
public uint QueueFamilyIndexCount => ptr->QueueFamilyIndexCount;
public void SetQueueFamilyIndexCount(uint value) => ptr->QueueFamilyIndexCount = value;
public uint* PQueueFamilyIndices => ptr->PQueueFamilyIndices;
public void SetPQueueFamilyIndices(uint* value) => ptr->PQueueFamilyIndices = value;
}
public unsafe partial struct VkBufferDeviceAddressInfoEXT : IDisposable
{
//VkBufferDeviceAddressInfoEXT
private VkBufferDeviceAddressInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkBufferDeviceAddressInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBufferDeviceAddressInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBufferDeviceAddressInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkBufferDeviceAddressInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkBuffer Buffer;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkBuffer Buffer => ptr->Buffer;
public void SetBuffer(VkBuffer value) => ptr->Buffer = value;
}
public unsafe partial struct VkBufferImageCopy : IDisposable
{
//VkBufferImageCopy
private VkBufferImageCopy(Data* ptr)
{
this.ptr = ptr;
}
public static VkBufferImageCopy New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBufferImageCopy(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBufferImageCopy AsPtr() { fixed(Data* ptr = &this) return new VkBufferImageCopy(ptr); }
public VkDeviceSize BufferOffset;
public uint BufferRowLength;
public uint BufferImageHeight;
public VkImageSubresourceLayers ImageSubresource;
public VkOffset3D ImageOffset;
public VkExtent3D ImageExtent;
}
public VkDeviceSize BufferOffset => ptr->BufferOffset;
public void SetBufferOffset(VkDeviceSize value) => ptr->BufferOffset = value;
public uint BufferRowLength => ptr->BufferRowLength;
public void SetBufferRowLength(uint value) => ptr->BufferRowLength = value;
public uint BufferImageHeight => ptr->BufferImageHeight;
public void SetBufferImageHeight(uint value) => ptr->BufferImageHeight = value;
public VkImageSubresourceLayers ImageSubresource => ptr->ImageSubresource;
public void SetImageSubresource(VkImageSubresourceLayers value) => ptr->ImageSubresource = value;
public VkOffset3D ImageOffset => ptr->ImageOffset;
public void SetImageOffset(VkOffset3D value) => ptr->ImageOffset = value;
public VkExtent3D ImageExtent => ptr->ImageExtent;
public void SetImageExtent(VkExtent3D value) => ptr->ImageExtent = value;
}
public unsafe partial struct VkBufferMemoryBarrier : IDisposable
{
//VkBufferMemoryBarrier
private VkBufferMemoryBarrier(Data* ptr)
{
this.ptr = ptr;
}
public static VkBufferMemoryBarrier New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBufferMemoryBarrier(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBufferMemoryBarrier AsPtr() { fixed(Data* ptr = &this) return new VkBufferMemoryBarrier(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkAccessFlags SrcAccessMask;
public VkAccessFlags DstAccessMask;
public uint SrcQueueFamilyIndex;
public uint DstQueueFamilyIndex;
public VkBuffer Buffer;
public VkDeviceSize Offset;
public VkDeviceSize Size;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkAccessFlags SrcAccessMask => ptr->SrcAccessMask;
public void SetSrcAccessMask(VkAccessFlags value) => ptr->SrcAccessMask = value;
public VkAccessFlags DstAccessMask => ptr->DstAccessMask;
public void SetDstAccessMask(VkAccessFlags value) => ptr->DstAccessMask = value;
public uint SrcQueueFamilyIndex => ptr->SrcQueueFamilyIndex;
public void SetSrcQueueFamilyIndex(uint value) => ptr->SrcQueueFamilyIndex = value;
public uint DstQueueFamilyIndex => ptr->DstQueueFamilyIndex;
public void SetDstQueueFamilyIndex(uint value) => ptr->DstQueueFamilyIndex = value;
public VkBuffer Buffer => ptr->Buffer;
public void SetBuffer(VkBuffer value) => ptr->Buffer = value;
public VkDeviceSize Offset => ptr->Offset;
public void SetOffset(VkDeviceSize value) => ptr->Offset = value;
public VkDeviceSize Size => ptr->Size;
public void SetSize(VkDeviceSize value) => ptr->Size = value;
}
public unsafe partial struct VkBufferMemoryRequirementsInfo2 : IDisposable
{
//VkBufferMemoryRequirementsInfo2
private VkBufferMemoryRequirementsInfo2(Data* ptr)
{
this.ptr = ptr;
}
public static VkBufferMemoryRequirementsInfo2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBufferMemoryRequirementsInfo2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBufferMemoryRequirementsInfo2 AsPtr() { fixed(Data* ptr = &this) return new VkBufferMemoryRequirementsInfo2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkBuffer Buffer;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkBuffer Buffer => ptr->Buffer;
public void SetBuffer(VkBuffer value) => ptr->Buffer = value;
}
public unsafe partial struct VkBufferViewCreateInfo : IDisposable
{
//VkBufferViewCreateInfo
private VkBufferViewCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkBufferViewCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkBufferViewCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkBufferViewCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkBufferViewCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkBufferViewCreateFlags Flags;
public VkBuffer Buffer;
public VkFormat Format;
public VkDeviceSize Offset;
public VkDeviceSize Range;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkBufferViewCreateFlags Flags => ptr->Flags;
public void SetFlags(VkBufferViewCreateFlags value) => ptr->Flags = value;
public VkBuffer Buffer => ptr->Buffer;
public void SetBuffer(VkBuffer value) => ptr->Buffer = value;
public VkFormat Format => ptr->Format;
public void SetFormat(VkFormat value) => ptr->Format = value;
public VkDeviceSize Offset => ptr->Offset;
public void SetOffset(VkDeviceSize value) => ptr->Offset = value;
public VkDeviceSize Range => ptr->Range;
public void SetRange(VkDeviceSize value) => ptr->Range = value;
}
public unsafe partial struct VkCalibratedTimestampInfoEXT : IDisposable
{
//VkCalibratedTimestampInfoEXT
private VkCalibratedTimestampInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkCalibratedTimestampInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCalibratedTimestampInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCalibratedTimestampInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkCalibratedTimestampInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkTimeDomainEXT TimeDomain;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkTimeDomainEXT TimeDomain => ptr->TimeDomain;
public void SetTimeDomain(VkTimeDomainEXT value) => ptr->TimeDomain = value;
}
public unsafe partial struct VkCheckpointDataNV : IDisposable
{
//VkCheckpointDataNV
private VkCheckpointDataNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkCheckpointDataNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCheckpointDataNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCheckpointDataNV AsPtr() { fixed(Data* ptr = &this) return new VkCheckpointDataNV(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineStageFlagBits Stage;
public IntPtr PCheckpointMarker;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineStageFlagBits Stage => ptr->Stage;
public void SetStage(VkPipelineStageFlagBits value) => ptr->Stage = value;
public IntPtr PCheckpointMarker => ptr->PCheckpointMarker;
public void SetPCheckpointMarker(IntPtr value) => ptr->PCheckpointMarker = value;
}
public unsafe partial struct VkClearAttachment : IDisposable
{
//VkClearAttachment
private VkClearAttachment(Data* ptr)
{
this.ptr = ptr;
}
public static VkClearAttachment New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkClearAttachment(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkClearAttachment AsPtr() { fixed(Data* ptr = &this) return new VkClearAttachment(ptr); }
public VkImageAspectFlags AspectMask;
public uint ColorAttachment;
public VkClearValue ClearValue;
}
public VkImageAspectFlags AspectMask => ptr->AspectMask;
public void SetAspectMask(VkImageAspectFlags value) => ptr->AspectMask = value;
public uint ColorAttachment => ptr->ColorAttachment;
public void SetColorAttachment(uint value) => ptr->ColorAttachment = value;
public VkClearValue ClearValue => ptr->ClearValue;
public void SetClearValue(VkClearValue value) => ptr->ClearValue = value;
}
public unsafe partial struct VkClearDepthStencilValue
{
//VkClearDepthStencilValue
public float Depth;
public uint Stencil;
}
public unsafe partial struct VkClearRect : IDisposable
{
//VkClearRect
private VkClearRect(Data* ptr)
{
this.ptr = ptr;
}
public static VkClearRect New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkClearRect(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkClearRect AsPtr() { fixed(Data* ptr = &this) return new VkClearRect(ptr); }
public VkRect2D Rect;
public uint BaseArrayLayer;
public uint LayerCount;
}
public VkRect2D Rect => ptr->Rect;
public void SetRect(VkRect2D value) => ptr->Rect = value;
public uint BaseArrayLayer => ptr->BaseArrayLayer;
public void SetBaseArrayLayer(uint value) => ptr->BaseArrayLayer = value;
public uint LayerCount => ptr->LayerCount;
public void SetLayerCount(uint value) => ptr->LayerCount = value;
}
public unsafe partial struct VkCmdProcessCommandsInfoNVX : IDisposable
{
//VkCmdProcessCommandsInfoNVX
private VkCmdProcessCommandsInfoNVX(Data* ptr)
{
this.ptr = ptr;
}
public static VkCmdProcessCommandsInfoNVX New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCmdProcessCommandsInfoNVX(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCmdProcessCommandsInfoNVX AsPtr() { fixed(Data* ptr = &this) return new VkCmdProcessCommandsInfoNVX(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkObjectTableNVX ObjectTable;
public VkIndirectCommandsLayoutNVX IndirectCommandsLayout;
public uint IndirectCommandsTokenCount;
public VkIndirectCommandsTokenNVX PIndirectCommandsTokens;
public uint MaxSequencesCount;
public VkCommandBuffer TargetCommandBuffer;
public VkBuffer SequencesCountBuffer;
public VkDeviceSize SequencesCountOffset;
public VkBuffer SequencesIndexBuffer;
public VkDeviceSize SequencesIndexOffset;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkObjectTableNVX ObjectTable => ptr->ObjectTable;
public void SetObjectTable(VkObjectTableNVX value) => ptr->ObjectTable = value;
public VkIndirectCommandsLayoutNVX IndirectCommandsLayout => ptr->IndirectCommandsLayout;
public void SetIndirectCommandsLayout(VkIndirectCommandsLayoutNVX value) => ptr->IndirectCommandsLayout = value;
public uint IndirectCommandsTokenCount => ptr->IndirectCommandsTokenCount;
public void SetIndirectCommandsTokenCount(uint value) => ptr->IndirectCommandsTokenCount = value;
public VkIndirectCommandsTokenNVX PIndirectCommandsTokens => ptr->PIndirectCommandsTokens;
public void SetPIndirectCommandsTokens(VkIndirectCommandsTokenNVX value) => ptr->PIndirectCommandsTokens = value;
public uint MaxSequencesCount => ptr->MaxSequencesCount;
public void SetMaxSequencesCount(uint value) => ptr->MaxSequencesCount = value;
public VkCommandBuffer TargetCommandBuffer => ptr->TargetCommandBuffer;
public void SetTargetCommandBuffer(VkCommandBuffer value) => ptr->TargetCommandBuffer = value;
public VkBuffer SequencesCountBuffer => ptr->SequencesCountBuffer;
public void SetSequencesCountBuffer(VkBuffer value) => ptr->SequencesCountBuffer = value;
public VkDeviceSize SequencesCountOffset => ptr->SequencesCountOffset;
public void SetSequencesCountOffset(VkDeviceSize value) => ptr->SequencesCountOffset = value;
public VkBuffer SequencesIndexBuffer => ptr->SequencesIndexBuffer;
public void SetSequencesIndexBuffer(VkBuffer value) => ptr->SequencesIndexBuffer = value;
public VkDeviceSize SequencesIndexOffset => ptr->SequencesIndexOffset;
public void SetSequencesIndexOffset(VkDeviceSize value) => ptr->SequencesIndexOffset = value;
}
public unsafe partial struct VkCmdReserveSpaceForCommandsInfoNVX : IDisposable
{
//VkCmdReserveSpaceForCommandsInfoNVX
private VkCmdReserveSpaceForCommandsInfoNVX(Data* ptr)
{
this.ptr = ptr;
}
public static VkCmdReserveSpaceForCommandsInfoNVX New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCmdReserveSpaceForCommandsInfoNVX(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCmdReserveSpaceForCommandsInfoNVX AsPtr() { fixed(Data* ptr = &this) return new VkCmdReserveSpaceForCommandsInfoNVX(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkObjectTableNVX ObjectTable;
public VkIndirectCommandsLayoutNVX IndirectCommandsLayout;
public uint MaxSequencesCount;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkObjectTableNVX ObjectTable => ptr->ObjectTable;
public void SetObjectTable(VkObjectTableNVX value) => ptr->ObjectTable = value;
public VkIndirectCommandsLayoutNVX IndirectCommandsLayout => ptr->IndirectCommandsLayout;
public void SetIndirectCommandsLayout(VkIndirectCommandsLayoutNVX value) => ptr->IndirectCommandsLayout = value;
public uint MaxSequencesCount => ptr->MaxSequencesCount;
public void SetMaxSequencesCount(uint value) => ptr->MaxSequencesCount = value;
}
public unsafe partial struct VkCoarseSampleLocationNV : IDisposable
{
//VkCoarseSampleLocationNV
private VkCoarseSampleLocationNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkCoarseSampleLocationNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCoarseSampleLocationNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCoarseSampleLocationNV AsPtr() { fixed(Data* ptr = &this) return new VkCoarseSampleLocationNV(ptr); }
public uint PixelX;
public uint PixelY;
public uint Sample;
}
public uint PixelX => ptr->PixelX;
public void SetPixelX(uint value) => ptr->PixelX = value;
public uint PixelY => ptr->PixelY;
public void SetPixelY(uint value) => ptr->PixelY = value;
public uint Sample => ptr->Sample;
public void SetSample(uint value) => ptr->Sample = value;
}
public unsafe partial struct VkCoarseSampleOrderCustomNV : IDisposable
{
//VkCoarseSampleOrderCustomNV
private VkCoarseSampleOrderCustomNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkCoarseSampleOrderCustomNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCoarseSampleOrderCustomNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCoarseSampleOrderCustomNV AsPtr() { fixed(Data* ptr = &this) return new VkCoarseSampleOrderCustomNV(ptr); }
public VkShadingRatePaletteEntryNV ShadingRate;
public uint SampleCount;
public uint SampleLocationCount;
public VkCoarseSampleLocationNV PSampleLocations;
}
public VkShadingRatePaletteEntryNV ShadingRate => ptr->ShadingRate;
public void SetShadingRate(VkShadingRatePaletteEntryNV value) => ptr->ShadingRate = value;
public uint SampleCount => ptr->SampleCount;
public void SetSampleCount(uint value) => ptr->SampleCount = value;
public uint SampleLocationCount => ptr->SampleLocationCount;
public void SetSampleLocationCount(uint value) => ptr->SampleLocationCount = value;
public VkCoarseSampleLocationNV PSampleLocations => ptr->PSampleLocations;
public void SetPSampleLocations(VkCoarseSampleLocationNV value) => ptr->PSampleLocations = value;
}
public unsafe partial struct VkCommandBufferAllocateInfo : IDisposable
{
//VkCommandBufferAllocateInfo
private VkCommandBufferAllocateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkCommandBufferAllocateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCommandBufferAllocateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCommandBufferAllocateInfo AsPtr() { fixed(Data* ptr = &this) return new VkCommandBufferAllocateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkCommandPool CommandPool;
public VkCommandBufferLevel Level;
public uint CommandBufferCount;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkCommandPool CommandPool => ptr->CommandPool;
public void SetCommandPool(VkCommandPool value) => ptr->CommandPool = value;
public VkCommandBufferLevel Level => ptr->Level;
public void SetLevel(VkCommandBufferLevel value) => ptr->Level = value;
public uint CommandBufferCount => ptr->CommandBufferCount;
public void SetCommandBufferCount(uint value) => ptr->CommandBufferCount = value;
}
public unsafe partial struct VkCommandBufferBeginInfo : IDisposable
{
//VkCommandBufferBeginInfo
private VkCommandBufferBeginInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkCommandBufferBeginInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCommandBufferBeginInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCommandBufferBeginInfo AsPtr() { fixed(Data* ptr = &this) return new VkCommandBufferBeginInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkCommandBufferUsageFlags Flags;
public VkCommandBufferInheritanceInfo PInheritanceInfo;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkCommandBufferUsageFlags Flags => ptr->Flags;
public void SetFlags(VkCommandBufferUsageFlags value) => ptr->Flags = value;
public VkCommandBufferInheritanceInfo PInheritanceInfo => ptr->PInheritanceInfo;
public void SetPInheritanceInfo(VkCommandBufferInheritanceInfo value) => ptr->PInheritanceInfo = value;
}
public unsafe partial struct VkCommandBufferInheritanceInfo : IDisposable
{
//VkCommandBufferInheritanceInfo
private VkCommandBufferInheritanceInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkCommandBufferInheritanceInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCommandBufferInheritanceInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCommandBufferInheritanceInfo AsPtr() { fixed(Data* ptr = &this) return new VkCommandBufferInheritanceInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkRenderPass RenderPass;
public uint Subpass;
public VkFramebuffer Framebuffer;
public VkBool32 OcclusionQueryEnable;
public VkQueryControlFlags QueryFlags;
public VkQueryPipelineStatisticFlags PipelineStatistics;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkRenderPass RenderPass => ptr->RenderPass;
public void SetRenderPass(VkRenderPass value) => ptr->RenderPass = value;
public uint Subpass => ptr->Subpass;
public void SetSubpass(uint value) => ptr->Subpass = value;
public VkFramebuffer Framebuffer => ptr->Framebuffer;
public void SetFramebuffer(VkFramebuffer value) => ptr->Framebuffer = value;
public VkBool32 OcclusionQueryEnable => ptr->OcclusionQueryEnable;
public void SetOcclusionQueryEnable(VkBool32 value) => ptr->OcclusionQueryEnable = value;
public VkQueryControlFlags QueryFlags => ptr->QueryFlags;
public void SetQueryFlags(VkQueryControlFlags value) => ptr->QueryFlags = value;
public VkQueryPipelineStatisticFlags PipelineStatistics => ptr->PipelineStatistics;
public void SetPipelineStatistics(VkQueryPipelineStatisticFlags value) => ptr->PipelineStatistics = value;
}
public unsafe partial struct VkCommandPoolCreateInfo : IDisposable
{
//VkCommandPoolCreateInfo
private VkCommandPoolCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkCommandPoolCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCommandPoolCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCommandPoolCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkCommandPoolCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkCommandPoolCreateFlags Flags;
public uint QueueFamilyIndex;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkCommandPoolCreateFlags Flags => ptr->Flags;
public void SetFlags(VkCommandPoolCreateFlags value) => ptr->Flags = value;
public uint QueueFamilyIndex => ptr->QueueFamilyIndex;
public void SetQueueFamilyIndex(uint value) => ptr->QueueFamilyIndex = value;
}
public unsafe partial struct VkComponentMapping
{
//VkComponentMapping
public VkComponentSwizzle R;
public VkComponentSwizzle G;
public VkComponentSwizzle B;
public VkComponentSwizzle A;
}
public unsafe partial struct VkComputePipelineCreateInfo : IDisposable
{
//VkComputePipelineCreateInfo
private VkComputePipelineCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkComputePipelineCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkComputePipelineCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkComputePipelineCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkComputePipelineCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineCreateFlags Flags;
public VkPipelineShaderStageCreateInfo Stage;
public VkPipelineLayout Layout;
public VkPipeline BasePipelineHandle;
public int BasePipelineIndex;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineCreateFlags value) => ptr->Flags = value;
public VkPipelineShaderStageCreateInfo Stage => ptr->Stage;
public void SetStage(VkPipelineShaderStageCreateInfo value) => ptr->Stage = value;
public VkPipelineLayout Layout => ptr->Layout;
public void SetLayout(VkPipelineLayout value) => ptr->Layout = value;
public VkPipeline BasePipelineHandle => ptr->BasePipelineHandle;
public void SetBasePipelineHandle(VkPipeline value) => ptr->BasePipelineHandle = value;
public int BasePipelineIndex => ptr->BasePipelineIndex;
public void SetBasePipelineIndex(int value) => ptr->BasePipelineIndex = value;
}
public unsafe partial struct VkConditionalRenderingBeginInfoEXT : IDisposable
{
//VkConditionalRenderingBeginInfoEXT
private VkConditionalRenderingBeginInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkConditionalRenderingBeginInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkConditionalRenderingBeginInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkConditionalRenderingBeginInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkConditionalRenderingBeginInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkBuffer Buffer;
public VkDeviceSize Offset;
public VkConditionalRenderingFlagsEXT Flags;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkBuffer Buffer => ptr->Buffer;
public void SetBuffer(VkBuffer value) => ptr->Buffer = value;
public VkDeviceSize Offset => ptr->Offset;
public void SetOffset(VkDeviceSize value) => ptr->Offset = value;
public VkConditionalRenderingFlagsEXT Flags => ptr->Flags;
public void SetFlags(VkConditionalRenderingFlagsEXT value) => ptr->Flags = value;
}
public unsafe partial struct VkCopyDescriptorSet : IDisposable
{
//VkCopyDescriptorSet
private VkCopyDescriptorSet(Data* ptr)
{
this.ptr = ptr;
}
public static VkCopyDescriptorSet New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkCopyDescriptorSet(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkCopyDescriptorSet AsPtr() { fixed(Data* ptr = &this) return new VkCopyDescriptorSet(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDescriptorSet SrcSet;
public uint SrcBinding;
public uint SrcArrayElement;
public VkDescriptorSet DstSet;
public uint DstBinding;
public uint DstArrayElement;
public uint DescriptorCount;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDescriptorSet SrcSet => ptr->SrcSet;
public void SetSrcSet(VkDescriptorSet value) => ptr->SrcSet = value;
public uint SrcBinding => ptr->SrcBinding;
public void SetSrcBinding(uint value) => ptr->SrcBinding = value;
public uint SrcArrayElement => ptr->SrcArrayElement;
public void SetSrcArrayElement(uint value) => ptr->SrcArrayElement = value;
public VkDescriptorSet DstSet => ptr->DstSet;
public void SetDstSet(VkDescriptorSet value) => ptr->DstSet = value;
public uint DstBinding => ptr->DstBinding;
public void SetDstBinding(uint value) => ptr->DstBinding = value;
public uint DstArrayElement => ptr->DstArrayElement;
public void SetDstArrayElement(uint value) => ptr->DstArrayElement = value;
public uint DescriptorCount => ptr->DescriptorCount;
public void SetDescriptorCount(uint value) => ptr->DescriptorCount = value;
}
public unsafe partial struct VkDebugMarkerMarkerInfoEXT : IDisposable
{
//VkDebugMarkerMarkerInfoEXT
private VkDebugMarkerMarkerInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDebugMarkerMarkerInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDebugMarkerMarkerInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDebugMarkerMarkerInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDebugMarkerMarkerInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public CString PMarkerName;
public Float4 Color;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public CString PMarkerName => ptr->PMarkerName;
public void SetPMarkerName(CString value) => ptr->PMarkerName = value;
public Float4 Color => ptr->Color;
}
public unsafe partial struct VkDebugMarkerObjectNameInfoEXT : IDisposable
{
//VkDebugMarkerObjectNameInfoEXT
private VkDebugMarkerObjectNameInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDebugMarkerObjectNameInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDebugMarkerObjectNameInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDebugMarkerObjectNameInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDebugMarkerObjectNameInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDebugReportObjectTypeEXT ObjectType;
public ulong Object;
public CString PObjectName;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDebugReportObjectTypeEXT ObjectType => ptr->ObjectType;
public void SetObjectType(VkDebugReportObjectTypeEXT value) => ptr->ObjectType = value;
public ulong Object => ptr->Object;
public void SetObject(ulong value) => ptr->Object = value;
public CString PObjectName => ptr->PObjectName;
public void SetPObjectName(CString value) => ptr->PObjectName = value;
}
public unsafe partial struct VkDebugMarkerObjectTagInfoEXT : IDisposable
{
//VkDebugMarkerObjectTagInfoEXT
private VkDebugMarkerObjectTagInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDebugMarkerObjectTagInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDebugMarkerObjectTagInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDebugMarkerObjectTagInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDebugMarkerObjectTagInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDebugReportObjectTypeEXT ObjectType;
public ulong Object;
public ulong TagName;
public UIntPtr TagSize;
public IntPtr PTag;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDebugReportObjectTypeEXT ObjectType => ptr->ObjectType;
public void SetObjectType(VkDebugReportObjectTypeEXT value) => ptr->ObjectType = value;
public ulong Object => ptr->Object;
public void SetObject(ulong value) => ptr->Object = value;
public ulong TagName => ptr->TagName;
public void SetTagName(ulong value) => ptr->TagName = value;
public UIntPtr TagSize => ptr->TagSize;
public void SetTagSize(UIntPtr value) => ptr->TagSize = value;
public IntPtr PTag => ptr->PTag;
public void SetPTag(IntPtr value) => ptr->PTag = value;
}
public unsafe partial struct VkDebugReportCallbackCreateInfoEXT : IDisposable
{
//VkDebugReportCallbackCreateInfoEXT
private VkDebugReportCallbackCreateInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDebugReportCallbackCreateInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDebugReportCallbackCreateInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDebugReportCallbackCreateInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDebugReportCallbackCreateInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDebugReportFlagsEXT Flags;
internal IntPtr _PfnCallback;
public void SetPfnCallback(PFNVkDebugReportCallbackEXTDelegate value) => _PfnCallback = Marshal.GetFunctionPointerForDelegate(value);
public IntPtr PUserData;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDebugReportFlagsEXT Flags => ptr->Flags;
public void SetFlags(VkDebugReportFlagsEXT value) => ptr->Flags = value;
public PFNVkDebugReportCallbackEXTDelegate PfnCallback => Marshal.GetDelegateForFunctionPointer<PFNVkDebugReportCallbackEXTDelegate>(ptr->_PfnCallback);
public void SetPfnCallback(PFNVkDebugReportCallbackEXTDelegate value) => ptr->_PfnCallback = Marshal.GetFunctionPointerForDelegate(value);
public IntPtr PUserData => ptr->PUserData;
public void SetPUserData(IntPtr value) => ptr->PUserData = value;
}
public unsafe partial struct VkDebugUtilsLabelEXT : IDisposable
{
//VkDebugUtilsLabelEXT
private VkDebugUtilsLabelEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDebugUtilsLabelEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDebugUtilsLabelEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDebugUtilsLabelEXT AsPtr() { fixed(Data* ptr = &this) return new VkDebugUtilsLabelEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public CString PLabelName;
public Float4 Color;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public CString PLabelName => ptr->PLabelName;
public void SetPLabelName(CString value) => ptr->PLabelName = value;
public Float4 Color => ptr->Color;
}
public unsafe partial struct VkDebugUtilsMessengerCallbackDataEXT : IDisposable
{
//VkDebugUtilsMessengerCallbackDataEXT
private VkDebugUtilsMessengerCallbackDataEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDebugUtilsMessengerCallbackDataEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDebugUtilsMessengerCallbackDataEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDebugUtilsMessengerCallbackDataEXT AsPtr() { fixed(Data* ptr = &this) return new VkDebugUtilsMessengerCallbackDataEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDebugUtilsMessengerCallbackDataFlagsEXT Flags;
public CString PMessageIdName;
public int MessageIdNumber;
public CString PMessage;
public uint QueueLabelCount;
public VkDebugUtilsLabelEXT PQueueLabels;
public uint CmdBufLabelCount;
public VkDebugUtilsLabelEXT PCmdBufLabels;
public uint ObjectCount;
public VkDebugUtilsObjectNameInfoEXT PObjects;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDebugUtilsMessengerCallbackDataFlagsEXT Flags => ptr->Flags;
public void SetFlags(VkDebugUtilsMessengerCallbackDataFlagsEXT value) => ptr->Flags = value;
public CString PMessageIdName => ptr->PMessageIdName;
public void SetPMessageIdName(CString value) => ptr->PMessageIdName = value;
public int MessageIdNumber => ptr->MessageIdNumber;
public void SetMessageIdNumber(int value) => ptr->MessageIdNumber = value;
public CString PMessage => ptr->PMessage;
public void SetPMessage(CString value) => ptr->PMessage = value;
public uint QueueLabelCount => ptr->QueueLabelCount;
public void SetQueueLabelCount(uint value) => ptr->QueueLabelCount = value;
public VkDebugUtilsLabelEXT PQueueLabels => ptr->PQueueLabels;
public void SetPQueueLabels(VkDebugUtilsLabelEXT value) => ptr->PQueueLabels = value;
public uint CmdBufLabelCount => ptr->CmdBufLabelCount;
public void SetCmdBufLabelCount(uint value) => ptr->CmdBufLabelCount = value;
public VkDebugUtilsLabelEXT PCmdBufLabels => ptr->PCmdBufLabels;
public void SetPCmdBufLabels(VkDebugUtilsLabelEXT value) => ptr->PCmdBufLabels = value;
public uint ObjectCount => ptr->ObjectCount;
public void SetObjectCount(uint value) => ptr->ObjectCount = value;
public VkDebugUtilsObjectNameInfoEXT PObjects => ptr->PObjects;
public void SetPObjects(VkDebugUtilsObjectNameInfoEXT value) => ptr->PObjects = value;
}
public unsafe partial struct VkDebugUtilsMessengerCreateInfoEXT : IDisposable
{
//VkDebugUtilsMessengerCreateInfoEXT
private VkDebugUtilsMessengerCreateInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDebugUtilsMessengerCreateInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDebugUtilsMessengerCreateInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDebugUtilsMessengerCreateInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDebugUtilsMessengerCreateInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDebugUtilsMessengerCreateFlagsEXT Flags;
public VkDebugUtilsMessageSeverityFlagsEXT MessageSeverity;
public VkDebugUtilsMessageTypeFlagsEXT MessageType;
internal IntPtr _PfnUserCallback;
public void SetPfnUserCallback(PFNVkDebugUtilsMessengerCallbackEXTDelegate value) => _PfnUserCallback = Marshal.GetFunctionPointerForDelegate(value);
public IntPtr PUserData;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDebugUtilsMessengerCreateFlagsEXT Flags => ptr->Flags;
public void SetFlags(VkDebugUtilsMessengerCreateFlagsEXT value) => ptr->Flags = value;
public VkDebugUtilsMessageSeverityFlagsEXT MessageSeverity => ptr->MessageSeverity;
public void SetMessageSeverity(VkDebugUtilsMessageSeverityFlagsEXT value) => ptr->MessageSeverity = value;
public VkDebugUtilsMessageTypeFlagsEXT MessageType => ptr->MessageType;
public void SetMessageType(VkDebugUtilsMessageTypeFlagsEXT value) => ptr->MessageType = value;
public PFNVkDebugUtilsMessengerCallbackEXTDelegate PfnUserCallback => Marshal.GetDelegateForFunctionPointer<PFNVkDebugUtilsMessengerCallbackEXTDelegate>(ptr->_PfnUserCallback);
public void SetPfnUserCallback(PFNVkDebugUtilsMessengerCallbackEXTDelegate value) => ptr->_PfnUserCallback = Marshal.GetFunctionPointerForDelegate(value);
public IntPtr PUserData => ptr->PUserData;
public void SetPUserData(IntPtr value) => ptr->PUserData = value;
}
public unsafe partial struct VkDebugUtilsObjectNameInfoEXT : IDisposable
{
//VkDebugUtilsObjectNameInfoEXT
private VkDebugUtilsObjectNameInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDebugUtilsObjectNameInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDebugUtilsObjectNameInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDebugUtilsObjectNameInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDebugUtilsObjectNameInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkObjectType ObjectType;
public ulong ObjectHandle;
public CString PObjectName;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkObjectType ObjectType => ptr->ObjectType;
public void SetObjectType(VkObjectType value) => ptr->ObjectType = value;
public ulong ObjectHandle => ptr->ObjectHandle;
public void SetObjectHandle(ulong value) => ptr->ObjectHandle = value;
public CString PObjectName => ptr->PObjectName;
public void SetPObjectName(CString value) => ptr->PObjectName = value;
}
public unsafe partial struct VkDebugUtilsObjectTagInfoEXT : IDisposable
{
//VkDebugUtilsObjectTagInfoEXT
private VkDebugUtilsObjectTagInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDebugUtilsObjectTagInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDebugUtilsObjectTagInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDebugUtilsObjectTagInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDebugUtilsObjectTagInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkObjectType ObjectType;
public ulong ObjectHandle;
public ulong TagName;
public UIntPtr TagSize;
public IntPtr PTag;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkObjectType ObjectType => ptr->ObjectType;
public void SetObjectType(VkObjectType value) => ptr->ObjectType = value;
public ulong ObjectHandle => ptr->ObjectHandle;
public void SetObjectHandle(ulong value) => ptr->ObjectHandle = value;
public ulong TagName => ptr->TagName;
public void SetTagName(ulong value) => ptr->TagName = value;
public UIntPtr TagSize => ptr->TagSize;
public void SetTagSize(UIntPtr value) => ptr->TagSize = value;
public IntPtr PTag => ptr->PTag;
public void SetPTag(IntPtr value) => ptr->PTag = value;
}
public unsafe partial struct VkDescriptorBufferInfo : IDisposable
{
//VkDescriptorBufferInfo
private VkDescriptorBufferInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorBufferInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorBufferInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorBufferInfo AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorBufferInfo(ptr); }
public VkBuffer Buffer;
public VkDeviceSize Offset;
public VkDeviceSize Range;
}
public VkBuffer Buffer => ptr->Buffer;
public void SetBuffer(VkBuffer value) => ptr->Buffer = value;
public VkDeviceSize Offset => ptr->Offset;
public void SetOffset(VkDeviceSize value) => ptr->Offset = value;
public VkDeviceSize Range => ptr->Range;
public void SetRange(VkDeviceSize value) => ptr->Range = value;
}
public unsafe partial struct VkDescriptorImageInfo : IDisposable
{
//VkDescriptorImageInfo
private VkDescriptorImageInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorImageInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorImageInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorImageInfo AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorImageInfo(ptr); }
public VkSampler Sampler;
public VkImageView ImageView;
public VkImageLayout ImageLayout;
}
public VkSampler Sampler => ptr->Sampler;
public void SetSampler(VkSampler value) => ptr->Sampler = value;
public VkImageView ImageView => ptr->ImageView;
public void SetImageView(VkImageView value) => ptr->ImageView = value;
public VkImageLayout ImageLayout => ptr->ImageLayout;
public void SetImageLayout(VkImageLayout value) => ptr->ImageLayout = value;
}
public unsafe partial struct VkDescriptorPoolCreateInfo : IDisposable
{
//VkDescriptorPoolCreateInfo
private VkDescriptorPoolCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorPoolCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorPoolCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorPoolCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorPoolCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDescriptorPoolCreateFlags Flags;
public uint MaxSets;
public uint PoolSizeCount;
public VkDescriptorPoolSize PPoolSizes;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDescriptorPoolCreateFlags Flags => ptr->Flags;
public void SetFlags(VkDescriptorPoolCreateFlags value) => ptr->Flags = value;
public uint MaxSets => ptr->MaxSets;
public void SetMaxSets(uint value) => ptr->MaxSets = value;
public uint PoolSizeCount => ptr->PoolSizeCount;
public void SetPoolSizeCount(uint value) => ptr->PoolSizeCount = value;
public VkDescriptorPoolSize PPoolSizes => ptr->PPoolSizes;
public void SetPPoolSizes(VkDescriptorPoolSize value) => ptr->PPoolSizes = value;
}
public unsafe partial struct VkDescriptorPoolSize : IDisposable
{
//VkDescriptorPoolSize
private VkDescriptorPoolSize(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorPoolSize New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorPoolSize(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorPoolSize AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorPoolSize(ptr); }
public VkDescriptorType Type;
public uint DescriptorCount;
}
public VkDescriptorType Type => ptr->Type;
public void SetType(VkDescriptorType value) => ptr->Type = value;
public uint DescriptorCount => ptr->DescriptorCount;
public void SetDescriptorCount(uint value) => ptr->DescriptorCount = value;
}
public unsafe partial struct VkDescriptorSetAllocateInfo : IDisposable
{
//VkDescriptorSetAllocateInfo
private VkDescriptorSetAllocateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorSetAllocateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorSetAllocateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorSetAllocateInfo AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorSetAllocateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDescriptorPool DescriptorPool;
public uint DescriptorSetCount;
public VkDescriptorSetLayout* PSetLayouts;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDescriptorPool DescriptorPool => ptr->DescriptorPool;
public void SetDescriptorPool(VkDescriptorPool value) => ptr->DescriptorPool = value;
public uint DescriptorSetCount => ptr->DescriptorSetCount;
public void SetDescriptorSetCount(uint value) => ptr->DescriptorSetCount = value;
public VkDescriptorSetLayout* PSetLayouts => ptr->PSetLayouts;
public void SetPSetLayouts(VkDescriptorSetLayout* value) => ptr->PSetLayouts = value;
}
public unsafe partial struct VkDescriptorSetLayoutBinding : IDisposable
{
//VkDescriptorSetLayoutBinding
private VkDescriptorSetLayoutBinding(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorSetLayoutBinding New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorSetLayoutBinding(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorSetLayoutBinding AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorSetLayoutBinding(ptr); }
public uint Binding;
public VkDescriptorType DescriptorType;
public uint DescriptorCount;
public VkShaderStageFlags StageFlags;
public VkSampler* PImmutableSamplers;
}
public uint Binding => ptr->Binding;
public void SetBinding(uint value) => ptr->Binding = value;
public VkDescriptorType DescriptorType => ptr->DescriptorType;
public void SetDescriptorType(VkDescriptorType value) => ptr->DescriptorType = value;
public uint DescriptorCount => ptr->DescriptorCount;
public void SetDescriptorCount(uint value) => ptr->DescriptorCount = value;
public VkShaderStageFlags StageFlags => ptr->StageFlags;
public void SetStageFlags(VkShaderStageFlags value) => ptr->StageFlags = value;
public VkSampler* PImmutableSamplers => ptr->PImmutableSamplers;
public void SetPImmutableSamplers(VkSampler* value) => ptr->PImmutableSamplers = value;
}
public unsafe partial struct VkDescriptorSetLayoutCreateInfo : IDisposable
{
//VkDescriptorSetLayoutCreateInfo
private VkDescriptorSetLayoutCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorSetLayoutCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorSetLayoutCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorSetLayoutCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorSetLayoutCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDescriptorSetLayoutCreateFlags Flags;
public uint BindingCount;
public VkDescriptorSetLayoutBinding PBindings;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDescriptorSetLayoutCreateFlags Flags => ptr->Flags;
public void SetFlags(VkDescriptorSetLayoutCreateFlags value) => ptr->Flags = value;
public uint BindingCount => ptr->BindingCount;
public void SetBindingCount(uint value) => ptr->BindingCount = value;
public VkDescriptorSetLayoutBinding PBindings => ptr->PBindings;
public void SetPBindings(VkDescriptorSetLayoutBinding value) => ptr->PBindings = value;
}
public unsafe partial struct VkDescriptorSetLayoutSupport : IDisposable
{
//VkDescriptorSetLayoutSupport
private VkDescriptorSetLayoutSupport(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorSetLayoutSupport New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorSetLayoutSupport(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorSetLayoutSupport AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorSetLayoutSupport(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkBool32 Supported;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkBool32 Supported => ptr->Supported;
public void SetSupported(VkBool32 value) => ptr->Supported = value;
}
public unsafe partial struct VkDescriptorUpdateTemplateCreateInfo : IDisposable
{
//VkDescriptorUpdateTemplateCreateInfo
private VkDescriptorUpdateTemplateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorUpdateTemplateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorUpdateTemplateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorUpdateTemplateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorUpdateTemplateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDescriptorUpdateTemplateCreateFlags Flags;
public uint DescriptorUpdateEntryCount;
public VkDescriptorUpdateTemplateEntry PDescriptorUpdateEntries;
public VkDescriptorUpdateTemplateType TemplateType;
public VkDescriptorSetLayout DescriptorSetLayout;
public VkPipelineBindPoint PipelineBindPoint;
public VkPipelineLayout PipelineLayout;
public uint Set;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDescriptorUpdateTemplateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkDescriptorUpdateTemplateCreateFlags value) => ptr->Flags = value;
public uint DescriptorUpdateEntryCount => ptr->DescriptorUpdateEntryCount;
public void SetDescriptorUpdateEntryCount(uint value) => ptr->DescriptorUpdateEntryCount = value;
public VkDescriptorUpdateTemplateEntry PDescriptorUpdateEntries => ptr->PDescriptorUpdateEntries;
public void SetPDescriptorUpdateEntries(VkDescriptorUpdateTemplateEntry value) => ptr->PDescriptorUpdateEntries = value;
public VkDescriptorUpdateTemplateType TemplateType => ptr->TemplateType;
public void SetTemplateType(VkDescriptorUpdateTemplateType value) => ptr->TemplateType = value;
public VkDescriptorSetLayout DescriptorSetLayout => ptr->DescriptorSetLayout;
public void SetDescriptorSetLayout(VkDescriptorSetLayout value) => ptr->DescriptorSetLayout = value;
public VkPipelineBindPoint PipelineBindPoint => ptr->PipelineBindPoint;
public void SetPipelineBindPoint(VkPipelineBindPoint value) => ptr->PipelineBindPoint = value;
public VkPipelineLayout PipelineLayout => ptr->PipelineLayout;
public void SetPipelineLayout(VkPipelineLayout value) => ptr->PipelineLayout = value;
public uint Set => ptr->Set;
public void SetSet(uint value) => ptr->Set = value;
}
public unsafe partial struct VkDescriptorUpdateTemplateEntry : IDisposable
{
//VkDescriptorUpdateTemplateEntry
private VkDescriptorUpdateTemplateEntry(Data* ptr)
{
this.ptr = ptr;
}
public static VkDescriptorUpdateTemplateEntry New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDescriptorUpdateTemplateEntry(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDescriptorUpdateTemplateEntry AsPtr() { fixed(Data* ptr = &this) return new VkDescriptorUpdateTemplateEntry(ptr); }
public uint DstBinding;
public uint DstArrayElement;
public uint DescriptorCount;
public VkDescriptorType DescriptorType;
public UIntPtr Offset;
public UIntPtr Stride;
}
public uint DstBinding => ptr->DstBinding;
public void SetDstBinding(uint value) => ptr->DstBinding = value;
public uint DstArrayElement => ptr->DstArrayElement;
public void SetDstArrayElement(uint value) => ptr->DstArrayElement = value;
public uint DescriptorCount => ptr->DescriptorCount;
public void SetDescriptorCount(uint value) => ptr->DescriptorCount = value;
public VkDescriptorType DescriptorType => ptr->DescriptorType;
public void SetDescriptorType(VkDescriptorType value) => ptr->DescriptorType = value;
public UIntPtr Offset => ptr->Offset;
public void SetOffset(UIntPtr value) => ptr->Offset = value;
public UIntPtr Stride => ptr->Stride;
public void SetStride(UIntPtr value) => ptr->Stride = value;
}
public unsafe partial struct VkDeviceCreateInfo : IDisposable
{
//VkDeviceCreateInfo
private VkDeviceCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkDeviceCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDeviceCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDeviceCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkDeviceCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDeviceCreateFlags Flags;
public uint QueueCreateInfoCount;
public VkDeviceQueueCreateInfo PQueueCreateInfos;
public uint EnabledLayerCount;
public byte** PpEnabledLayerNames;
public uint EnabledExtensionCount;
public byte** PpEnabledExtensionNames;
public VkPhysicalDeviceFeatures* PEnabledFeatures;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDeviceCreateFlags Flags => ptr->Flags;
public void SetFlags(VkDeviceCreateFlags value) => ptr->Flags = value;
public uint QueueCreateInfoCount => ptr->QueueCreateInfoCount;
public void SetQueueCreateInfoCount(uint value) => ptr->QueueCreateInfoCount = value;
public VkDeviceQueueCreateInfo PQueueCreateInfos => ptr->PQueueCreateInfos;
public void SetPQueueCreateInfos(VkDeviceQueueCreateInfo value) => ptr->PQueueCreateInfos = value;
public uint EnabledLayerCount => ptr->EnabledLayerCount;
public void SetEnabledLayerCount(uint value) => ptr->EnabledLayerCount = value;
public byte** PpEnabledLayerNames => ptr->PpEnabledLayerNames;
public void SetPpEnabledLayerNames(byte** value) => ptr->PpEnabledLayerNames = value;
public uint EnabledExtensionCount => ptr->EnabledExtensionCount;
public void SetEnabledExtensionCount(uint value) => ptr->EnabledExtensionCount = value;
public byte** PpEnabledExtensionNames => ptr->PpEnabledExtensionNames;
public void SetPpEnabledExtensionNames(byte** value) => ptr->PpEnabledExtensionNames = value;
public VkPhysicalDeviceFeatures* PEnabledFeatures => ptr->PEnabledFeatures;
public void SetPEnabledFeatures(VkPhysicalDeviceFeatures* value) => ptr->PEnabledFeatures = value;
}
public unsafe partial struct VkDeviceEventInfoEXT : IDisposable
{
//VkDeviceEventInfoEXT
private VkDeviceEventInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDeviceEventInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDeviceEventInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDeviceEventInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDeviceEventInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDeviceEventTypeEXT DeviceEvent;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDeviceEventTypeEXT DeviceEvent => ptr->DeviceEvent;
public void SetDeviceEvent(VkDeviceEventTypeEXT value) => ptr->DeviceEvent = value;
}
public unsafe partial struct VkDeviceGeneratedCommandsFeaturesNVX : IDisposable
{
//VkDeviceGeneratedCommandsFeaturesNVX
private VkDeviceGeneratedCommandsFeaturesNVX(Data* ptr)
{
this.ptr = ptr;
}
public static VkDeviceGeneratedCommandsFeaturesNVX New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDeviceGeneratedCommandsFeaturesNVX(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDeviceGeneratedCommandsFeaturesNVX AsPtr() { fixed(Data* ptr = &this) return new VkDeviceGeneratedCommandsFeaturesNVX(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkBool32 ComputeBindingPointSupport;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkBool32 ComputeBindingPointSupport => ptr->ComputeBindingPointSupport;
public void SetComputeBindingPointSupport(VkBool32 value) => ptr->ComputeBindingPointSupport = value;
}
public unsafe partial struct VkDeviceGeneratedCommandsLimitsNVX : IDisposable
{
//VkDeviceGeneratedCommandsLimitsNVX
private VkDeviceGeneratedCommandsLimitsNVX(Data* ptr)
{
this.ptr = ptr;
}
public static VkDeviceGeneratedCommandsLimitsNVX New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDeviceGeneratedCommandsLimitsNVX(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDeviceGeneratedCommandsLimitsNVX AsPtr() { fixed(Data* ptr = &this) return new VkDeviceGeneratedCommandsLimitsNVX(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint MaxIndirectCommandsLayoutTokenCount;
public uint MaxObjectEntryCounts;
public uint MinSequenceCountBufferOffsetAlignment;
public uint MinSequenceIndexBufferOffsetAlignment;
public uint MinCommandsTokenBufferOffsetAlignment;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint MaxIndirectCommandsLayoutTokenCount => ptr->MaxIndirectCommandsLayoutTokenCount;
public void SetMaxIndirectCommandsLayoutTokenCount(uint value) => ptr->MaxIndirectCommandsLayoutTokenCount = value;
public uint MaxObjectEntryCounts => ptr->MaxObjectEntryCounts;
public void SetMaxObjectEntryCounts(uint value) => ptr->MaxObjectEntryCounts = value;
public uint MinSequenceCountBufferOffsetAlignment => ptr->MinSequenceCountBufferOffsetAlignment;
public void SetMinSequenceCountBufferOffsetAlignment(uint value) => ptr->MinSequenceCountBufferOffsetAlignment = value;
public uint MinSequenceIndexBufferOffsetAlignment => ptr->MinSequenceIndexBufferOffsetAlignment;
public void SetMinSequenceIndexBufferOffsetAlignment(uint value) => ptr->MinSequenceIndexBufferOffsetAlignment = value;
public uint MinCommandsTokenBufferOffsetAlignment => ptr->MinCommandsTokenBufferOffsetAlignment;
public void SetMinCommandsTokenBufferOffsetAlignment(uint value) => ptr->MinCommandsTokenBufferOffsetAlignment = value;
}
public unsafe partial struct VkDeviceGroupPresentCapabilitiesKHR : IDisposable
{
//VkDeviceGroupPresentCapabilitiesKHR
private VkDeviceGroupPresentCapabilitiesKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkDeviceGroupPresentCapabilitiesKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDeviceGroupPresentCapabilitiesKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDeviceGroupPresentCapabilitiesKHR AsPtr() { fixed(Data* ptr = &this) return new VkDeviceGroupPresentCapabilitiesKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public fixed uint PresentMask[32];
public VkDeviceGroupPresentModeFlagsKHR Modes;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDeviceGroupPresentModeFlagsKHR Modes => ptr->Modes;
public void SetModes(VkDeviceGroupPresentModeFlagsKHR value) => ptr->Modes = value;
}
public unsafe partial struct VkDeviceQueueCreateInfo : IDisposable
{
//VkDeviceQueueCreateInfo
private VkDeviceQueueCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkDeviceQueueCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDeviceQueueCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDeviceQueueCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkDeviceQueueCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDeviceQueueCreateFlags Flags;
public uint QueueFamilyIndex;
public uint QueueCount;
public float* PQueuePriorities;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDeviceQueueCreateFlags Flags => ptr->Flags;
public void SetFlags(VkDeviceQueueCreateFlags value) => ptr->Flags = value;
public uint QueueFamilyIndex => ptr->QueueFamilyIndex;
public void SetQueueFamilyIndex(uint value) => ptr->QueueFamilyIndex = value;
public uint QueueCount => ptr->QueueCount;
public void SetQueueCount(uint value) => ptr->QueueCount = value;
public float* PQueuePriorities => ptr->PQueuePriorities;
public void SetPQueuePriorities(float* value) => ptr->PQueuePriorities = value;
}
public unsafe partial struct VkDeviceQueueInfo2 : IDisposable
{
//VkDeviceQueueInfo2
private VkDeviceQueueInfo2(Data* ptr)
{
this.ptr = ptr;
}
public static VkDeviceQueueInfo2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDeviceQueueInfo2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDeviceQueueInfo2 AsPtr() { fixed(Data* ptr = &this) return new VkDeviceQueueInfo2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDeviceQueueCreateFlags Flags;
public uint QueueFamilyIndex;
public uint QueueIndex;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDeviceQueueCreateFlags Flags => ptr->Flags;
public void SetFlags(VkDeviceQueueCreateFlags value) => ptr->Flags = value;
public uint QueueFamilyIndex => ptr->QueueFamilyIndex;
public void SetQueueFamilyIndex(uint value) => ptr->QueueFamilyIndex = value;
public uint QueueIndex => ptr->QueueIndex;
public void SetQueueIndex(uint value) => ptr->QueueIndex = value;
}
public unsafe partial struct VkDisplayEventInfoEXT : IDisposable
{
//VkDisplayEventInfoEXT
private VkDisplayEventInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDisplayEventInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDisplayEventInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDisplayEventInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDisplayEventInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDisplayEventTypeEXT DisplayEvent;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDisplayEventTypeEXT DisplayEvent => ptr->DisplayEvent;
public void SetDisplayEvent(VkDisplayEventTypeEXT value) => ptr->DisplayEvent = value;
}
public unsafe partial struct VkDisplayModeCreateInfoKHR : IDisposable
{
//VkDisplayModeCreateInfoKHR
private VkDisplayModeCreateInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkDisplayModeCreateInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDisplayModeCreateInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDisplayModeCreateInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkDisplayModeCreateInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDisplayModeCreateFlagsKHR Flags;
public VkDisplayModeParametersKHR Parameters;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDisplayModeCreateFlagsKHR Flags => ptr->Flags;
public void SetFlags(VkDisplayModeCreateFlagsKHR value) => ptr->Flags = value;
public VkDisplayModeParametersKHR Parameters => ptr->Parameters;
public void SetParameters(VkDisplayModeParametersKHR value) => ptr->Parameters = value;
}
public unsafe partial struct VkDisplayModeParametersKHR
{
//VkDisplayModeParametersKHR
public VkExtent2D VisibleRegion;
public uint RefreshRate;
}
public unsafe partial struct VkDisplayModeProperties2KHR : IDisposable
{
//VkDisplayModeProperties2KHR
private VkDisplayModeProperties2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkDisplayModeProperties2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDisplayModeProperties2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDisplayModeProperties2KHR AsPtr() { fixed(Data* ptr = &this) return new VkDisplayModeProperties2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDisplayModePropertiesKHR DisplayModeProperties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDisplayModePropertiesKHR DisplayModeProperties => ptr->DisplayModeProperties;
public void SetDisplayModeProperties(VkDisplayModePropertiesKHR value) => ptr->DisplayModeProperties = value;
}
public unsafe partial struct VkDisplayModePropertiesKHR
{
//VkDisplayModePropertiesKHR
public VkDisplayModeKHR DisplayMode;
public VkDisplayModeParametersKHR Parameters;
}
public unsafe partial struct VkDisplayPlaneCapabilities2KHR : IDisposable
{
//VkDisplayPlaneCapabilities2KHR
private VkDisplayPlaneCapabilities2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkDisplayPlaneCapabilities2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDisplayPlaneCapabilities2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDisplayPlaneCapabilities2KHR AsPtr() { fixed(Data* ptr = &this) return new VkDisplayPlaneCapabilities2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDisplayPlaneCapabilitiesKHR Capabilities;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDisplayPlaneCapabilitiesKHR Capabilities => ptr->Capabilities;
public void SetCapabilities(VkDisplayPlaneCapabilitiesKHR value) => ptr->Capabilities = value;
}
public unsafe partial struct VkDisplayPlaneCapabilitiesKHR
{
//VkDisplayPlaneCapabilitiesKHR
public VkDisplayPlaneAlphaFlagsKHR SupportedAlpha;
public VkOffset2D MinSrcPosition;
public VkOffset2D MaxSrcPosition;
public VkExtent2D MinSrcExtent;
public VkExtent2D MaxSrcExtent;
public VkOffset2D MinDstPosition;
public VkOffset2D MaxDstPosition;
public VkExtent2D MinDstExtent;
public VkExtent2D MaxDstExtent;
}
public unsafe partial struct VkDisplayPlaneInfo2KHR : IDisposable
{
//VkDisplayPlaneInfo2KHR
private VkDisplayPlaneInfo2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkDisplayPlaneInfo2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDisplayPlaneInfo2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDisplayPlaneInfo2KHR AsPtr() { fixed(Data* ptr = &this) return new VkDisplayPlaneInfo2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDisplayModeKHR Mode;
public uint PlaneIndex;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDisplayModeKHR Mode => ptr->Mode;
public void SetMode(VkDisplayModeKHR value) => ptr->Mode = value;
public uint PlaneIndex => ptr->PlaneIndex;
public void SetPlaneIndex(uint value) => ptr->PlaneIndex = value;
}
public unsafe partial struct VkDisplayPlaneProperties2KHR : IDisposable
{
//VkDisplayPlaneProperties2KHR
private VkDisplayPlaneProperties2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkDisplayPlaneProperties2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDisplayPlaneProperties2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDisplayPlaneProperties2KHR AsPtr() { fixed(Data* ptr = &this) return new VkDisplayPlaneProperties2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDisplayPlanePropertiesKHR DisplayPlaneProperties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDisplayPlanePropertiesKHR DisplayPlaneProperties => ptr->DisplayPlaneProperties;
public void SetDisplayPlaneProperties(VkDisplayPlanePropertiesKHR value) => ptr->DisplayPlaneProperties = value;
}
public unsafe partial struct VkDisplayPlanePropertiesKHR
{
//VkDisplayPlanePropertiesKHR
public VkDisplayKHR CurrentDisplay;
public uint CurrentStackIndex;
}
public unsafe partial struct VkDisplayPowerInfoEXT : IDisposable
{
//VkDisplayPowerInfoEXT
private VkDisplayPowerInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkDisplayPowerInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDisplayPowerInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDisplayPowerInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkDisplayPowerInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDisplayPowerStateEXT PowerState;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDisplayPowerStateEXT PowerState => ptr->PowerState;
public void SetPowerState(VkDisplayPowerStateEXT value) => ptr->PowerState = value;
}
public unsafe partial struct VkDisplayProperties2KHR : IDisposable
{
//VkDisplayProperties2KHR
private VkDisplayProperties2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkDisplayProperties2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDisplayProperties2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDisplayProperties2KHR AsPtr() { fixed(Data* ptr = &this) return new VkDisplayProperties2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDisplayPropertiesKHR DisplayProperties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDisplayPropertiesKHR DisplayProperties => ptr->DisplayProperties;
public void SetDisplayProperties(VkDisplayPropertiesKHR value) => ptr->DisplayProperties = value;
}
public unsafe partial struct VkDisplayPropertiesKHR
{
//VkDisplayPropertiesKHR
public VkDisplayKHR Display;
public CString DisplayName;
public VkExtent2D PhysicalDimensions;
public VkExtent2D PhysicalResolution;
public VkSurfaceTransformFlagsKHR SupportedTransforms;
public VkBool32 PlaneReorderPossible;
public VkBool32 PersistentContent;
}
public unsafe partial struct VkDisplaySurfaceCreateInfoKHR : IDisposable
{
//VkDisplaySurfaceCreateInfoKHR
private VkDisplaySurfaceCreateInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkDisplaySurfaceCreateInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkDisplaySurfaceCreateInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkDisplaySurfaceCreateInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkDisplaySurfaceCreateInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDisplaySurfaceCreateFlagsKHR Flags;
public VkDisplayModeKHR DisplayMode;
public uint PlaneIndex;
public uint PlaneStackIndex;
public VkSurfaceTransformFlagBitsKHR Transform;
public float GlobalAlpha;
public VkDisplayPlaneAlphaFlagBitsKHR AlphaMode;
public VkExtent2D ImageExtent;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDisplaySurfaceCreateFlagsKHR Flags => ptr->Flags;
public void SetFlags(VkDisplaySurfaceCreateFlagsKHR value) => ptr->Flags = value;
public VkDisplayModeKHR DisplayMode => ptr->DisplayMode;
public void SetDisplayMode(VkDisplayModeKHR value) => ptr->DisplayMode = value;
public uint PlaneIndex => ptr->PlaneIndex;
public void SetPlaneIndex(uint value) => ptr->PlaneIndex = value;
public uint PlaneStackIndex => ptr->PlaneStackIndex;
public void SetPlaneStackIndex(uint value) => ptr->PlaneStackIndex = value;
public VkSurfaceTransformFlagBitsKHR Transform => ptr->Transform;
public void SetTransform(VkSurfaceTransformFlagBitsKHR value) => ptr->Transform = value;
public float GlobalAlpha => ptr->GlobalAlpha;
public void SetGlobalAlpha(float value) => ptr->GlobalAlpha = value;
public VkDisplayPlaneAlphaFlagBitsKHR AlphaMode => ptr->AlphaMode;
public void SetAlphaMode(VkDisplayPlaneAlphaFlagBitsKHR value) => ptr->AlphaMode = value;
public VkExtent2D ImageExtent => ptr->ImageExtent;
public void SetImageExtent(VkExtent2D value) => ptr->ImageExtent = value;
}
public unsafe partial struct VkEventCreateInfo : IDisposable
{
//VkEventCreateInfo
private VkEventCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkEventCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkEventCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkEventCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkEventCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkEventCreateFlags Flags;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkEventCreateFlags Flags => ptr->Flags;
public void SetFlags(VkEventCreateFlags value) => ptr->Flags = value;
}
public unsafe partial struct VkExtensionProperties : IDisposable
{
//VkExtensionProperties
private VkExtensionProperties(Data* ptr)
{
this.ptr = ptr;
}
public static VkExtensionProperties New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkExtensionProperties(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkExtensionProperties AsPtr() { fixed(Data* ptr = &this) return new VkExtensionProperties(ptr); }
public fixed byte ExtensionName[256];
public uint SpecVersion;
}
public uint SpecVersion => ptr->SpecVersion;
public void SetSpecVersion(uint value) => ptr->SpecVersion = value;
}
public unsafe partial struct VkExtent2D
{
//VkExtent2D
public uint Width;
public uint Height;
}
public unsafe partial struct VkExtent3D
{
//VkExtent3D
public uint Width;
public uint Height;
public uint Depth;
}
public unsafe partial struct VkExternalBufferProperties : IDisposable
{
//VkExternalBufferProperties
private VkExternalBufferProperties(Data* ptr)
{
this.ptr = ptr;
}
public static VkExternalBufferProperties New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkExternalBufferProperties(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkExternalBufferProperties AsPtr() { fixed(Data* ptr = &this) return new VkExternalBufferProperties(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkExternalMemoryProperties ExternalMemoryProperties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkExternalMemoryProperties ExternalMemoryProperties => ptr->ExternalMemoryProperties;
public void SetExternalMemoryProperties(VkExternalMemoryProperties value) => ptr->ExternalMemoryProperties = value;
}
public unsafe partial struct VkExternalFenceProperties : IDisposable
{
//VkExternalFenceProperties
private VkExternalFenceProperties(Data* ptr)
{
this.ptr = ptr;
}
public static VkExternalFenceProperties New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkExternalFenceProperties(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkExternalFenceProperties AsPtr() { fixed(Data* ptr = &this) return new VkExternalFenceProperties(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkExternalFenceHandleTypeFlags ExportFromImportedHandleTypes;
public VkExternalFenceHandleTypeFlags CompatibleHandleTypes;
public VkExternalFenceFeatureFlags ExternalFenceFeatures;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkExternalFenceHandleTypeFlags ExportFromImportedHandleTypes => ptr->ExportFromImportedHandleTypes;
public void SetExportFromImportedHandleTypes(VkExternalFenceHandleTypeFlags value) => ptr->ExportFromImportedHandleTypes = value;
public VkExternalFenceHandleTypeFlags CompatibleHandleTypes => ptr->CompatibleHandleTypes;
public void SetCompatibleHandleTypes(VkExternalFenceHandleTypeFlags value) => ptr->CompatibleHandleTypes = value;
public VkExternalFenceFeatureFlags ExternalFenceFeatures => ptr->ExternalFenceFeatures;
public void SetExternalFenceFeatures(VkExternalFenceFeatureFlags value) => ptr->ExternalFenceFeatures = value;
}
public unsafe partial struct VkExternalImageFormatPropertiesNV : IDisposable
{
//VkExternalImageFormatPropertiesNV
private VkExternalImageFormatPropertiesNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkExternalImageFormatPropertiesNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkExternalImageFormatPropertiesNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkExternalImageFormatPropertiesNV AsPtr() { fixed(Data* ptr = &this) return new VkExternalImageFormatPropertiesNV(ptr); }
public VkImageFormatProperties ImageFormatProperties;
public VkExternalMemoryFeatureFlagsNV ExternalMemoryFeatures;
public VkExternalMemoryHandleTypeFlagsNV ExportFromImportedHandleTypes;
public VkExternalMemoryHandleTypeFlagsNV CompatibleHandleTypes;
}
public VkImageFormatProperties ImageFormatProperties => ptr->ImageFormatProperties;
public void SetImageFormatProperties(VkImageFormatProperties value) => ptr->ImageFormatProperties = value;
public VkExternalMemoryFeatureFlagsNV ExternalMemoryFeatures => ptr->ExternalMemoryFeatures;
public void SetExternalMemoryFeatures(VkExternalMemoryFeatureFlagsNV value) => ptr->ExternalMemoryFeatures = value;
public VkExternalMemoryHandleTypeFlagsNV ExportFromImportedHandleTypes => ptr->ExportFromImportedHandleTypes;
public void SetExportFromImportedHandleTypes(VkExternalMemoryHandleTypeFlagsNV value) => ptr->ExportFromImportedHandleTypes = value;
public VkExternalMemoryHandleTypeFlagsNV CompatibleHandleTypes => ptr->CompatibleHandleTypes;
public void SetCompatibleHandleTypes(VkExternalMemoryHandleTypeFlagsNV value) => ptr->CompatibleHandleTypes = value;
}
public unsafe partial struct VkExternalMemoryProperties
{
//VkExternalMemoryProperties
public VkExternalMemoryFeatureFlags ExternalMemoryFeatures;
public VkExternalMemoryHandleTypeFlags ExportFromImportedHandleTypes;
public VkExternalMemoryHandleTypeFlags CompatibleHandleTypes;
}
public unsafe partial struct VkExternalSemaphoreProperties : IDisposable
{
//VkExternalSemaphoreProperties
private VkExternalSemaphoreProperties(Data* ptr)
{
this.ptr = ptr;
}
public static VkExternalSemaphoreProperties New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkExternalSemaphoreProperties(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkExternalSemaphoreProperties AsPtr() { fixed(Data* ptr = &this) return new VkExternalSemaphoreProperties(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkExternalSemaphoreHandleTypeFlags ExportFromImportedHandleTypes;
public VkExternalSemaphoreHandleTypeFlags CompatibleHandleTypes;
public VkExternalSemaphoreFeatureFlags ExternalSemaphoreFeatures;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkExternalSemaphoreHandleTypeFlags ExportFromImportedHandleTypes => ptr->ExportFromImportedHandleTypes;
public void SetExportFromImportedHandleTypes(VkExternalSemaphoreHandleTypeFlags value) => ptr->ExportFromImportedHandleTypes = value;
public VkExternalSemaphoreHandleTypeFlags CompatibleHandleTypes => ptr->CompatibleHandleTypes;
public void SetCompatibleHandleTypes(VkExternalSemaphoreHandleTypeFlags value) => ptr->CompatibleHandleTypes = value;
public VkExternalSemaphoreFeatureFlags ExternalSemaphoreFeatures => ptr->ExternalSemaphoreFeatures;
public void SetExternalSemaphoreFeatures(VkExternalSemaphoreFeatureFlags value) => ptr->ExternalSemaphoreFeatures = value;
}
public unsafe partial struct VkFenceCreateInfo : IDisposable
{
//VkFenceCreateInfo
private VkFenceCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkFenceCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkFenceCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkFenceCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkFenceCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkFenceCreateFlags Flags;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkFenceCreateFlags Flags => ptr->Flags;
public void SetFlags(VkFenceCreateFlags value) => ptr->Flags = value;
}
public unsafe partial struct VkFenceGetFdInfoKHR : IDisposable
{
//VkFenceGetFdInfoKHR
private VkFenceGetFdInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkFenceGetFdInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkFenceGetFdInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkFenceGetFdInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkFenceGetFdInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkFence Fence;
public VkExternalFenceHandleTypeFlagBits HandleType;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkFence Fence => ptr->Fence;
public void SetFence(VkFence value) => ptr->Fence = value;
public VkExternalFenceHandleTypeFlagBits HandleType => ptr->HandleType;
public void SetHandleType(VkExternalFenceHandleTypeFlagBits value) => ptr->HandleType = value;
}
public unsafe partial struct VkFormatProperties
{
//VkFormatProperties
public VkFormatFeatureFlags LinearTilingFeatures;
public VkFormatFeatureFlags OptimalTilingFeatures;
public VkFormatFeatureFlags BufferFeatures;
}
public unsafe partial struct VkFormatProperties2 : IDisposable
{
//VkFormatProperties2
private VkFormatProperties2(Data* ptr)
{
this.ptr = ptr;
}
public static VkFormatProperties2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkFormatProperties2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkFormatProperties2 AsPtr() { fixed(Data* ptr = &this) return new VkFormatProperties2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkFormatProperties FormatProperties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkFormatProperties FormatProperties => ptr->FormatProperties;
public void SetFormatProperties(VkFormatProperties value) => ptr->FormatProperties = value;
}
public unsafe partial struct VkFramebufferCreateInfo : IDisposable
{
//VkFramebufferCreateInfo
private VkFramebufferCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkFramebufferCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkFramebufferCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkFramebufferCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkFramebufferCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkFramebufferCreateFlags Flags;
public VkRenderPass RenderPass;
public uint AttachmentCount;
public VkImageView* PAttachments;
public uint Width;
public uint Height;
public uint Layers;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkFramebufferCreateFlags Flags => ptr->Flags;
public void SetFlags(VkFramebufferCreateFlags value) => ptr->Flags = value;
public VkRenderPass RenderPass => ptr->RenderPass;
public void SetRenderPass(VkRenderPass value) => ptr->RenderPass = value;
public uint AttachmentCount => ptr->AttachmentCount;
public void SetAttachmentCount(uint value) => ptr->AttachmentCount = value;
public VkImageView* PAttachments => ptr->PAttachments;
public void SetPAttachments(VkImageView* value) => ptr->PAttachments = value;
public uint Width => ptr->Width;
public void SetWidth(uint value) => ptr->Width = value;
public uint Height => ptr->Height;
public void SetHeight(uint value) => ptr->Height = value;
public uint Layers => ptr->Layers;
public void SetLayers(uint value) => ptr->Layers = value;
}
public unsafe partial struct VkGeometryAABBNV
{
//VkGeometryAABBNV
public VkStructureType SType;
public IntPtr PNext;
public VkBuffer AabbData;
public uint NumAABBs;
public uint Stride;
public VkDeviceSize Offset;
}
public unsafe partial struct VkGeometryDataNV
{
//VkGeometryDataNV
public VkGeometryTrianglesNV Triangles;
public VkGeometryAABBNV Aabbs;
}
public unsafe partial struct VkGeometryNV : IDisposable
{
//VkGeometryNV
private VkGeometryNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkGeometryNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkGeometryNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkGeometryNV AsPtr() { fixed(Data* ptr = &this) return new VkGeometryNV(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkGeometryTypeNV GeometryType;
public VkGeometryDataNV Geometry;
public VkGeometryFlagsNV Flags;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkGeometryTypeNV GeometryType => ptr->GeometryType;
public void SetGeometryType(VkGeometryTypeNV value) => ptr->GeometryType = value;
public VkGeometryDataNV Geometry => ptr->Geometry;
public void SetGeometry(VkGeometryDataNV value) => ptr->Geometry = value;
public VkGeometryFlagsNV Flags => ptr->Flags;
public void SetFlags(VkGeometryFlagsNV value) => ptr->Flags = value;
}
public unsafe partial struct VkGeometryTrianglesNV
{
//VkGeometryTrianglesNV
public VkStructureType SType;
public IntPtr PNext;
public VkBuffer VertexData;
public VkDeviceSize VertexOffset;
public uint VertexCount;
public VkDeviceSize VertexStride;
public VkFormat VertexFormat;
public VkBuffer IndexData;
public VkDeviceSize IndexOffset;
public uint IndexCount;
public VkIndexType IndexType;
public VkBuffer TransformData;
public VkDeviceSize TransformOffset;
}
public unsafe partial struct VkGraphicsPipelineCreateInfo : IDisposable
{
//VkGraphicsPipelineCreateInfo
private VkGraphicsPipelineCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkGraphicsPipelineCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkGraphicsPipelineCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkGraphicsPipelineCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkGraphicsPipelineCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineCreateFlags Flags;
public uint StageCount;
public VkPipelineShaderStageCreateInfo* PStages;
public VkPipelineVertexInputStateCreateInfo PVertexInputState;
public VkPipelineInputAssemblyStateCreateInfo PInputAssemblyState;
public VkPipelineTessellationStateCreateInfo PTessellationState;
public VkPipelineViewportStateCreateInfo PViewportState;
public VkPipelineRasterizationStateCreateInfo PRasterizationState;
public VkPipelineMultisampleStateCreateInfo PMultisampleState;
public VkPipelineDepthStencilStateCreateInfo PDepthStencilState;
public VkPipelineColorBlendStateCreateInfo PColorBlendState;
public VkPipelineDynamicStateCreateInfo PDynamicState;
public VkPipelineLayout Layout;
public VkRenderPass RenderPass;
public uint Subpass;
public VkPipeline BasePipelineHandle;
public int BasePipelineIndex;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineCreateFlags value) => ptr->Flags = value;
public uint StageCount => ptr->StageCount;
public void SetStageCount(uint value) => ptr->StageCount = value;
public VkPipelineShaderStageCreateInfo* PStages => ptr->PStages;
public void SetPStages(VkPipelineShaderStageCreateInfo* value) => ptr->PStages = value;
public VkPipelineVertexInputStateCreateInfo PVertexInputState => ptr->PVertexInputState;
public void SetPVertexInputState(VkPipelineVertexInputStateCreateInfo value) => ptr->PVertexInputState = value;
public VkPipelineInputAssemblyStateCreateInfo PInputAssemblyState => ptr->PInputAssemblyState;
public void SetPInputAssemblyState(VkPipelineInputAssemblyStateCreateInfo value) => ptr->PInputAssemblyState = value;
public VkPipelineTessellationStateCreateInfo PTessellationState => ptr->PTessellationState;
public void SetPTessellationState(VkPipelineTessellationStateCreateInfo value) => ptr->PTessellationState = value;
public VkPipelineViewportStateCreateInfo PViewportState => ptr->PViewportState;
public void SetPViewportState(VkPipelineViewportStateCreateInfo value) => ptr->PViewportState = value;
public VkPipelineRasterizationStateCreateInfo PRasterizationState => ptr->PRasterizationState;
public void SetPRasterizationState(VkPipelineRasterizationStateCreateInfo value) => ptr->PRasterizationState = value;
public VkPipelineMultisampleStateCreateInfo PMultisampleState => ptr->PMultisampleState;
public void SetPMultisampleState(VkPipelineMultisampleStateCreateInfo value) => ptr->PMultisampleState = value;
public VkPipelineDepthStencilStateCreateInfo PDepthStencilState => ptr->PDepthStencilState;
public void SetPDepthStencilState(VkPipelineDepthStencilStateCreateInfo value) => ptr->PDepthStencilState = value;
public VkPipelineColorBlendStateCreateInfo PColorBlendState => ptr->PColorBlendState;
public void SetPColorBlendState(VkPipelineColorBlendStateCreateInfo value) => ptr->PColorBlendState = value;
public VkPipelineDynamicStateCreateInfo PDynamicState => ptr->PDynamicState;
public void SetPDynamicState(VkPipelineDynamicStateCreateInfo value) => ptr->PDynamicState = value;
public VkPipelineLayout Layout => ptr->Layout;
public void SetLayout(VkPipelineLayout value) => ptr->Layout = value;
public VkRenderPass RenderPass => ptr->RenderPass;
public void SetRenderPass(VkRenderPass value) => ptr->RenderPass = value;
public uint Subpass => ptr->Subpass;
public void SetSubpass(uint value) => ptr->Subpass = value;
public VkPipeline BasePipelineHandle => ptr->BasePipelineHandle;
public void SetBasePipelineHandle(VkPipeline value) => ptr->BasePipelineHandle = value;
public int BasePipelineIndex => ptr->BasePipelineIndex;
public void SetBasePipelineIndex(int value) => ptr->BasePipelineIndex = value;
}
public unsafe partial struct VkHdrMetadataEXT : IDisposable
{
//VkHdrMetadataEXT
private VkHdrMetadataEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkHdrMetadataEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkHdrMetadataEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkHdrMetadataEXT AsPtr() { fixed(Data* ptr = &this) return new VkHdrMetadataEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkXYColorEXT DisplayPrimaryRed;
public VkXYColorEXT DisplayPrimaryGreen;
public VkXYColorEXT DisplayPrimaryBlue;
public VkXYColorEXT WhitePoint;
public float MaxLuminance;
public float MinLuminance;
public float MaxContentLightLevel;
public float MaxFrameAverageLightLevel;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkXYColorEXT DisplayPrimaryRed => ptr->DisplayPrimaryRed;
public void SetDisplayPrimaryRed(VkXYColorEXT value) => ptr->DisplayPrimaryRed = value;
public VkXYColorEXT DisplayPrimaryGreen => ptr->DisplayPrimaryGreen;
public void SetDisplayPrimaryGreen(VkXYColorEXT value) => ptr->DisplayPrimaryGreen = value;
public VkXYColorEXT DisplayPrimaryBlue => ptr->DisplayPrimaryBlue;
public void SetDisplayPrimaryBlue(VkXYColorEXT value) => ptr->DisplayPrimaryBlue = value;
public VkXYColorEXT WhitePoint => ptr->WhitePoint;
public void SetWhitePoint(VkXYColorEXT value) => ptr->WhitePoint = value;
public float MaxLuminance => ptr->MaxLuminance;
public void SetMaxLuminance(float value) => ptr->MaxLuminance = value;
public float MinLuminance => ptr->MinLuminance;
public void SetMinLuminance(float value) => ptr->MinLuminance = value;
public float MaxContentLightLevel => ptr->MaxContentLightLevel;
public void SetMaxContentLightLevel(float value) => ptr->MaxContentLightLevel = value;
public float MaxFrameAverageLightLevel => ptr->MaxFrameAverageLightLevel;
public void SetMaxFrameAverageLightLevel(float value) => ptr->MaxFrameAverageLightLevel = value;
}
public unsafe partial struct VkImageBlit : IDisposable
{
//VkImageBlit
private VkImageBlit(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageBlit New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageBlit(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageBlit AsPtr() { fixed(Data* ptr = &this) return new VkImageBlit(ptr); }
public VkImageSubresourceLayers SrcSubresource;
public VkOffset3D2 SrcOffsets;
public VkImageSubresourceLayers DstSubresource;
public VkOffset3D2 DstOffsets;
}
public VkImageSubresourceLayers SrcSubresource => ptr->SrcSubresource;
public void SetSrcSubresource(VkImageSubresourceLayers value) => ptr->SrcSubresource = value;
public VkOffset3D2 SrcOffsets => ptr->SrcOffsets;
public VkImageSubresourceLayers DstSubresource => ptr->DstSubresource;
public void SetDstSubresource(VkImageSubresourceLayers value) => ptr->DstSubresource = value;
public VkOffset3D2 DstOffsets => ptr->DstOffsets;
}
public unsafe partial struct VkImageCopy : IDisposable
{
//VkImageCopy
private VkImageCopy(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageCopy New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageCopy(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageCopy AsPtr() { fixed(Data* ptr = &this) return new VkImageCopy(ptr); }
public VkImageSubresourceLayers SrcSubresource;
public VkOffset3D SrcOffset;
public VkImageSubresourceLayers DstSubresource;
public VkOffset3D DstOffset;
public VkExtent3D Extent;
}
public VkImageSubresourceLayers SrcSubresource => ptr->SrcSubresource;
public void SetSrcSubresource(VkImageSubresourceLayers value) => ptr->SrcSubresource = value;
public VkOffset3D SrcOffset => ptr->SrcOffset;
public void SetSrcOffset(VkOffset3D value) => ptr->SrcOffset = value;
public VkImageSubresourceLayers DstSubresource => ptr->DstSubresource;
public void SetDstSubresource(VkImageSubresourceLayers value) => ptr->DstSubresource = value;
public VkOffset3D DstOffset => ptr->DstOffset;
public void SetDstOffset(VkOffset3D value) => ptr->DstOffset = value;
public VkExtent3D Extent => ptr->Extent;
public void SetExtent(VkExtent3D value) => ptr->Extent = value;
}
public unsafe partial struct VkImageCreateInfo : IDisposable
{
//VkImageCreateInfo
private VkImageCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkImageCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkImageCreateFlags Flags;
public VkImageType ImageType;
public VkFormat Format;
public VkExtent3D Extent;
public uint MipLevels;
public uint ArrayLayers;
public VkSampleCountFlagBits Samples;
public VkImageTiling Tiling;
public VkImageUsageFlags Usage;
public VkSharingMode SharingMode;
public uint QueueFamilyIndexCount;
public uint* PQueueFamilyIndices;
public VkImageLayout InitialLayout;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkImageCreateFlags Flags => ptr->Flags;
public void SetFlags(VkImageCreateFlags value) => ptr->Flags = value;
public VkImageType ImageType => ptr->ImageType;
public void SetImageType(VkImageType value) => ptr->ImageType = value;
public VkFormat Format => ptr->Format;
public void SetFormat(VkFormat value) => ptr->Format = value;
public VkExtent3D Extent => ptr->Extent;
public void SetExtent(VkExtent3D value) => ptr->Extent = value;
public uint MipLevels => ptr->MipLevels;
public void SetMipLevels(uint value) => ptr->MipLevels = value;
public uint ArrayLayers => ptr->ArrayLayers;
public void SetArrayLayers(uint value) => ptr->ArrayLayers = value;
public VkSampleCountFlagBits Samples => ptr->Samples;
public void SetSamples(VkSampleCountFlagBits value) => ptr->Samples = value;
public VkImageTiling Tiling => ptr->Tiling;
public void SetTiling(VkImageTiling value) => ptr->Tiling = value;
public VkImageUsageFlags Usage => ptr->Usage;
public void SetUsage(VkImageUsageFlags value) => ptr->Usage = value;
public VkSharingMode SharingMode => ptr->SharingMode;
public void SetSharingMode(VkSharingMode value) => ptr->SharingMode = value;
public uint QueueFamilyIndexCount => ptr->QueueFamilyIndexCount;
public void SetQueueFamilyIndexCount(uint value) => ptr->QueueFamilyIndexCount = value;
public uint* PQueueFamilyIndices => ptr->PQueueFamilyIndices;
public void SetPQueueFamilyIndices(uint* value) => ptr->PQueueFamilyIndices = value;
public VkImageLayout InitialLayout => ptr->InitialLayout;
public void SetInitialLayout(VkImageLayout value) => ptr->InitialLayout = value;
}
public unsafe partial struct VkImageDrmFormatModifierPropertiesEXT : IDisposable
{
//VkImageDrmFormatModifierPropertiesEXT
private VkImageDrmFormatModifierPropertiesEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageDrmFormatModifierPropertiesEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageDrmFormatModifierPropertiesEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageDrmFormatModifierPropertiesEXT AsPtr() { fixed(Data* ptr = &this) return new VkImageDrmFormatModifierPropertiesEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public ulong DrmFormatModifier;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public ulong DrmFormatModifier => ptr->DrmFormatModifier;
public void SetDrmFormatModifier(ulong value) => ptr->DrmFormatModifier = value;
}
public unsafe partial struct VkImageFormatProperties
{
//VkImageFormatProperties
public VkExtent3D MaxExtent;
public uint MaxMipLevels;
public uint MaxArrayLayers;
public VkSampleCountFlags SampleCounts;
public VkDeviceSize MaxResourceSize;
}
public unsafe partial struct VkImageFormatProperties2 : IDisposable
{
//VkImageFormatProperties2
private VkImageFormatProperties2(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageFormatProperties2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageFormatProperties2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageFormatProperties2 AsPtr() { fixed(Data* ptr = &this) return new VkImageFormatProperties2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkImageFormatProperties ImageFormatProperties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkImageFormatProperties ImageFormatProperties => ptr->ImageFormatProperties;
public void SetImageFormatProperties(VkImageFormatProperties value) => ptr->ImageFormatProperties = value;
}
public unsafe partial struct VkImageMemoryBarrier : IDisposable
{
//VkImageMemoryBarrier
private VkImageMemoryBarrier(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageMemoryBarrier New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageMemoryBarrier(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageMemoryBarrier AsPtr() { fixed(Data* ptr = &this) return new VkImageMemoryBarrier(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkAccessFlags SrcAccessMask;
public VkAccessFlags DstAccessMask;
public VkImageLayout OldLayout;
public VkImageLayout NewLayout;
public uint SrcQueueFamilyIndex;
public uint DstQueueFamilyIndex;
public VkImage Image;
public VkImageSubresourceRange SubresourceRange;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkAccessFlags SrcAccessMask => ptr->SrcAccessMask;
public void SetSrcAccessMask(VkAccessFlags value) => ptr->SrcAccessMask = value;
public VkAccessFlags DstAccessMask => ptr->DstAccessMask;
public void SetDstAccessMask(VkAccessFlags value) => ptr->DstAccessMask = value;
public VkImageLayout OldLayout => ptr->OldLayout;
public void SetOldLayout(VkImageLayout value) => ptr->OldLayout = value;
public VkImageLayout NewLayout => ptr->NewLayout;
public void SetNewLayout(VkImageLayout value) => ptr->NewLayout = value;
public uint SrcQueueFamilyIndex => ptr->SrcQueueFamilyIndex;
public void SetSrcQueueFamilyIndex(uint value) => ptr->SrcQueueFamilyIndex = value;
public uint DstQueueFamilyIndex => ptr->DstQueueFamilyIndex;
public void SetDstQueueFamilyIndex(uint value) => ptr->DstQueueFamilyIndex = value;
public VkImage Image => ptr->Image;
public void SetImage(VkImage value) => ptr->Image = value;
public VkImageSubresourceRange SubresourceRange => ptr->SubresourceRange;
public void SetSubresourceRange(VkImageSubresourceRange value) => ptr->SubresourceRange = value;
}
public unsafe partial struct VkImageMemoryRequirementsInfo2 : IDisposable
{
//VkImageMemoryRequirementsInfo2
private VkImageMemoryRequirementsInfo2(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageMemoryRequirementsInfo2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageMemoryRequirementsInfo2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageMemoryRequirementsInfo2 AsPtr() { fixed(Data* ptr = &this) return new VkImageMemoryRequirementsInfo2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkImage Image;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkImage Image => ptr->Image;
public void SetImage(VkImage value) => ptr->Image = value;
}
public unsafe partial struct VkImageResolve : IDisposable
{
//VkImageResolve
private VkImageResolve(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageResolve New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageResolve(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageResolve AsPtr() { fixed(Data* ptr = &this) return new VkImageResolve(ptr); }
public VkImageSubresourceLayers SrcSubresource;
public VkOffset3D SrcOffset;
public VkImageSubresourceLayers DstSubresource;
public VkOffset3D DstOffset;
public VkExtent3D Extent;
}
public VkImageSubresourceLayers SrcSubresource => ptr->SrcSubresource;
public void SetSrcSubresource(VkImageSubresourceLayers value) => ptr->SrcSubresource = value;
public VkOffset3D SrcOffset => ptr->SrcOffset;
public void SetSrcOffset(VkOffset3D value) => ptr->SrcOffset = value;
public VkImageSubresourceLayers DstSubresource => ptr->DstSubresource;
public void SetDstSubresource(VkImageSubresourceLayers value) => ptr->DstSubresource = value;
public VkOffset3D DstOffset => ptr->DstOffset;
public void SetDstOffset(VkOffset3D value) => ptr->DstOffset = value;
public VkExtent3D Extent => ptr->Extent;
public void SetExtent(VkExtent3D value) => ptr->Extent = value;
}
public unsafe partial struct VkImageSparseMemoryRequirementsInfo2 : IDisposable
{
//VkImageSparseMemoryRequirementsInfo2
private VkImageSparseMemoryRequirementsInfo2(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageSparseMemoryRequirementsInfo2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageSparseMemoryRequirementsInfo2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageSparseMemoryRequirementsInfo2 AsPtr() { fixed(Data* ptr = &this) return new VkImageSparseMemoryRequirementsInfo2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkImage Image;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkImage Image => ptr->Image;
public void SetImage(VkImage value) => ptr->Image = value;
}
public unsafe partial struct VkImageSubresource
{
//VkImageSubresource
public VkImageAspectFlags AspectMask;
public uint MipLevel;
public uint ArrayLayer;
}
public unsafe partial struct VkImageSubresourceLayers
{
//VkImageSubresourceLayers
public VkImageAspectFlags AspectMask;
public uint MipLevel;
public uint BaseArrayLayer;
public uint LayerCount;
}
public unsafe partial struct VkImageSubresourceRange
{
//VkImageSubresourceRange
public VkImageAspectFlags AspectMask;
public uint BaseMipLevel;
public uint LevelCount;
public uint BaseArrayLayer;
public uint LayerCount;
}
public unsafe partial struct VkImageViewCreateInfo : IDisposable
{
//VkImageViewCreateInfo
private VkImageViewCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkImageViewCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImageViewCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImageViewCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkImageViewCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkImageViewCreateFlags Flags;
public VkImage Image;
public VkImageViewType ViewType;
public VkFormat Format;
public VkComponentMapping Components;
public VkImageSubresourceRange SubresourceRange;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkImageViewCreateFlags Flags => ptr->Flags;
public void SetFlags(VkImageViewCreateFlags value) => ptr->Flags = value;
public VkImage Image => ptr->Image;
public void SetImage(VkImage value) => ptr->Image = value;
public VkImageViewType ViewType => ptr->ViewType;
public void SetViewType(VkImageViewType value) => ptr->ViewType = value;
public VkFormat Format => ptr->Format;
public void SetFormat(VkFormat value) => ptr->Format = value;
public VkComponentMapping Components => ptr->Components;
public void SetComponents(VkComponentMapping value) => ptr->Components = value;
public VkImageSubresourceRange SubresourceRange => ptr->SubresourceRange;
public void SetSubresourceRange(VkImageSubresourceRange value) => ptr->SubresourceRange = value;
}
public unsafe partial struct VkImportFenceFdInfoKHR : IDisposable
{
//VkImportFenceFdInfoKHR
private VkImportFenceFdInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkImportFenceFdInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImportFenceFdInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImportFenceFdInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkImportFenceFdInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkFence Fence;
public VkFenceImportFlags Flags;
public VkExternalFenceHandleTypeFlagBits HandleType;
public int Fd;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkFence Fence => ptr->Fence;
public void SetFence(VkFence value) => ptr->Fence = value;
public VkFenceImportFlags Flags => ptr->Flags;
public void SetFlags(VkFenceImportFlags value) => ptr->Flags = value;
public VkExternalFenceHandleTypeFlagBits HandleType => ptr->HandleType;
public void SetHandleType(VkExternalFenceHandleTypeFlagBits value) => ptr->HandleType = value;
public int Fd => ptr->Fd;
public void SetFd(int value) => ptr->Fd = value;
}
public unsafe partial struct VkImportSemaphoreFdInfoKHR : IDisposable
{
//VkImportSemaphoreFdInfoKHR
private VkImportSemaphoreFdInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkImportSemaphoreFdInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkImportSemaphoreFdInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkImportSemaphoreFdInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkImportSemaphoreFdInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSemaphore Semaphore;
public VkSemaphoreImportFlags Flags;
public VkExternalSemaphoreHandleTypeFlagBits HandleType;
public int Fd;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSemaphore Semaphore => ptr->Semaphore;
public void SetSemaphore(VkSemaphore value) => ptr->Semaphore = value;
public VkSemaphoreImportFlags Flags => ptr->Flags;
public void SetFlags(VkSemaphoreImportFlags value) => ptr->Flags = value;
public VkExternalSemaphoreHandleTypeFlagBits HandleType => ptr->HandleType;
public void SetHandleType(VkExternalSemaphoreHandleTypeFlagBits value) => ptr->HandleType = value;
public int Fd => ptr->Fd;
public void SetFd(int value) => ptr->Fd = value;
}
public unsafe partial struct VkIndirectCommandsLayoutCreateInfoNVX : IDisposable
{
//VkIndirectCommandsLayoutCreateInfoNVX
private VkIndirectCommandsLayoutCreateInfoNVX(Data* ptr)
{
this.ptr = ptr;
}
public static VkIndirectCommandsLayoutCreateInfoNVX New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkIndirectCommandsLayoutCreateInfoNVX(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkIndirectCommandsLayoutCreateInfoNVX AsPtr() { fixed(Data* ptr = &this) return new VkIndirectCommandsLayoutCreateInfoNVX(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineBindPoint PipelineBindPoint;
public VkIndirectCommandsLayoutUsageFlagsNVX Flags;
public uint TokenCount;
public VkIndirectCommandsLayoutTokenNVX PTokens;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineBindPoint PipelineBindPoint => ptr->PipelineBindPoint;
public void SetPipelineBindPoint(VkPipelineBindPoint value) => ptr->PipelineBindPoint = value;
public VkIndirectCommandsLayoutUsageFlagsNVX Flags => ptr->Flags;
public void SetFlags(VkIndirectCommandsLayoutUsageFlagsNVX value) => ptr->Flags = value;
public uint TokenCount => ptr->TokenCount;
public void SetTokenCount(uint value) => ptr->TokenCount = value;
public VkIndirectCommandsLayoutTokenNVX PTokens => ptr->PTokens;
public void SetPTokens(VkIndirectCommandsLayoutTokenNVX value) => ptr->PTokens = value;
}
public unsafe partial struct VkIndirectCommandsLayoutTokenNVX : IDisposable
{
//VkIndirectCommandsLayoutTokenNVX
private VkIndirectCommandsLayoutTokenNVX(Data* ptr)
{
this.ptr = ptr;
}
public static VkIndirectCommandsLayoutTokenNVX New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkIndirectCommandsLayoutTokenNVX(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkIndirectCommandsLayoutTokenNVX AsPtr() { fixed(Data* ptr = &this) return new VkIndirectCommandsLayoutTokenNVX(ptr); }
public VkIndirectCommandsTokenTypeNVX TokenType;
public uint BindingUnit;
public uint DynamicCount;
public uint Divisor;
}
public VkIndirectCommandsTokenTypeNVX TokenType => ptr->TokenType;
public void SetTokenType(VkIndirectCommandsTokenTypeNVX value) => ptr->TokenType = value;
public uint BindingUnit => ptr->BindingUnit;
public void SetBindingUnit(uint value) => ptr->BindingUnit = value;
public uint DynamicCount => ptr->DynamicCount;
public void SetDynamicCount(uint value) => ptr->DynamicCount = value;
public uint Divisor => ptr->Divisor;
public void SetDivisor(uint value) => ptr->Divisor = value;
}
public unsafe partial struct VkIndirectCommandsTokenNVX : IDisposable
{
//VkIndirectCommandsTokenNVX
private VkIndirectCommandsTokenNVX(Data* ptr)
{
this.ptr = ptr;
}
public static VkIndirectCommandsTokenNVX New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkIndirectCommandsTokenNVX(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkIndirectCommandsTokenNVX AsPtr() { fixed(Data* ptr = &this) return new VkIndirectCommandsTokenNVX(ptr); }
public VkIndirectCommandsTokenTypeNVX TokenType;
public VkBuffer Buffer;
public VkDeviceSize Offset;
}
public VkIndirectCommandsTokenTypeNVX TokenType => ptr->TokenType;
public void SetTokenType(VkIndirectCommandsTokenTypeNVX value) => ptr->TokenType = value;
public VkBuffer Buffer => ptr->Buffer;
public void SetBuffer(VkBuffer value) => ptr->Buffer = value;
public VkDeviceSize Offset => ptr->Offset;
public void SetOffset(VkDeviceSize value) => ptr->Offset = value;
}
public unsafe partial struct VkInstanceCreateInfo : IDisposable
{
//VkInstanceCreateInfo
private VkInstanceCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkInstanceCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkInstanceCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkInstanceCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkInstanceCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkInstanceCreateFlags Flags;
public VkApplicationInfo PApplicationInfo;
public uint EnabledLayerCount;
public byte** PpEnabledLayerNames;
public uint EnabledExtensionCount;
public byte** PpEnabledExtensionNames;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkInstanceCreateFlags Flags => ptr->Flags;
public void SetFlags(VkInstanceCreateFlags value) => ptr->Flags = value;
public VkApplicationInfo PApplicationInfo => ptr->PApplicationInfo;
public void SetPApplicationInfo(VkApplicationInfo value) => ptr->PApplicationInfo = value;
public uint EnabledLayerCount => ptr->EnabledLayerCount;
public void SetEnabledLayerCount(uint value) => ptr->EnabledLayerCount = value;
public byte** PpEnabledLayerNames => ptr->PpEnabledLayerNames;
public void SetPpEnabledLayerNames(byte** value) => ptr->PpEnabledLayerNames = value;
public uint EnabledExtensionCount => ptr->EnabledExtensionCount;
public void SetEnabledExtensionCount(uint value) => ptr->EnabledExtensionCount = value;
public byte** PpEnabledExtensionNames => ptr->PpEnabledExtensionNames;
public void SetPpEnabledExtensionNames(byte** value) => ptr->PpEnabledExtensionNames = value;
}
public unsafe partial struct VkLayerProperties : IDisposable
{
//VkLayerProperties
private VkLayerProperties(Data* ptr)
{
this.ptr = ptr;
}
public static VkLayerProperties New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkLayerProperties(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkLayerProperties AsPtr() { fixed(Data* ptr = &this) return new VkLayerProperties(ptr); }
public fixed byte LayerName[256];
public uint SpecVersion;
public uint ImplementationVersion;
public fixed byte Description[256];
}
public uint SpecVersion => ptr->SpecVersion;
public void SetSpecVersion(uint value) => ptr->SpecVersion = value;
public uint ImplementationVersion => ptr->ImplementationVersion;
public void SetImplementationVersion(uint value) => ptr->ImplementationVersion = value;
}
public unsafe partial struct VkMappedMemoryRange : IDisposable
{
//VkMappedMemoryRange
private VkMappedMemoryRange(Data* ptr)
{
this.ptr = ptr;
}
public static VkMappedMemoryRange New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkMappedMemoryRange(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkMappedMemoryRange AsPtr() { fixed(Data* ptr = &this) return new VkMappedMemoryRange(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDeviceMemory Memory;
public VkDeviceSize Offset;
public VkDeviceSize Size;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDeviceMemory Memory => ptr->Memory;
public void SetMemory(VkDeviceMemory value) => ptr->Memory = value;
public VkDeviceSize Offset => ptr->Offset;
public void SetOffset(VkDeviceSize value) => ptr->Offset = value;
public VkDeviceSize Size => ptr->Size;
public void SetSize(VkDeviceSize value) => ptr->Size = value;
}
public unsafe partial struct VkMemoryAllocateInfo : IDisposable
{
//VkMemoryAllocateInfo
private VkMemoryAllocateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkMemoryAllocateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkMemoryAllocateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkMemoryAllocateInfo AsPtr() { fixed(Data* ptr = &this) return new VkMemoryAllocateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDeviceSize AllocationSize;
public uint MemoryTypeIndex;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDeviceSize AllocationSize => ptr->AllocationSize;
public void SetAllocationSize(VkDeviceSize value) => ptr->AllocationSize = value;
public uint MemoryTypeIndex => ptr->MemoryTypeIndex;
public void SetMemoryTypeIndex(uint value) => ptr->MemoryTypeIndex = value;
}
public unsafe partial struct VkMemoryBarrier : IDisposable
{
//VkMemoryBarrier
private VkMemoryBarrier(Data* ptr)
{
this.ptr = ptr;
}
public static VkMemoryBarrier New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkMemoryBarrier(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkMemoryBarrier AsPtr() { fixed(Data* ptr = &this) return new VkMemoryBarrier(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkAccessFlags SrcAccessMask;
public VkAccessFlags DstAccessMask;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkAccessFlags SrcAccessMask => ptr->SrcAccessMask;
public void SetSrcAccessMask(VkAccessFlags value) => ptr->SrcAccessMask = value;
public VkAccessFlags DstAccessMask => ptr->DstAccessMask;
public void SetDstAccessMask(VkAccessFlags value) => ptr->DstAccessMask = value;
}
public unsafe partial struct VkMemoryFdPropertiesKHR : IDisposable
{
//VkMemoryFdPropertiesKHR
private VkMemoryFdPropertiesKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkMemoryFdPropertiesKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkMemoryFdPropertiesKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkMemoryFdPropertiesKHR AsPtr() { fixed(Data* ptr = &this) return new VkMemoryFdPropertiesKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint MemoryTypeBits;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint MemoryTypeBits => ptr->MemoryTypeBits;
public void SetMemoryTypeBits(uint value) => ptr->MemoryTypeBits = value;
}
public unsafe partial struct VkMemoryGetFdInfoKHR : IDisposable
{
//VkMemoryGetFdInfoKHR
private VkMemoryGetFdInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkMemoryGetFdInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkMemoryGetFdInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkMemoryGetFdInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkMemoryGetFdInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDeviceMemory Memory;
public VkExternalMemoryHandleTypeFlagBits HandleType;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDeviceMemory Memory => ptr->Memory;
public void SetMemory(VkDeviceMemory value) => ptr->Memory = value;
public VkExternalMemoryHandleTypeFlagBits HandleType => ptr->HandleType;
public void SetHandleType(VkExternalMemoryHandleTypeFlagBits value) => ptr->HandleType = value;
}
public unsafe partial struct VkMemoryHeap
{
//VkMemoryHeap
public VkDeviceSize Size;
public VkMemoryHeapFlags Flags;
}
public unsafe partial struct VkMemoryHostPointerPropertiesEXT : IDisposable
{
//VkMemoryHostPointerPropertiesEXT
private VkMemoryHostPointerPropertiesEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkMemoryHostPointerPropertiesEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkMemoryHostPointerPropertiesEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkMemoryHostPointerPropertiesEXT AsPtr() { fixed(Data* ptr = &this) return new VkMemoryHostPointerPropertiesEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint MemoryTypeBits;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint MemoryTypeBits => ptr->MemoryTypeBits;
public void SetMemoryTypeBits(uint value) => ptr->MemoryTypeBits = value;
}
public unsafe partial struct VkMemoryRequirements
{
//VkMemoryRequirements
public VkDeviceSize Size;
public VkDeviceSize Alignment;
public uint MemoryTypeBits;
}
public unsafe partial struct VkMemoryRequirements2 : IDisposable
{
//VkMemoryRequirements2
private VkMemoryRequirements2(Data* ptr)
{
this.ptr = ptr;
}
public static VkMemoryRequirements2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkMemoryRequirements2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkMemoryRequirements2 AsPtr() { fixed(Data* ptr = &this) return new VkMemoryRequirements2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkMemoryRequirements MemoryRequirements;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkMemoryRequirements MemoryRequirements => ptr->MemoryRequirements;
public void SetMemoryRequirements(VkMemoryRequirements value) => ptr->MemoryRequirements = value;
}
public unsafe partial struct VkMemoryRequirements2KHR : IDisposable
{
//VkMemoryRequirements2KHR
private VkMemoryRequirements2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkMemoryRequirements2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkMemoryRequirements2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkMemoryRequirements2KHR AsPtr() { fixed(Data* ptr = &this) return new VkMemoryRequirements2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkMemoryRequirements MemoryRequirements;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkMemoryRequirements MemoryRequirements => ptr->MemoryRequirements;
public void SetMemoryRequirements(VkMemoryRequirements value) => ptr->MemoryRequirements = value;
}
public unsafe partial struct VkMemoryType
{
//VkMemoryType
public VkMemoryPropertyFlags PropertyFlags;
public uint HeapIndex;
}
public unsafe partial struct VkMultisamplePropertiesEXT : IDisposable
{
//VkMultisamplePropertiesEXT
private VkMultisamplePropertiesEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkMultisamplePropertiesEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkMultisamplePropertiesEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkMultisamplePropertiesEXT AsPtr() { fixed(Data* ptr = &this) return new VkMultisamplePropertiesEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkExtent2D MaxSampleLocationGridSize;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkExtent2D MaxSampleLocationGridSize => ptr->MaxSampleLocationGridSize;
public void SetMaxSampleLocationGridSize(VkExtent2D value) => ptr->MaxSampleLocationGridSize = value;
}
public unsafe partial struct VkObjectTableCreateInfoNVX : IDisposable
{
//VkObjectTableCreateInfoNVX
private VkObjectTableCreateInfoNVX(Data* ptr)
{
this.ptr = ptr;
}
public static VkObjectTableCreateInfoNVX New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkObjectTableCreateInfoNVX(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkObjectTableCreateInfoNVX AsPtr() { fixed(Data* ptr = &this) return new VkObjectTableCreateInfoNVX(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint ObjectCount;
public VkObjectEntryTypeNVX* PObjectEntryTypes;
public uint* PObjectEntryCounts;
public VkObjectEntryUsageFlagsNVX* PObjectEntryUsageFlags;
public uint MaxUniformBuffersPerDescriptor;
public uint MaxStorageBuffersPerDescriptor;
public uint MaxStorageImagesPerDescriptor;
public uint MaxSampledImagesPerDescriptor;
public uint MaxPipelineLayouts;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint ObjectCount => ptr->ObjectCount;
public void SetObjectCount(uint value) => ptr->ObjectCount = value;
public VkObjectEntryTypeNVX* PObjectEntryTypes => ptr->PObjectEntryTypes;
public void SetPObjectEntryTypes(VkObjectEntryTypeNVX* value) => ptr->PObjectEntryTypes = value;
public uint* PObjectEntryCounts => ptr->PObjectEntryCounts;
public void SetPObjectEntryCounts(uint* value) => ptr->PObjectEntryCounts = value;
public VkObjectEntryUsageFlagsNVX* PObjectEntryUsageFlags => ptr->PObjectEntryUsageFlags;
public void SetPObjectEntryUsageFlags(VkObjectEntryUsageFlagsNVX* value) => ptr->PObjectEntryUsageFlags = value;
public uint MaxUniformBuffersPerDescriptor => ptr->MaxUniformBuffersPerDescriptor;
public void SetMaxUniformBuffersPerDescriptor(uint value) => ptr->MaxUniformBuffersPerDescriptor = value;
public uint MaxStorageBuffersPerDescriptor => ptr->MaxStorageBuffersPerDescriptor;
public void SetMaxStorageBuffersPerDescriptor(uint value) => ptr->MaxStorageBuffersPerDescriptor = value;
public uint MaxStorageImagesPerDescriptor => ptr->MaxStorageImagesPerDescriptor;
public void SetMaxStorageImagesPerDescriptor(uint value) => ptr->MaxStorageImagesPerDescriptor = value;
public uint MaxSampledImagesPerDescriptor => ptr->MaxSampledImagesPerDescriptor;
public void SetMaxSampledImagesPerDescriptor(uint value) => ptr->MaxSampledImagesPerDescriptor = value;
public uint MaxPipelineLayouts => ptr->MaxPipelineLayouts;
public void SetMaxPipelineLayouts(uint value) => ptr->MaxPipelineLayouts = value;
}
public unsafe partial struct VkObjectTableEntryNVX : IDisposable
{
//VkObjectTableEntryNVX
private VkObjectTableEntryNVX(Data* ptr)
{
this.ptr = ptr;
}
public static VkObjectTableEntryNVX New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkObjectTableEntryNVX(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkObjectTableEntryNVX AsPtr() { fixed(Data* ptr = &this) return new VkObjectTableEntryNVX(ptr); }
public VkObjectEntryTypeNVX Type;
public VkObjectEntryUsageFlagsNVX Flags;
}
public VkObjectEntryTypeNVX Type => ptr->Type;
public void SetType(VkObjectEntryTypeNVX value) => ptr->Type = value;
public VkObjectEntryUsageFlagsNVX Flags => ptr->Flags;
public void SetFlags(VkObjectEntryUsageFlagsNVX value) => ptr->Flags = value;
}
public unsafe partial struct VkOffset2D
{
//VkOffset2D
public int X;
public int Y;
}
public unsafe partial struct VkOffset3D
{
//VkOffset3D
public int X;
public int Y;
public int Z;
}
public unsafe partial struct VkPastPresentationTimingGOOGLE : IDisposable
{
//VkPastPresentationTimingGOOGLE
private VkPastPresentationTimingGOOGLE(Data* ptr)
{
this.ptr = ptr;
}
public static VkPastPresentationTimingGOOGLE New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPastPresentationTimingGOOGLE(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPastPresentationTimingGOOGLE AsPtr() { fixed(Data* ptr = &this) return new VkPastPresentationTimingGOOGLE(ptr); }
public uint PresentID;
public ulong DesiredPresentTime;
public ulong ActualPresentTime;
public ulong EarliestPresentTime;
public ulong PresentMargin;
}
public uint PresentID => ptr->PresentID;
public void SetPresentID(uint value) => ptr->PresentID = value;
public ulong DesiredPresentTime => ptr->DesiredPresentTime;
public void SetDesiredPresentTime(ulong value) => ptr->DesiredPresentTime = value;
public ulong ActualPresentTime => ptr->ActualPresentTime;
public void SetActualPresentTime(ulong value) => ptr->ActualPresentTime = value;
public ulong EarliestPresentTime => ptr->EarliestPresentTime;
public void SetEarliestPresentTime(ulong value) => ptr->EarliestPresentTime = value;
public ulong PresentMargin => ptr->PresentMargin;
public void SetPresentMargin(ulong value) => ptr->PresentMargin = value;
}
public unsafe partial struct VkPhysicalDeviceExternalBufferInfo : IDisposable
{
//VkPhysicalDeviceExternalBufferInfo
private VkPhysicalDeviceExternalBufferInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceExternalBufferInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceExternalBufferInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceExternalBufferInfo AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceExternalBufferInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkBufferCreateFlags Flags;
public VkBufferUsageFlags Usage;
public VkExternalMemoryHandleTypeFlagBits HandleType;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkBufferCreateFlags Flags => ptr->Flags;
public void SetFlags(VkBufferCreateFlags value) => ptr->Flags = value;
public VkBufferUsageFlags Usage => ptr->Usage;
public void SetUsage(VkBufferUsageFlags value) => ptr->Usage = value;
public VkExternalMemoryHandleTypeFlagBits HandleType => ptr->HandleType;
public void SetHandleType(VkExternalMemoryHandleTypeFlagBits value) => ptr->HandleType = value;
}
public unsafe partial struct VkPhysicalDeviceExternalFenceInfo : IDisposable
{
//VkPhysicalDeviceExternalFenceInfo
private VkPhysicalDeviceExternalFenceInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceExternalFenceInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceExternalFenceInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceExternalFenceInfo AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceExternalFenceInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkExternalFenceHandleTypeFlagBits HandleType;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkExternalFenceHandleTypeFlagBits HandleType => ptr->HandleType;
public void SetHandleType(VkExternalFenceHandleTypeFlagBits value) => ptr->HandleType = value;
}
public unsafe partial struct VkPhysicalDeviceExternalSemaphoreInfo : IDisposable
{
//VkPhysicalDeviceExternalSemaphoreInfo
private VkPhysicalDeviceExternalSemaphoreInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceExternalSemaphoreInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceExternalSemaphoreInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceExternalSemaphoreInfo AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceExternalSemaphoreInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkExternalSemaphoreHandleTypeFlagBits HandleType;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkExternalSemaphoreHandleTypeFlagBits HandleType => ptr->HandleType;
public void SetHandleType(VkExternalSemaphoreHandleTypeFlagBits value) => ptr->HandleType = value;
}
public unsafe partial struct VkPhysicalDeviceFeatures
{
//VkPhysicalDeviceFeatures
public VkBool32 RobustBufferAccess;
public VkBool32 FullDrawIndexUint32;
public VkBool32 ImageCubeArray;
public VkBool32 IndependentBlend;
public VkBool32 GeometryShader;
public VkBool32 TessellationShader;
public VkBool32 SampleRateShading;
public VkBool32 DualSrcBlend;
public VkBool32 LogicOp;
public VkBool32 MultiDrawIndirect;
public VkBool32 DrawIndirectFirstInstance;
public VkBool32 DepthClamp;
public VkBool32 DepthBiasClamp;
public VkBool32 FillModeNonSolid;
public VkBool32 DepthBounds;
public VkBool32 WideLines;
public VkBool32 LargePoints;
public VkBool32 AlphaToOne;
public VkBool32 MultiViewport;
public VkBool32 SamplerAnisotropy;
public VkBool32 TextureCompressionETC2;
public VkBool32 TextureCompressionASTCLDR;
public VkBool32 TextureCompressionBC;
public VkBool32 OcclusionQueryPrecise;
public VkBool32 PipelineStatisticsQuery;
public VkBool32 VertexPipelineStoresAndAtomics;
public VkBool32 FragmentStoresAndAtomics;
public VkBool32 ShaderTessellationAndGeometryPointSize;
public VkBool32 ShaderImageGatherExtended;
public VkBool32 ShaderStorageImageExtendedFormats;
public VkBool32 ShaderStorageImageMultisample;
public VkBool32 ShaderStorageImageReadWithoutFormat;
public VkBool32 ShaderStorageImageWriteWithoutFormat;
public VkBool32 ShaderUniformBufferArrayDynamicIndexing;
public VkBool32 ShaderSampledImageArrayDynamicIndexing;
public VkBool32 ShaderStorageBufferArrayDynamicIndexing;
public VkBool32 ShaderStorageImageArrayDynamicIndexing;
public VkBool32 ShaderClipDistance;
public VkBool32 ShaderCullDistance;
public VkBool32 ShaderFloat64;
public VkBool32 ShaderInt64;
public VkBool32 ShaderInt16;
public VkBool32 ShaderResourceResidency;
public VkBool32 ShaderResourceMinLod;
public VkBool32 SparseBinding;
public VkBool32 SparseResidencyBuffer;
public VkBool32 SparseResidencyImage2D;
public VkBool32 SparseResidencyImage3D;
public VkBool32 SparseResidency2Samples;
public VkBool32 SparseResidency4Samples;
public VkBool32 SparseResidency8Samples;
public VkBool32 SparseResidency16Samples;
public VkBool32 SparseResidencyAliased;
public VkBool32 VariableMultisampleRate;
public VkBool32 InheritedQueries;
}
public unsafe partial struct VkPhysicalDeviceFeatures2 : IDisposable
{
//VkPhysicalDeviceFeatures2
private VkPhysicalDeviceFeatures2(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceFeatures2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceFeatures2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceFeatures2 AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceFeatures2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPhysicalDeviceFeatures Features;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPhysicalDeviceFeatures Features => ptr->Features;
public void SetFeatures(VkPhysicalDeviceFeatures value) => ptr->Features = value;
}
public unsafe partial struct VkPhysicalDeviceGroupProperties : IDisposable
{
//VkPhysicalDeviceGroupProperties
private VkPhysicalDeviceGroupProperties(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceGroupProperties New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceGroupProperties(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceGroupProperties AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceGroupProperties(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint PhysicalDeviceCount;
public VkPhysicalDevice32 PhysicalDevices;
public VkBool32 SubsetAllocation;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint PhysicalDeviceCount => ptr->PhysicalDeviceCount;
public void SetPhysicalDeviceCount(uint value) => ptr->PhysicalDeviceCount = value;
public VkPhysicalDevice32 PhysicalDevices => ptr->PhysicalDevices;
public VkBool32 SubsetAllocation => ptr->SubsetAllocation;
public void SetSubsetAllocation(VkBool32 value) => ptr->SubsetAllocation = value;
}
public unsafe partial struct VkPhysicalDeviceImageFormatInfo2 : IDisposable
{
//VkPhysicalDeviceImageFormatInfo2
private VkPhysicalDeviceImageFormatInfo2(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceImageFormatInfo2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceImageFormatInfo2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceImageFormatInfo2 AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceImageFormatInfo2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkFormat Format;
public VkImageType Type;
public VkImageTiling Tiling;
public VkImageUsageFlags Usage;
public VkImageCreateFlags Flags;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkFormat Format => ptr->Format;
public void SetFormat(VkFormat value) => ptr->Format = value;
public VkImageType Type => ptr->Type;
public void SetType(VkImageType value) => ptr->Type = value;
public VkImageTiling Tiling => ptr->Tiling;
public void SetTiling(VkImageTiling value) => ptr->Tiling = value;
public VkImageUsageFlags Usage => ptr->Usage;
public void SetUsage(VkImageUsageFlags value) => ptr->Usage = value;
public VkImageCreateFlags Flags => ptr->Flags;
public void SetFlags(VkImageCreateFlags value) => ptr->Flags = value;
}
public unsafe partial struct VkPhysicalDeviceLimits
{
//VkPhysicalDeviceLimits
public uint MaxImageDimension1D;
public uint MaxImageDimension2D;
public uint MaxImageDimension3D;
public uint MaxImageDimensionCube;
public uint MaxImageArrayLayers;
public uint MaxTexelBufferElements;
public uint MaxUniformBufferRange;
public uint MaxStorageBufferRange;
public uint MaxPushConstantsSize;
public uint MaxMemoryAllocationCount;
public uint MaxSamplerAllocationCount;
public VkDeviceSize BufferImageGranularity;
public VkDeviceSize SparseAddressSpaceSize;
public uint MaxBoundDescriptorSets;
public uint MaxPerStageDescriptorSamplers;
public uint MaxPerStageDescriptorUniformBuffers;
public uint MaxPerStageDescriptorStorageBuffers;
public uint MaxPerStageDescriptorSampledImages;
public uint MaxPerStageDescriptorStorageImages;
public uint MaxPerStageDescriptorInputAttachments;
public uint MaxPerStageResources;
public uint MaxDescriptorSetSamplers;
public uint MaxDescriptorSetUniformBuffers;
public uint MaxDescriptorSetUniformBuffersDynamic;
public uint MaxDescriptorSetStorageBuffers;
public uint MaxDescriptorSetStorageBuffersDynamic;
public uint MaxDescriptorSetSampledImages;
public uint MaxDescriptorSetStorageImages;
public uint MaxDescriptorSetInputAttachments;
public uint MaxVertexInputAttributes;
public uint MaxVertexInputBindings;
public uint MaxVertexInputAttributeOffset;
public uint MaxVertexInputBindingStride;
public uint MaxVertexOutputComponents;
public uint MaxTessellationGenerationLevel;
public uint MaxTessellationPatchSize;
public uint MaxTessellationControlPerVertexInputComponents;
public uint MaxTessellationControlPerVertexOutputComponents;
public uint MaxTessellationControlPerPatchOutputComponents;
public uint MaxTessellationControlTotalOutputComponents;
public uint MaxTessellationEvaluationInputComponents;
public uint MaxTessellationEvaluationOutputComponents;
public uint MaxGeometryShaderInvocations;
public uint MaxGeometryInputComponents;
public uint MaxGeometryOutputComponents;
public uint MaxGeometryOutputVertices;
public uint MaxGeometryTotalOutputComponents;
public uint MaxFragmentInputComponents;
public uint MaxFragmentOutputAttachments;
public uint MaxFragmentDualSrcAttachments;
public uint MaxFragmentCombinedOutputResources;
public uint MaxComputeSharedMemorySize;
public fixed uint MaxComputeWorkGroupCount[3];
public uint MaxComputeWorkGroupInvocations;
public fixed uint MaxComputeWorkGroupSize[3];
public uint SubPixelPrecisionBits;
public uint SubTexelPrecisionBits;
public uint MipmapPrecisionBits;
public uint MaxDrawIndexedIndexValue;
public uint MaxDrawIndirectCount;
public float MaxSamplerLodBias;
public float MaxSamplerAnisotropy;
public uint MaxViewports;
public fixed uint MaxViewportDimensions[2];
public fixed float ViewportBoundsRange[2];
public uint ViewportSubPixelBits;
public UIntPtr MinMemoryMapAlignment;
public VkDeviceSize MinTexelBufferOffsetAlignment;
public VkDeviceSize MinUniformBufferOffsetAlignment;
public VkDeviceSize MinStorageBufferOffsetAlignment;
public int MinTexelOffset;
public uint MaxTexelOffset;
public int MinTexelGatherOffset;
public uint MaxTexelGatherOffset;
public float MinInterpolationOffset;
public float MaxInterpolationOffset;
public uint SubPixelInterpolationOffsetBits;
public uint MaxFramebufferWidth;
public uint MaxFramebufferHeight;
public uint MaxFramebufferLayers;
public VkSampleCountFlags FramebufferColorSampleCounts;
public VkSampleCountFlags FramebufferDepthSampleCounts;
public VkSampleCountFlags FramebufferStencilSampleCounts;
public VkSampleCountFlags FramebufferNoAttachmentsSampleCounts;
public uint MaxColorAttachments;
public VkSampleCountFlags SampledImageColorSampleCounts;
public VkSampleCountFlags SampledImageIntegerSampleCounts;
public VkSampleCountFlags SampledImageDepthSampleCounts;
public VkSampleCountFlags SampledImageStencilSampleCounts;
public VkSampleCountFlags StorageImageSampleCounts;
public uint MaxSampleMaskWords;
public VkBool32 TimestampComputeAndGraphics;
public float TimestampPeriod;
public uint MaxClipDistances;
public uint MaxCullDistances;
public uint MaxCombinedClipAndCullDistances;
public uint DiscreteQueuePriorities;
public fixed float PointSizeRange[2];
public fixed float LineWidthRange[2];
public float PointSizeGranularity;
public float LineWidthGranularity;
public VkBool32 StrictLines;
public VkBool32 StandardSampleLocations;
public VkDeviceSize OptimalBufferCopyOffsetAlignment;
public VkDeviceSize OptimalBufferCopyRowPitchAlignment;
public VkDeviceSize NonCoherentAtomSize;
}
public unsafe partial struct VkPhysicalDeviceMemoryProperties
{
//VkPhysicalDeviceMemoryProperties
public uint MemoryTypeCount;
public VkMemoryType32 MemoryTypes;
public uint MemoryHeapCount;
public VkMemoryHeap16 MemoryHeaps;
}
public unsafe partial struct VkPhysicalDeviceMemoryProperties2 : IDisposable
{
//VkPhysicalDeviceMemoryProperties2
private VkPhysicalDeviceMemoryProperties2(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceMemoryProperties2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceMemoryProperties2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceMemoryProperties2 AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceMemoryProperties2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPhysicalDeviceMemoryProperties MemoryProperties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPhysicalDeviceMemoryProperties MemoryProperties => ptr->MemoryProperties;
public void SetMemoryProperties(VkPhysicalDeviceMemoryProperties value) => ptr->MemoryProperties = value;
}
public unsafe partial struct VkPhysicalDeviceProperties
{
//VkPhysicalDeviceProperties
public uint ApiVersion;
public uint DriverVersion;
public uint VendorID;
public uint DeviceID;
public VkPhysicalDeviceType DeviceType;
public fixed byte DeviceName[256];
public fixed byte PipelineCacheUUID[16];
public VkPhysicalDeviceLimits Limits;
public VkPhysicalDeviceSparseProperties SparseProperties;
}
public unsafe partial struct VkPhysicalDeviceProperties2 : IDisposable
{
//VkPhysicalDeviceProperties2
private VkPhysicalDeviceProperties2(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceProperties2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceProperties2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceProperties2 AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceProperties2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPhysicalDeviceProperties Properties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPhysicalDeviceProperties Properties => ptr->Properties;
public void SetProperties(VkPhysicalDeviceProperties value) => ptr->Properties = value;
}
public unsafe partial struct VkPhysicalDeviceSparseImageFormatInfo2 : IDisposable
{
//VkPhysicalDeviceSparseImageFormatInfo2
private VkPhysicalDeviceSparseImageFormatInfo2(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceSparseImageFormatInfo2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceSparseImageFormatInfo2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceSparseImageFormatInfo2 AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceSparseImageFormatInfo2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkFormat Format;
public VkImageType Type;
public VkSampleCountFlagBits Samples;
public VkImageUsageFlags Usage;
public VkImageTiling Tiling;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkFormat Format => ptr->Format;
public void SetFormat(VkFormat value) => ptr->Format = value;
public VkImageType Type => ptr->Type;
public void SetType(VkImageType value) => ptr->Type = value;
public VkSampleCountFlagBits Samples => ptr->Samples;
public void SetSamples(VkSampleCountFlagBits value) => ptr->Samples = value;
public VkImageUsageFlags Usage => ptr->Usage;
public void SetUsage(VkImageUsageFlags value) => ptr->Usage = value;
public VkImageTiling Tiling => ptr->Tiling;
public void SetTiling(VkImageTiling value) => ptr->Tiling = value;
}
public unsafe partial struct VkPhysicalDeviceSparseProperties
{
//VkPhysicalDeviceSparseProperties
public VkBool32 ResidencyStandard2DBlockShape;
public VkBool32 ResidencyStandard2DMultisampleBlockShape;
public VkBool32 ResidencyStandard3DBlockShape;
public VkBool32 ResidencyAlignedMipSize;
public VkBool32 ResidencyNonResidentStrict;
}
public unsafe partial struct VkPhysicalDeviceSurfaceInfo2KHR : IDisposable
{
//VkPhysicalDeviceSurfaceInfo2KHR
private VkPhysicalDeviceSurfaceInfo2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkPhysicalDeviceSurfaceInfo2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPhysicalDeviceSurfaceInfo2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPhysicalDeviceSurfaceInfo2KHR AsPtr() { fixed(Data* ptr = &this) return new VkPhysicalDeviceSurfaceInfo2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSurfaceKHR Surface;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSurfaceKHR Surface => ptr->Surface;
public void SetSurface(VkSurfaceKHR value) => ptr->Surface = value;
}
public unsafe partial struct VkPipelineCacheCreateInfo : IDisposable
{
//VkPipelineCacheCreateInfo
private VkPipelineCacheCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineCacheCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineCacheCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineCacheCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineCacheCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineCacheCreateFlags Flags;
public UIntPtr InitialDataSize;
public IntPtr PInitialData;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineCacheCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineCacheCreateFlags value) => ptr->Flags = value;
public UIntPtr InitialDataSize => ptr->InitialDataSize;
public void SetInitialDataSize(UIntPtr value) => ptr->InitialDataSize = value;
public IntPtr PInitialData => ptr->PInitialData;
public void SetPInitialData(IntPtr value) => ptr->PInitialData = value;
}
public unsafe partial struct VkPipelineColorBlendAttachmentState : IDisposable
{
//VkPipelineColorBlendAttachmentState
private VkPipelineColorBlendAttachmentState(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineColorBlendAttachmentState New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineColorBlendAttachmentState(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineColorBlendAttachmentState AsPtr() { fixed(Data* ptr = &this) return new VkPipelineColorBlendAttachmentState(ptr); }
public VkBool32 BlendEnable;
public VkBlendFactor SrcColorBlendFactor;
public VkBlendFactor DstColorBlendFactor;
public VkBlendOp ColorBlendOp;
public VkBlendFactor SrcAlphaBlendFactor;
public VkBlendFactor DstAlphaBlendFactor;
public VkBlendOp AlphaBlendOp;
public VkColorComponentFlags ColorWriteMask;
}
public VkBool32 BlendEnable => ptr->BlendEnable;
public void SetBlendEnable(VkBool32 value) => ptr->BlendEnable = value;
public VkBlendFactor SrcColorBlendFactor => ptr->SrcColorBlendFactor;
public void SetSrcColorBlendFactor(VkBlendFactor value) => ptr->SrcColorBlendFactor = value;
public VkBlendFactor DstColorBlendFactor => ptr->DstColorBlendFactor;
public void SetDstColorBlendFactor(VkBlendFactor value) => ptr->DstColorBlendFactor = value;
public VkBlendOp ColorBlendOp => ptr->ColorBlendOp;
public void SetColorBlendOp(VkBlendOp value) => ptr->ColorBlendOp = value;
public VkBlendFactor SrcAlphaBlendFactor => ptr->SrcAlphaBlendFactor;
public void SetSrcAlphaBlendFactor(VkBlendFactor value) => ptr->SrcAlphaBlendFactor = value;
public VkBlendFactor DstAlphaBlendFactor => ptr->DstAlphaBlendFactor;
public void SetDstAlphaBlendFactor(VkBlendFactor value) => ptr->DstAlphaBlendFactor = value;
public VkBlendOp AlphaBlendOp => ptr->AlphaBlendOp;
public void SetAlphaBlendOp(VkBlendOp value) => ptr->AlphaBlendOp = value;
public VkColorComponentFlags ColorWriteMask => ptr->ColorWriteMask;
public void SetColorWriteMask(VkColorComponentFlags value) => ptr->ColorWriteMask = value;
}
public unsafe partial struct VkPipelineColorBlendStateCreateInfo : IDisposable
{
//VkPipelineColorBlendStateCreateInfo
private VkPipelineColorBlendStateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineColorBlendStateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineColorBlendStateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineColorBlendStateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineColorBlendStateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineColorBlendStateCreateFlags Flags;
public VkBool32 LogicOpEnable;
public VkLogicOp LogicOp;
public uint AttachmentCount;
public VkPipelineColorBlendAttachmentState PAttachments;
public Float4 BlendConstants;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineColorBlendStateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineColorBlendStateCreateFlags value) => ptr->Flags = value;
public VkBool32 LogicOpEnable => ptr->LogicOpEnable;
public void SetLogicOpEnable(VkBool32 value) => ptr->LogicOpEnable = value;
public VkLogicOp LogicOp => ptr->LogicOp;
public void SetLogicOp(VkLogicOp value) => ptr->LogicOp = value;
public uint AttachmentCount => ptr->AttachmentCount;
public void SetAttachmentCount(uint value) => ptr->AttachmentCount = value;
public VkPipelineColorBlendAttachmentState PAttachments => ptr->PAttachments;
public void SetPAttachments(VkPipelineColorBlendAttachmentState value) => ptr->PAttachments = value;
public Float4 BlendConstants => ptr->BlendConstants;
}
public unsafe partial struct VkPipelineDepthStencilStateCreateInfo : IDisposable
{
//VkPipelineDepthStencilStateCreateInfo
private VkPipelineDepthStencilStateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineDepthStencilStateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineDepthStencilStateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineDepthStencilStateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineDepthStencilStateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineDepthStencilStateCreateFlags Flags;
public VkBool32 DepthTestEnable;
public VkBool32 DepthWriteEnable;
public VkCompareOp DepthCompareOp;
public VkBool32 DepthBoundsTestEnable;
public VkBool32 StencilTestEnable;
public VkStencilOpState Front;
public VkStencilOpState Back;
public float MinDepthBounds;
public float MaxDepthBounds;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineDepthStencilStateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineDepthStencilStateCreateFlags value) => ptr->Flags = value;
public VkBool32 DepthTestEnable => ptr->DepthTestEnable;
public void SetDepthTestEnable(VkBool32 value) => ptr->DepthTestEnable = value;
public VkBool32 DepthWriteEnable => ptr->DepthWriteEnable;
public void SetDepthWriteEnable(VkBool32 value) => ptr->DepthWriteEnable = value;
public VkCompareOp DepthCompareOp => ptr->DepthCompareOp;
public void SetDepthCompareOp(VkCompareOp value) => ptr->DepthCompareOp = value;
public VkBool32 DepthBoundsTestEnable => ptr->DepthBoundsTestEnable;
public void SetDepthBoundsTestEnable(VkBool32 value) => ptr->DepthBoundsTestEnable = value;
public VkBool32 StencilTestEnable => ptr->StencilTestEnable;
public void SetStencilTestEnable(VkBool32 value) => ptr->StencilTestEnable = value;
public VkStencilOpState Front => ptr->Front;
public void SetFront(VkStencilOpState value) => ptr->Front = value;
public VkStencilOpState Back => ptr->Back;
public void SetBack(VkStencilOpState value) => ptr->Back = value;
public float MinDepthBounds => ptr->MinDepthBounds;
public void SetMinDepthBounds(float value) => ptr->MinDepthBounds = value;
public float MaxDepthBounds => ptr->MaxDepthBounds;
public void SetMaxDepthBounds(float value) => ptr->MaxDepthBounds = value;
}
public unsafe partial struct VkPipelineDynamicStateCreateInfo : IDisposable
{
//VkPipelineDynamicStateCreateInfo
private VkPipelineDynamicStateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineDynamicStateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineDynamicStateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineDynamicStateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineDynamicStateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineDynamicStateCreateFlags Flags;
public uint DynamicStateCount;
public VkDynamicState* PDynamicStates;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineDynamicStateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineDynamicStateCreateFlags value) => ptr->Flags = value;
public uint DynamicStateCount => ptr->DynamicStateCount;
public void SetDynamicStateCount(uint value) => ptr->DynamicStateCount = value;
public VkDynamicState* PDynamicStates => ptr->PDynamicStates;
public void SetPDynamicStates(VkDynamicState* value) => ptr->PDynamicStates = value;
}
public unsafe partial struct VkPipelineInputAssemblyStateCreateInfo : IDisposable
{
//VkPipelineInputAssemblyStateCreateInfo
private VkPipelineInputAssemblyStateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineInputAssemblyStateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineInputAssemblyStateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineInputAssemblyStateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineInputAssemblyStateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineInputAssemblyStateCreateFlags Flags;
public VkPrimitiveTopology Topology;
public VkBool32 PrimitiveRestartEnable;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineInputAssemblyStateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineInputAssemblyStateCreateFlags value) => ptr->Flags = value;
public VkPrimitiveTopology Topology => ptr->Topology;
public void SetTopology(VkPrimitiveTopology value) => ptr->Topology = value;
public VkBool32 PrimitiveRestartEnable => ptr->PrimitiveRestartEnable;
public void SetPrimitiveRestartEnable(VkBool32 value) => ptr->PrimitiveRestartEnable = value;
}
public unsafe partial struct VkPipelineLayoutCreateInfo : IDisposable
{
//VkPipelineLayoutCreateInfo
private VkPipelineLayoutCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineLayoutCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineLayoutCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineLayoutCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineLayoutCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineLayoutCreateFlags Flags;
public uint SetLayoutCount;
public VkDescriptorSetLayout* PSetLayouts;
public uint PushConstantRangeCount;
public VkPushConstantRange PPushConstantRanges;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineLayoutCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineLayoutCreateFlags value) => ptr->Flags = value;
public uint SetLayoutCount => ptr->SetLayoutCount;
public void SetSetLayoutCount(uint value) => ptr->SetLayoutCount = value;
public VkDescriptorSetLayout* PSetLayouts => ptr->PSetLayouts;
public void SetPSetLayouts(VkDescriptorSetLayout* value) => ptr->PSetLayouts = value;
public uint PushConstantRangeCount => ptr->PushConstantRangeCount;
public void SetPushConstantRangeCount(uint value) => ptr->PushConstantRangeCount = value;
public VkPushConstantRange PPushConstantRanges => ptr->PPushConstantRanges;
public void SetPPushConstantRanges(VkPushConstantRange value) => ptr->PPushConstantRanges = value;
}
public unsafe partial struct VkPipelineMultisampleStateCreateInfo : IDisposable
{
//VkPipelineMultisampleStateCreateInfo
private VkPipelineMultisampleStateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineMultisampleStateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineMultisampleStateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineMultisampleStateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineMultisampleStateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineMultisampleStateCreateFlags Flags;
public VkSampleCountFlagBits RasterizationSamples;
public VkBool32 SampleShadingEnable;
public float MinSampleShading;
public VkSampleMask* PSampleMask;
public VkBool32 AlphaToCoverageEnable;
public VkBool32 AlphaToOneEnable;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineMultisampleStateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineMultisampleStateCreateFlags value) => ptr->Flags = value;
public VkSampleCountFlagBits RasterizationSamples => ptr->RasterizationSamples;
public void SetRasterizationSamples(VkSampleCountFlagBits value) => ptr->RasterizationSamples = value;
public VkBool32 SampleShadingEnable => ptr->SampleShadingEnable;
public void SetSampleShadingEnable(VkBool32 value) => ptr->SampleShadingEnable = value;
public float MinSampleShading => ptr->MinSampleShading;
public void SetMinSampleShading(float value) => ptr->MinSampleShading = value;
public VkSampleMask* PSampleMask => ptr->PSampleMask;
public void SetPSampleMask(VkSampleMask* value) => ptr->PSampleMask = value;
public VkBool32 AlphaToCoverageEnable => ptr->AlphaToCoverageEnable;
public void SetAlphaToCoverageEnable(VkBool32 value) => ptr->AlphaToCoverageEnable = value;
public VkBool32 AlphaToOneEnable => ptr->AlphaToOneEnable;
public void SetAlphaToOneEnable(VkBool32 value) => ptr->AlphaToOneEnable = value;
}
public unsafe partial struct VkPipelineRasterizationStateCreateInfo : IDisposable
{
//VkPipelineRasterizationStateCreateInfo
private VkPipelineRasterizationStateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineRasterizationStateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineRasterizationStateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineRasterizationStateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineRasterizationStateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineRasterizationStateCreateFlags Flags;
public VkBool32 DepthClampEnable;
public VkBool32 RasterizerDiscardEnable;
public VkPolygonMode PolygonMode;
public VkCullModeFlags CullMode;
public VkFrontFace FrontFace;
public VkBool32 DepthBiasEnable;
public float DepthBiasConstantFactor;
public float DepthBiasClamp;
public float DepthBiasSlopeFactor;
public float LineWidth;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineRasterizationStateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineRasterizationStateCreateFlags value) => ptr->Flags = value;
public VkBool32 DepthClampEnable => ptr->DepthClampEnable;
public void SetDepthClampEnable(VkBool32 value) => ptr->DepthClampEnable = value;
public VkBool32 RasterizerDiscardEnable => ptr->RasterizerDiscardEnable;
public void SetRasterizerDiscardEnable(VkBool32 value) => ptr->RasterizerDiscardEnable = value;
public VkPolygonMode PolygonMode => ptr->PolygonMode;
public void SetPolygonMode(VkPolygonMode value) => ptr->PolygonMode = value;
public VkCullModeFlags CullMode => ptr->CullMode;
public void SetCullMode(VkCullModeFlags value) => ptr->CullMode = value;
public VkFrontFace FrontFace => ptr->FrontFace;
public void SetFrontFace(VkFrontFace value) => ptr->FrontFace = value;
public VkBool32 DepthBiasEnable => ptr->DepthBiasEnable;
public void SetDepthBiasEnable(VkBool32 value) => ptr->DepthBiasEnable = value;
public float DepthBiasConstantFactor => ptr->DepthBiasConstantFactor;
public void SetDepthBiasConstantFactor(float value) => ptr->DepthBiasConstantFactor = value;
public float DepthBiasClamp => ptr->DepthBiasClamp;
public void SetDepthBiasClamp(float value) => ptr->DepthBiasClamp = value;
public float DepthBiasSlopeFactor => ptr->DepthBiasSlopeFactor;
public void SetDepthBiasSlopeFactor(float value) => ptr->DepthBiasSlopeFactor = value;
public float LineWidth => ptr->LineWidth;
public void SetLineWidth(float value) => ptr->LineWidth = value;
}
public unsafe partial struct VkPipelineShaderStageCreateInfo
{
//VkPipelineShaderStageCreateInfo
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineShaderStageCreateFlags Flags;
public VkShaderStageFlagBits Stage;
public VkShaderModule Module;
public CString PName;
public VkSpecializationInfo PSpecializationInfo;
}
public unsafe partial struct VkPipelineTessellationStateCreateInfo : IDisposable
{
//VkPipelineTessellationStateCreateInfo
private VkPipelineTessellationStateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineTessellationStateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineTessellationStateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineTessellationStateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineTessellationStateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineTessellationStateCreateFlags Flags;
public uint PatchControlPoints;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineTessellationStateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineTessellationStateCreateFlags value) => ptr->Flags = value;
public uint PatchControlPoints => ptr->PatchControlPoints;
public void SetPatchControlPoints(uint value) => ptr->PatchControlPoints = value;
}
public unsafe partial struct VkPipelineVertexInputStateCreateInfo : IDisposable
{
//VkPipelineVertexInputStateCreateInfo
private VkPipelineVertexInputStateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineVertexInputStateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineVertexInputStateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineVertexInputStateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineVertexInputStateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineVertexInputStateCreateFlags Flags;
public uint VertexBindingDescriptionCount;
public VkVertexInputBindingDescription PVertexBindingDescriptions;
public uint VertexAttributeDescriptionCount;
public VkVertexInputAttributeDescription PVertexAttributeDescriptions;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineVertexInputStateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineVertexInputStateCreateFlags value) => ptr->Flags = value;
public uint VertexBindingDescriptionCount => ptr->VertexBindingDescriptionCount;
public void SetVertexBindingDescriptionCount(uint value) => ptr->VertexBindingDescriptionCount = value;
public VkVertexInputBindingDescription PVertexBindingDescriptions => ptr->PVertexBindingDescriptions;
public void SetPVertexBindingDescriptions(VkVertexInputBindingDescription value) => ptr->PVertexBindingDescriptions = value;
public uint VertexAttributeDescriptionCount => ptr->VertexAttributeDescriptionCount;
public void SetVertexAttributeDescriptionCount(uint value) => ptr->VertexAttributeDescriptionCount = value;
public VkVertexInputAttributeDescription PVertexAttributeDescriptions => ptr->PVertexAttributeDescriptions;
public void SetPVertexAttributeDescriptions(VkVertexInputAttributeDescription value) => ptr->PVertexAttributeDescriptions = value;
}
public unsafe partial struct VkPipelineViewportStateCreateInfo : IDisposable
{
//VkPipelineViewportStateCreateInfo
private VkPipelineViewportStateCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkPipelineViewportStateCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPipelineViewportStateCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPipelineViewportStateCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkPipelineViewportStateCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineViewportStateCreateFlags Flags;
public uint ViewportCount;
public VkViewport PViewports;
public uint ScissorCount;
public VkRect2D* PScissors;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineViewportStateCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineViewportStateCreateFlags value) => ptr->Flags = value;
public uint ViewportCount => ptr->ViewportCount;
public void SetViewportCount(uint value) => ptr->ViewportCount = value;
public VkViewport PViewports => ptr->PViewports;
public void SetPViewports(VkViewport value) => ptr->PViewports = value;
public uint ScissorCount => ptr->ScissorCount;
public void SetScissorCount(uint value) => ptr->ScissorCount = value;
public VkRect2D* PScissors => ptr->PScissors;
public void SetPScissors(VkRect2D* value) => ptr->PScissors = value;
}
public unsafe partial struct VkPresentInfoKHR : IDisposable
{
//VkPresentInfoKHR
private VkPresentInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkPresentInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPresentInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPresentInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkPresentInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint WaitSemaphoreCount;
public VkSemaphore* PWaitSemaphores;
public uint SwapchainCount;
public VkSwapchainKHR* PSwapchains;
public uint* PImageIndices;
public VkResult* PResults;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint WaitSemaphoreCount => ptr->WaitSemaphoreCount;
public void SetWaitSemaphoreCount(uint value) => ptr->WaitSemaphoreCount = value;
public VkSemaphore* PWaitSemaphores => ptr->PWaitSemaphores;
public void SetPWaitSemaphores(VkSemaphore* value) => ptr->PWaitSemaphores = value;
public uint SwapchainCount => ptr->SwapchainCount;
public void SetSwapchainCount(uint value) => ptr->SwapchainCount = value;
public VkSwapchainKHR* PSwapchains => ptr->PSwapchains;
public void SetPSwapchains(VkSwapchainKHR* value) => ptr->PSwapchains = value;
public uint* PImageIndices => ptr->PImageIndices;
public void SetPImageIndices(uint* value) => ptr->PImageIndices = value;
public VkResult* PResults => ptr->PResults;
public void SetPResults(VkResult* value) => ptr->PResults = value;
}
public unsafe partial struct VkPushConstantRange : IDisposable
{
//VkPushConstantRange
private VkPushConstantRange(Data* ptr)
{
this.ptr = ptr;
}
public static VkPushConstantRange New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkPushConstantRange(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkPushConstantRange AsPtr() { fixed(Data* ptr = &this) return new VkPushConstantRange(ptr); }
public VkShaderStageFlags StageFlags;
public uint Offset;
public uint Size;
}
public VkShaderStageFlags StageFlags => ptr->StageFlags;
public void SetStageFlags(VkShaderStageFlags value) => ptr->StageFlags = value;
public uint Offset => ptr->Offset;
public void SetOffset(uint value) => ptr->Offset = value;
public uint Size => ptr->Size;
public void SetSize(uint value) => ptr->Size = value;
}
public unsafe partial struct VkQueryPoolCreateInfo : IDisposable
{
//VkQueryPoolCreateInfo
private VkQueryPoolCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkQueryPoolCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkQueryPoolCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkQueryPoolCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkQueryPoolCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkQueryPoolCreateFlags Flags;
public VkQueryType QueryType;
public uint QueryCount;
public VkQueryPipelineStatisticFlags PipelineStatistics;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkQueryPoolCreateFlags Flags => ptr->Flags;
public void SetFlags(VkQueryPoolCreateFlags value) => ptr->Flags = value;
public VkQueryType QueryType => ptr->QueryType;
public void SetQueryType(VkQueryType value) => ptr->QueryType = value;
public uint QueryCount => ptr->QueryCount;
public void SetQueryCount(uint value) => ptr->QueryCount = value;
public VkQueryPipelineStatisticFlags PipelineStatistics => ptr->PipelineStatistics;
public void SetPipelineStatistics(VkQueryPipelineStatisticFlags value) => ptr->PipelineStatistics = value;
}
public unsafe partial struct VkQueueFamilyProperties
{
//VkQueueFamilyProperties
public VkQueueFlags QueueFlags;
public uint QueueCount;
public uint TimestampValidBits;
public VkExtent3D MinImageTransferGranularity;
}
public unsafe partial struct VkQueueFamilyProperties2 : IDisposable
{
//VkQueueFamilyProperties2
private VkQueueFamilyProperties2(Data* ptr)
{
this.ptr = ptr;
}
public static VkQueueFamilyProperties2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkQueueFamilyProperties2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkQueueFamilyProperties2 AsPtr() { fixed(Data* ptr = &this) return new VkQueueFamilyProperties2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkQueueFamilyProperties QueueFamilyProperties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkQueueFamilyProperties QueueFamilyProperties => ptr->QueueFamilyProperties;
public void SetQueueFamilyProperties(VkQueueFamilyProperties value) => ptr->QueueFamilyProperties = value;
}
public unsafe partial struct VkRayTracingPipelineCreateInfoNV : IDisposable
{
//VkRayTracingPipelineCreateInfoNV
private VkRayTracingPipelineCreateInfoNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkRayTracingPipelineCreateInfoNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkRayTracingPipelineCreateInfoNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkRayTracingPipelineCreateInfoNV AsPtr() { fixed(Data* ptr = &this) return new VkRayTracingPipelineCreateInfoNV(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkPipelineCreateFlags Flags;
public uint StageCount;
public VkPipelineShaderStageCreateInfo* PStages;
public uint GroupCount;
public VkRayTracingShaderGroupCreateInfoNV PGroups;
public uint MaxRecursionDepth;
public VkPipelineLayout Layout;
public VkPipeline BasePipelineHandle;
public int BasePipelineIndex;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkPipelineCreateFlags Flags => ptr->Flags;
public void SetFlags(VkPipelineCreateFlags value) => ptr->Flags = value;
public uint StageCount => ptr->StageCount;
public void SetStageCount(uint value) => ptr->StageCount = value;
public VkPipelineShaderStageCreateInfo* PStages => ptr->PStages;
public void SetPStages(VkPipelineShaderStageCreateInfo* value) => ptr->PStages = value;
public uint GroupCount => ptr->GroupCount;
public void SetGroupCount(uint value) => ptr->GroupCount = value;
public VkRayTracingShaderGroupCreateInfoNV PGroups => ptr->PGroups;
public void SetPGroups(VkRayTracingShaderGroupCreateInfoNV value) => ptr->PGroups = value;
public uint MaxRecursionDepth => ptr->MaxRecursionDepth;
public void SetMaxRecursionDepth(uint value) => ptr->MaxRecursionDepth = value;
public VkPipelineLayout Layout => ptr->Layout;
public void SetLayout(VkPipelineLayout value) => ptr->Layout = value;
public VkPipeline BasePipelineHandle => ptr->BasePipelineHandle;
public void SetBasePipelineHandle(VkPipeline value) => ptr->BasePipelineHandle = value;
public int BasePipelineIndex => ptr->BasePipelineIndex;
public void SetBasePipelineIndex(int value) => ptr->BasePipelineIndex = value;
}
public unsafe partial struct VkRayTracingShaderGroupCreateInfoNV : IDisposable
{
//VkRayTracingShaderGroupCreateInfoNV
private VkRayTracingShaderGroupCreateInfoNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkRayTracingShaderGroupCreateInfoNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkRayTracingShaderGroupCreateInfoNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkRayTracingShaderGroupCreateInfoNV AsPtr() { fixed(Data* ptr = &this) return new VkRayTracingShaderGroupCreateInfoNV(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkRayTracingShaderGroupTypeNV Type;
public uint GeneralShader;
public uint ClosestHitShader;
public uint AnyHitShader;
public uint IntersectionShader;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkRayTracingShaderGroupTypeNV Type => ptr->Type;
public void SetType(VkRayTracingShaderGroupTypeNV value) => ptr->Type = value;
public uint GeneralShader => ptr->GeneralShader;
public void SetGeneralShader(uint value) => ptr->GeneralShader = value;
public uint ClosestHitShader => ptr->ClosestHitShader;
public void SetClosestHitShader(uint value) => ptr->ClosestHitShader = value;
public uint AnyHitShader => ptr->AnyHitShader;
public void SetAnyHitShader(uint value) => ptr->AnyHitShader = value;
public uint IntersectionShader => ptr->IntersectionShader;
public void SetIntersectionShader(uint value) => ptr->IntersectionShader = value;
}
public unsafe partial struct VkRect2D
{
//VkRect2D
public VkOffset2D Offset;
public VkExtent2D Extent;
}
public unsafe partial struct VkRefreshCycleDurationGOOGLE : IDisposable
{
//VkRefreshCycleDurationGOOGLE
private VkRefreshCycleDurationGOOGLE(Data* ptr)
{
this.ptr = ptr;
}
public static VkRefreshCycleDurationGOOGLE New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkRefreshCycleDurationGOOGLE(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkRefreshCycleDurationGOOGLE AsPtr() { fixed(Data* ptr = &this) return new VkRefreshCycleDurationGOOGLE(ptr); }
public ulong RefreshDuration;
}
public ulong RefreshDuration => ptr->RefreshDuration;
public void SetRefreshDuration(ulong value) => ptr->RefreshDuration = value;
}
public unsafe partial struct VkRenderPassBeginInfo : IDisposable
{
//VkRenderPassBeginInfo
private VkRenderPassBeginInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkRenderPassBeginInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkRenderPassBeginInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkRenderPassBeginInfo AsPtr() { fixed(Data* ptr = &this) return new VkRenderPassBeginInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkRenderPass RenderPass;
public VkFramebuffer Framebuffer;
public VkRect2D RenderArea;
public uint ClearValueCount;
public VkClearValue* PClearValues;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkRenderPass RenderPass => ptr->RenderPass;
public void SetRenderPass(VkRenderPass value) => ptr->RenderPass = value;
public VkFramebuffer Framebuffer => ptr->Framebuffer;
public void SetFramebuffer(VkFramebuffer value) => ptr->Framebuffer = value;
public VkRect2D RenderArea => ptr->RenderArea;
public void SetRenderArea(VkRect2D value) => ptr->RenderArea = value;
public uint ClearValueCount => ptr->ClearValueCount;
public void SetClearValueCount(uint value) => ptr->ClearValueCount = value;
public VkClearValue* PClearValues => ptr->PClearValues;
public void SetPClearValues(VkClearValue* value) => ptr->PClearValues = value;
}
public unsafe partial struct VkRenderPassCreateInfo : IDisposable
{
//VkRenderPassCreateInfo
private VkRenderPassCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkRenderPassCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkRenderPassCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkRenderPassCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkRenderPassCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkRenderPassCreateFlags Flags;
public uint AttachmentCount;
public VkAttachmentDescription PAttachments;
public uint SubpassCount;
public VkSubpassDescription PSubpasses;
public uint DependencyCount;
public VkSubpassDependency PDependencies;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkRenderPassCreateFlags Flags => ptr->Flags;
public void SetFlags(VkRenderPassCreateFlags value) => ptr->Flags = value;
public uint AttachmentCount => ptr->AttachmentCount;
public void SetAttachmentCount(uint value) => ptr->AttachmentCount = value;
public VkAttachmentDescription PAttachments => ptr->PAttachments;
public void SetPAttachments(VkAttachmentDescription value) => ptr->PAttachments = value;
public uint SubpassCount => ptr->SubpassCount;
public void SetSubpassCount(uint value) => ptr->SubpassCount = value;
public VkSubpassDescription PSubpasses => ptr->PSubpasses;
public void SetPSubpasses(VkSubpassDescription value) => ptr->PSubpasses = value;
public uint DependencyCount => ptr->DependencyCount;
public void SetDependencyCount(uint value) => ptr->DependencyCount = value;
public VkSubpassDependency PDependencies => ptr->PDependencies;
public void SetPDependencies(VkSubpassDependency value) => ptr->PDependencies = value;
}
public unsafe partial struct VkRenderPassCreateInfo2KHR : IDisposable
{
//VkRenderPassCreateInfo2KHR
private VkRenderPassCreateInfo2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkRenderPassCreateInfo2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkRenderPassCreateInfo2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkRenderPassCreateInfo2KHR AsPtr() { fixed(Data* ptr = &this) return new VkRenderPassCreateInfo2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkRenderPassCreateFlags Flags;
public uint AttachmentCount;
public VkAttachmentDescription2KHR PAttachments;
public uint SubpassCount;
public VkSubpassDescription2KHR PSubpasses;
public uint DependencyCount;
public VkSubpassDependency2KHR PDependencies;
public uint CorrelatedViewMaskCount;
public uint* PCorrelatedViewMasks;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkRenderPassCreateFlags Flags => ptr->Flags;
public void SetFlags(VkRenderPassCreateFlags value) => ptr->Flags = value;
public uint AttachmentCount => ptr->AttachmentCount;
public void SetAttachmentCount(uint value) => ptr->AttachmentCount = value;
public VkAttachmentDescription2KHR PAttachments => ptr->PAttachments;
public void SetPAttachments(VkAttachmentDescription2KHR value) => ptr->PAttachments = value;
public uint SubpassCount => ptr->SubpassCount;
public void SetSubpassCount(uint value) => ptr->SubpassCount = value;
public VkSubpassDescription2KHR PSubpasses => ptr->PSubpasses;
public void SetPSubpasses(VkSubpassDescription2KHR value) => ptr->PSubpasses = value;
public uint DependencyCount => ptr->DependencyCount;
public void SetDependencyCount(uint value) => ptr->DependencyCount = value;
public VkSubpassDependency2KHR PDependencies => ptr->PDependencies;
public void SetPDependencies(VkSubpassDependency2KHR value) => ptr->PDependencies = value;
public uint CorrelatedViewMaskCount => ptr->CorrelatedViewMaskCount;
public void SetCorrelatedViewMaskCount(uint value) => ptr->CorrelatedViewMaskCount = value;
public uint* PCorrelatedViewMasks => ptr->PCorrelatedViewMasks;
public void SetPCorrelatedViewMasks(uint* value) => ptr->PCorrelatedViewMasks = value;
}
public unsafe partial struct VkSampleLocationEXT : IDisposable
{
//VkSampleLocationEXT
private VkSampleLocationEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkSampleLocationEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSampleLocationEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSampleLocationEXT AsPtr() { fixed(Data* ptr = &this) return new VkSampleLocationEXT(ptr); }
public float X;
public float Y;
}
public float X => ptr->X;
public void SetX(float value) => ptr->X = value;
public float Y => ptr->Y;
public void SetY(float value) => ptr->Y = value;
}
public unsafe partial struct VkSampleLocationsInfoEXT : IDisposable
{
//VkSampleLocationsInfoEXT
private VkSampleLocationsInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkSampleLocationsInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSampleLocationsInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSampleLocationsInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkSampleLocationsInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSampleCountFlagBits SampleLocationsPerPixel;
public VkExtent2D SampleLocationGridSize;
public uint SampleLocationsCount;
public VkSampleLocationEXT PSampleLocations;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSampleCountFlagBits SampleLocationsPerPixel => ptr->SampleLocationsPerPixel;
public void SetSampleLocationsPerPixel(VkSampleCountFlagBits value) => ptr->SampleLocationsPerPixel = value;
public VkExtent2D SampleLocationGridSize => ptr->SampleLocationGridSize;
public void SetSampleLocationGridSize(VkExtent2D value) => ptr->SampleLocationGridSize = value;
public uint SampleLocationsCount => ptr->SampleLocationsCount;
public void SetSampleLocationsCount(uint value) => ptr->SampleLocationsCount = value;
public VkSampleLocationEXT PSampleLocations => ptr->PSampleLocations;
public void SetPSampleLocations(VkSampleLocationEXT value) => ptr->PSampleLocations = value;
}
public unsafe partial struct VkSamplerCreateInfo : IDisposable
{
//VkSamplerCreateInfo
private VkSamplerCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkSamplerCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSamplerCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSamplerCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkSamplerCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSamplerCreateFlags Flags;
public VkFilter MagFilter;
public VkFilter MinFilter;
public VkSamplerMipmapMode MipmapMode;
public VkSamplerAddressMode AddressModeU;
public VkSamplerAddressMode AddressModeV;
public VkSamplerAddressMode AddressModeW;
public float MipLodBias;
public VkBool32 AnisotropyEnable;
public float MaxAnisotropy;
public VkBool32 CompareEnable;
public VkCompareOp CompareOp;
public float MinLod;
public float MaxLod;
public VkBorderColor BorderColor;
public VkBool32 UnnormalizedCoordinates;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSamplerCreateFlags Flags => ptr->Flags;
public void SetFlags(VkSamplerCreateFlags value) => ptr->Flags = value;
public VkFilter MagFilter => ptr->MagFilter;
public void SetMagFilter(VkFilter value) => ptr->MagFilter = value;
public VkFilter MinFilter => ptr->MinFilter;
public void SetMinFilter(VkFilter value) => ptr->MinFilter = value;
public VkSamplerMipmapMode MipmapMode => ptr->MipmapMode;
public void SetMipmapMode(VkSamplerMipmapMode value) => ptr->MipmapMode = value;
public VkSamplerAddressMode AddressModeU => ptr->AddressModeU;
public void SetAddressModeU(VkSamplerAddressMode value) => ptr->AddressModeU = value;
public VkSamplerAddressMode AddressModeV => ptr->AddressModeV;
public void SetAddressModeV(VkSamplerAddressMode value) => ptr->AddressModeV = value;
public VkSamplerAddressMode AddressModeW => ptr->AddressModeW;
public void SetAddressModeW(VkSamplerAddressMode value) => ptr->AddressModeW = value;
public float MipLodBias => ptr->MipLodBias;
public void SetMipLodBias(float value) => ptr->MipLodBias = value;
public VkBool32 AnisotropyEnable => ptr->AnisotropyEnable;
public void SetAnisotropyEnable(VkBool32 value) => ptr->AnisotropyEnable = value;
public float MaxAnisotropy => ptr->MaxAnisotropy;
public void SetMaxAnisotropy(float value) => ptr->MaxAnisotropy = value;
public VkBool32 CompareEnable => ptr->CompareEnable;
public void SetCompareEnable(VkBool32 value) => ptr->CompareEnable = value;
public VkCompareOp CompareOp => ptr->CompareOp;
public void SetCompareOp(VkCompareOp value) => ptr->CompareOp = value;
public float MinLod => ptr->MinLod;
public void SetMinLod(float value) => ptr->MinLod = value;
public float MaxLod => ptr->MaxLod;
public void SetMaxLod(float value) => ptr->MaxLod = value;
public VkBorderColor BorderColor => ptr->BorderColor;
public void SetBorderColor(VkBorderColor value) => ptr->BorderColor = value;
public VkBool32 UnnormalizedCoordinates => ptr->UnnormalizedCoordinates;
public void SetUnnormalizedCoordinates(VkBool32 value) => ptr->UnnormalizedCoordinates = value;
}
public unsafe partial struct VkSamplerYcbcrConversionCreateInfo : IDisposable
{
//VkSamplerYcbcrConversionCreateInfo
private VkSamplerYcbcrConversionCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkSamplerYcbcrConversionCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSamplerYcbcrConversionCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSamplerYcbcrConversionCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkSamplerYcbcrConversionCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkFormat Format;
public VkSamplerYcbcrModelConversion YcbcrModel;
public VkSamplerYcbcrRange YcbcrRange;
public VkComponentMapping Components;
public VkChromaLocation XChromaOffset;
public VkChromaLocation YChromaOffset;
public VkFilter ChromaFilter;
public VkBool32 ForceExplicitReconstruction;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkFormat Format => ptr->Format;
public void SetFormat(VkFormat value) => ptr->Format = value;
public VkSamplerYcbcrModelConversion YcbcrModel => ptr->YcbcrModel;
public void SetYcbcrModel(VkSamplerYcbcrModelConversion value) => ptr->YcbcrModel = value;
public VkSamplerYcbcrRange YcbcrRange => ptr->YcbcrRange;
public void SetYcbcrRange(VkSamplerYcbcrRange value) => ptr->YcbcrRange = value;
public VkComponentMapping Components => ptr->Components;
public void SetComponents(VkComponentMapping value) => ptr->Components = value;
public VkChromaLocation XChromaOffset => ptr->XChromaOffset;
public void SetXChromaOffset(VkChromaLocation value) => ptr->XChromaOffset = value;
public VkChromaLocation YChromaOffset => ptr->YChromaOffset;
public void SetYChromaOffset(VkChromaLocation value) => ptr->YChromaOffset = value;
public VkFilter ChromaFilter => ptr->ChromaFilter;
public void SetChromaFilter(VkFilter value) => ptr->ChromaFilter = value;
public VkBool32 ForceExplicitReconstruction => ptr->ForceExplicitReconstruction;
public void SetForceExplicitReconstruction(VkBool32 value) => ptr->ForceExplicitReconstruction = value;
}
public unsafe partial struct VkSemaphoreCreateInfo : IDisposable
{
//VkSemaphoreCreateInfo
private VkSemaphoreCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkSemaphoreCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSemaphoreCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSemaphoreCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkSemaphoreCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSemaphoreCreateFlags Flags;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSemaphoreCreateFlags Flags => ptr->Flags;
public void SetFlags(VkSemaphoreCreateFlags value) => ptr->Flags = value;
}
public unsafe partial struct VkSemaphoreGetFdInfoKHR : IDisposable
{
//VkSemaphoreGetFdInfoKHR
private VkSemaphoreGetFdInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkSemaphoreGetFdInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSemaphoreGetFdInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSemaphoreGetFdInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkSemaphoreGetFdInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSemaphore Semaphore;
public VkExternalSemaphoreHandleTypeFlagBits HandleType;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSemaphore Semaphore => ptr->Semaphore;
public void SetSemaphore(VkSemaphore value) => ptr->Semaphore = value;
public VkExternalSemaphoreHandleTypeFlagBits HandleType => ptr->HandleType;
public void SetHandleType(VkExternalSemaphoreHandleTypeFlagBits value) => ptr->HandleType = value;
}
public unsafe partial struct VkShaderModuleCreateInfo : IDisposable
{
//VkShaderModuleCreateInfo
private VkShaderModuleCreateInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkShaderModuleCreateInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkShaderModuleCreateInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkShaderModuleCreateInfo AsPtr() { fixed(Data* ptr = &this) return new VkShaderModuleCreateInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkShaderModuleCreateFlags Flags;
public UIntPtr CodeSize;
public uint* PCode;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkShaderModuleCreateFlags Flags => ptr->Flags;
public void SetFlags(VkShaderModuleCreateFlags value) => ptr->Flags = value;
public UIntPtr CodeSize => ptr->CodeSize;
public void SetCodeSize(UIntPtr value) => ptr->CodeSize = value;
public uint* PCode => ptr->PCode;
public void SetPCode(uint* value) => ptr->PCode = value;
}
public unsafe partial struct VkShadingRatePaletteNV : IDisposable
{
//VkShadingRatePaletteNV
private VkShadingRatePaletteNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkShadingRatePaletteNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkShadingRatePaletteNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkShadingRatePaletteNV AsPtr() { fixed(Data* ptr = &this) return new VkShadingRatePaletteNV(ptr); }
public uint ShadingRatePaletteEntryCount;
public VkShadingRatePaletteEntryNV* PShadingRatePaletteEntries;
}
public uint ShadingRatePaletteEntryCount => ptr->ShadingRatePaletteEntryCount;
public void SetShadingRatePaletteEntryCount(uint value) => ptr->ShadingRatePaletteEntryCount = value;
public VkShadingRatePaletteEntryNV* PShadingRatePaletteEntries => ptr->PShadingRatePaletteEntries;
public void SetPShadingRatePaletteEntries(VkShadingRatePaletteEntryNV* value) => ptr->PShadingRatePaletteEntries = value;
}
public unsafe partial struct VkSparseBufferMemoryBindInfo : IDisposable
{
//VkSparseBufferMemoryBindInfo
private VkSparseBufferMemoryBindInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkSparseBufferMemoryBindInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSparseBufferMemoryBindInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSparseBufferMemoryBindInfo AsPtr() { fixed(Data* ptr = &this) return new VkSparseBufferMemoryBindInfo(ptr); }
public VkBuffer Buffer;
public uint BindCount;
public VkSparseMemoryBind PBinds;
}
public VkBuffer Buffer => ptr->Buffer;
public void SetBuffer(VkBuffer value) => ptr->Buffer = value;
public uint BindCount => ptr->BindCount;
public void SetBindCount(uint value) => ptr->BindCount = value;
public VkSparseMemoryBind PBinds => ptr->PBinds;
public void SetPBinds(VkSparseMemoryBind value) => ptr->PBinds = value;
}
public unsafe partial struct VkSparseImageFormatProperties
{
//VkSparseImageFormatProperties
public VkImageAspectFlags AspectMask;
public VkExtent3D ImageGranularity;
public VkSparseImageFormatFlags Flags;
}
public unsafe partial struct VkSparseImageFormatProperties2 : IDisposable
{
//VkSparseImageFormatProperties2
private VkSparseImageFormatProperties2(Data* ptr)
{
this.ptr = ptr;
}
public static VkSparseImageFormatProperties2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSparseImageFormatProperties2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSparseImageFormatProperties2 AsPtr() { fixed(Data* ptr = &this) return new VkSparseImageFormatProperties2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSparseImageFormatProperties Properties;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSparseImageFormatProperties Properties => ptr->Properties;
public void SetProperties(VkSparseImageFormatProperties value) => ptr->Properties = value;
}
public unsafe partial struct VkSparseImageMemoryBind : IDisposable
{
//VkSparseImageMemoryBind
private VkSparseImageMemoryBind(Data* ptr)
{
this.ptr = ptr;
}
public static VkSparseImageMemoryBind New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSparseImageMemoryBind(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSparseImageMemoryBind AsPtr() { fixed(Data* ptr = &this) return new VkSparseImageMemoryBind(ptr); }
public VkImageSubresource Subresource;
public VkOffset3D Offset;
public VkExtent3D Extent;
public VkDeviceMemory Memory;
public VkDeviceSize MemoryOffset;
public VkSparseMemoryBindFlags Flags;
}
public VkImageSubresource Subresource => ptr->Subresource;
public void SetSubresource(VkImageSubresource value) => ptr->Subresource = value;
public VkOffset3D Offset => ptr->Offset;
public void SetOffset(VkOffset3D value) => ptr->Offset = value;
public VkExtent3D Extent => ptr->Extent;
public void SetExtent(VkExtent3D value) => ptr->Extent = value;
public VkDeviceMemory Memory => ptr->Memory;
public void SetMemory(VkDeviceMemory value) => ptr->Memory = value;
public VkDeviceSize MemoryOffset => ptr->MemoryOffset;
public void SetMemoryOffset(VkDeviceSize value) => ptr->MemoryOffset = value;
public VkSparseMemoryBindFlags Flags => ptr->Flags;
public void SetFlags(VkSparseMemoryBindFlags value) => ptr->Flags = value;
}
public unsafe partial struct VkSparseImageMemoryBindInfo : IDisposable
{
//VkSparseImageMemoryBindInfo
private VkSparseImageMemoryBindInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkSparseImageMemoryBindInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSparseImageMemoryBindInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSparseImageMemoryBindInfo AsPtr() { fixed(Data* ptr = &this) return new VkSparseImageMemoryBindInfo(ptr); }
public VkImage Image;
public uint BindCount;
public VkSparseImageMemoryBind PBinds;
}
public VkImage Image => ptr->Image;
public void SetImage(VkImage value) => ptr->Image = value;
public uint BindCount => ptr->BindCount;
public void SetBindCount(uint value) => ptr->BindCount = value;
public VkSparseImageMemoryBind PBinds => ptr->PBinds;
public void SetPBinds(VkSparseImageMemoryBind value) => ptr->PBinds = value;
}
public unsafe partial struct VkSparseImageMemoryRequirements
{
//VkSparseImageMemoryRequirements
public VkSparseImageFormatProperties FormatProperties;
public uint ImageMipTailFirstLod;
public VkDeviceSize ImageMipTailSize;
public VkDeviceSize ImageMipTailOffset;
public VkDeviceSize ImageMipTailStride;
}
public unsafe partial struct VkSparseImageMemoryRequirements2 : IDisposable
{
//VkSparseImageMemoryRequirements2
private VkSparseImageMemoryRequirements2(Data* ptr)
{
this.ptr = ptr;
}
public static VkSparseImageMemoryRequirements2 New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSparseImageMemoryRequirements2(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSparseImageMemoryRequirements2 AsPtr() { fixed(Data* ptr = &this) return new VkSparseImageMemoryRequirements2(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSparseImageMemoryRequirements MemoryRequirements;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSparseImageMemoryRequirements MemoryRequirements => ptr->MemoryRequirements;
public void SetMemoryRequirements(VkSparseImageMemoryRequirements value) => ptr->MemoryRequirements = value;
}
public unsafe partial struct VkSparseImageOpaqueMemoryBindInfo : IDisposable
{
//VkSparseImageOpaqueMemoryBindInfo
private VkSparseImageOpaqueMemoryBindInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkSparseImageOpaqueMemoryBindInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSparseImageOpaqueMemoryBindInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSparseImageOpaqueMemoryBindInfo AsPtr() { fixed(Data* ptr = &this) return new VkSparseImageOpaqueMemoryBindInfo(ptr); }
public VkImage Image;
public uint BindCount;
public VkSparseMemoryBind PBinds;
}
public VkImage Image => ptr->Image;
public void SetImage(VkImage value) => ptr->Image = value;
public uint BindCount => ptr->BindCount;
public void SetBindCount(uint value) => ptr->BindCount = value;
public VkSparseMemoryBind PBinds => ptr->PBinds;
public void SetPBinds(VkSparseMemoryBind value) => ptr->PBinds = value;
}
public unsafe partial struct VkSparseMemoryBind : IDisposable
{
//VkSparseMemoryBind
private VkSparseMemoryBind(Data* ptr)
{
this.ptr = ptr;
}
public static VkSparseMemoryBind New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSparseMemoryBind(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSparseMemoryBind AsPtr() { fixed(Data* ptr = &this) return new VkSparseMemoryBind(ptr); }
public VkDeviceSize ResourceOffset;
public VkDeviceSize Size;
public VkDeviceMemory Memory;
public VkDeviceSize MemoryOffset;
public VkSparseMemoryBindFlags Flags;
}
public VkDeviceSize ResourceOffset => ptr->ResourceOffset;
public void SetResourceOffset(VkDeviceSize value) => ptr->ResourceOffset = value;
public VkDeviceSize Size => ptr->Size;
public void SetSize(VkDeviceSize value) => ptr->Size = value;
public VkDeviceMemory Memory => ptr->Memory;
public void SetMemory(VkDeviceMemory value) => ptr->Memory = value;
public VkDeviceSize MemoryOffset => ptr->MemoryOffset;
public void SetMemoryOffset(VkDeviceSize value) => ptr->MemoryOffset = value;
public VkSparseMemoryBindFlags Flags => ptr->Flags;
public void SetFlags(VkSparseMemoryBindFlags value) => ptr->Flags = value;
}
public unsafe partial struct VkSpecializationInfo : IDisposable
{
//VkSpecializationInfo
private VkSpecializationInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkSpecializationInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSpecializationInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSpecializationInfo AsPtr() { fixed(Data* ptr = &this) return new VkSpecializationInfo(ptr); }
public uint MapEntryCount;
public VkSpecializationMapEntry PMapEntries;
public UIntPtr DataSize;
public IntPtr PData;
}
public uint MapEntryCount => ptr->MapEntryCount;
public void SetMapEntryCount(uint value) => ptr->MapEntryCount = value;
public VkSpecializationMapEntry PMapEntries => ptr->PMapEntries;
public void SetPMapEntries(VkSpecializationMapEntry value) => ptr->PMapEntries = value;
public UIntPtr DataSize => ptr->DataSize;
public void SetDataSize(UIntPtr value) => ptr->DataSize = value;
public IntPtr PData => ptr->PData;
public void SetPData(IntPtr value) => ptr->PData = value;
}
public unsafe partial struct VkSpecializationMapEntry : IDisposable
{
//VkSpecializationMapEntry
private VkSpecializationMapEntry(Data* ptr)
{
this.ptr = ptr;
}
public static VkSpecializationMapEntry New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSpecializationMapEntry(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSpecializationMapEntry AsPtr() { fixed(Data* ptr = &this) return new VkSpecializationMapEntry(ptr); }
public uint ConstantID;
public uint Offset;
public UIntPtr Size;
}
public uint ConstantID => ptr->ConstantID;
public void SetConstantID(uint value) => ptr->ConstantID = value;
public uint Offset => ptr->Offset;
public void SetOffset(uint value) => ptr->Offset = value;
public UIntPtr Size => ptr->Size;
public void SetSize(UIntPtr value) => ptr->Size = value;
}
public unsafe partial struct VkStencilOpState
{
//VkStencilOpState
public VkStencilOp FailOp;
public VkStencilOp PassOp;
public VkStencilOp DepthFailOp;
public VkCompareOp CompareOp;
public uint CompareMask;
public uint WriteMask;
public uint Reference;
}
public unsafe partial struct VkSubmitInfo : IDisposable
{
//VkSubmitInfo
private VkSubmitInfo(Data* ptr)
{
this.ptr = ptr;
}
public static VkSubmitInfo New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSubmitInfo(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSubmitInfo AsPtr() { fixed(Data* ptr = &this) return new VkSubmitInfo(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint WaitSemaphoreCount;
public VkSemaphore* PWaitSemaphores;
public VkPipelineStageFlags* PWaitDstStageMask;
public uint CommandBufferCount;
public VkCommandBuffer* PCommandBuffers;
public uint SignalSemaphoreCount;
public VkSemaphore* PSignalSemaphores;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint WaitSemaphoreCount => ptr->WaitSemaphoreCount;
public void SetWaitSemaphoreCount(uint value) => ptr->WaitSemaphoreCount = value;
public VkSemaphore* PWaitSemaphores => ptr->PWaitSemaphores;
public void SetPWaitSemaphores(VkSemaphore* value) => ptr->PWaitSemaphores = value;
public VkPipelineStageFlags* PWaitDstStageMask => ptr->PWaitDstStageMask;
public void SetPWaitDstStageMask(VkPipelineStageFlags* value) => ptr->PWaitDstStageMask = value;
public uint CommandBufferCount => ptr->CommandBufferCount;
public void SetCommandBufferCount(uint value) => ptr->CommandBufferCount = value;
public VkCommandBuffer* PCommandBuffers => ptr->PCommandBuffers;
public void SetPCommandBuffers(VkCommandBuffer* value) => ptr->PCommandBuffers = value;
public uint SignalSemaphoreCount => ptr->SignalSemaphoreCount;
public void SetSignalSemaphoreCount(uint value) => ptr->SignalSemaphoreCount = value;
public VkSemaphore* PSignalSemaphores => ptr->PSignalSemaphores;
public void SetPSignalSemaphores(VkSemaphore* value) => ptr->PSignalSemaphores = value;
}
public unsafe partial struct VkSubpassBeginInfoKHR : IDisposable
{
//VkSubpassBeginInfoKHR
private VkSubpassBeginInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkSubpassBeginInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSubpassBeginInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSubpassBeginInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkSubpassBeginInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSubpassContents Contents;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSubpassContents Contents => ptr->Contents;
public void SetContents(VkSubpassContents value) => ptr->Contents = value;
}
public unsafe partial struct VkSubpassDependency : IDisposable
{
//VkSubpassDependency
private VkSubpassDependency(Data* ptr)
{
this.ptr = ptr;
}
public static VkSubpassDependency New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSubpassDependency(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSubpassDependency AsPtr() { fixed(Data* ptr = &this) return new VkSubpassDependency(ptr); }
public uint SrcSubpass;
public uint DstSubpass;
public VkPipelineStageFlags SrcStageMask;
public VkPipelineStageFlags DstStageMask;
public VkAccessFlags SrcAccessMask;
public VkAccessFlags DstAccessMask;
public VkDependencyFlags DependencyFlags;
}
public uint SrcSubpass => ptr->SrcSubpass;
public void SetSrcSubpass(uint value) => ptr->SrcSubpass = value;
public uint DstSubpass => ptr->DstSubpass;
public void SetDstSubpass(uint value) => ptr->DstSubpass = value;
public VkPipelineStageFlags SrcStageMask => ptr->SrcStageMask;
public void SetSrcStageMask(VkPipelineStageFlags value) => ptr->SrcStageMask = value;
public VkPipelineStageFlags DstStageMask => ptr->DstStageMask;
public void SetDstStageMask(VkPipelineStageFlags value) => ptr->DstStageMask = value;
public VkAccessFlags SrcAccessMask => ptr->SrcAccessMask;
public void SetSrcAccessMask(VkAccessFlags value) => ptr->SrcAccessMask = value;
public VkAccessFlags DstAccessMask => ptr->DstAccessMask;
public void SetDstAccessMask(VkAccessFlags value) => ptr->DstAccessMask = value;
public VkDependencyFlags DependencyFlags => ptr->DependencyFlags;
public void SetDependencyFlags(VkDependencyFlags value) => ptr->DependencyFlags = value;
}
public unsafe partial struct VkSubpassDependency2KHR : IDisposable
{
//VkSubpassDependency2KHR
private VkSubpassDependency2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkSubpassDependency2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSubpassDependency2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSubpassDependency2KHR AsPtr() { fixed(Data* ptr = &this) return new VkSubpassDependency2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint SrcSubpass;
public uint DstSubpass;
public VkPipelineStageFlags SrcStageMask;
public VkPipelineStageFlags DstStageMask;
public VkAccessFlags SrcAccessMask;
public VkAccessFlags DstAccessMask;
public VkDependencyFlags DependencyFlags;
public int ViewOffset;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint SrcSubpass => ptr->SrcSubpass;
public void SetSrcSubpass(uint value) => ptr->SrcSubpass = value;
public uint DstSubpass => ptr->DstSubpass;
public void SetDstSubpass(uint value) => ptr->DstSubpass = value;
public VkPipelineStageFlags SrcStageMask => ptr->SrcStageMask;
public void SetSrcStageMask(VkPipelineStageFlags value) => ptr->SrcStageMask = value;
public VkPipelineStageFlags DstStageMask => ptr->DstStageMask;
public void SetDstStageMask(VkPipelineStageFlags value) => ptr->DstStageMask = value;
public VkAccessFlags SrcAccessMask => ptr->SrcAccessMask;
public void SetSrcAccessMask(VkAccessFlags value) => ptr->SrcAccessMask = value;
public VkAccessFlags DstAccessMask => ptr->DstAccessMask;
public void SetDstAccessMask(VkAccessFlags value) => ptr->DstAccessMask = value;
public VkDependencyFlags DependencyFlags => ptr->DependencyFlags;
public void SetDependencyFlags(VkDependencyFlags value) => ptr->DependencyFlags = value;
public int ViewOffset => ptr->ViewOffset;
public void SetViewOffset(int value) => ptr->ViewOffset = value;
}
public unsafe partial struct VkSubpassDescription : IDisposable
{
//VkSubpassDescription
private VkSubpassDescription(Data* ptr)
{
this.ptr = ptr;
}
public static VkSubpassDescription New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSubpassDescription(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSubpassDescription AsPtr() { fixed(Data* ptr = &this) return new VkSubpassDescription(ptr); }
public VkSubpassDescriptionFlags Flags;
public VkPipelineBindPoint PipelineBindPoint;
public uint InputAttachmentCount;
public VkAttachmentReference PInputAttachments;
public uint ColorAttachmentCount;
public VkAttachmentReference PColorAttachments;
public VkAttachmentReference PResolveAttachments;
public VkAttachmentReference PDepthStencilAttachment;
public uint PreserveAttachmentCount;
public uint* PPreserveAttachments;
}
public VkSubpassDescriptionFlags Flags => ptr->Flags;
public void SetFlags(VkSubpassDescriptionFlags value) => ptr->Flags = value;
public VkPipelineBindPoint PipelineBindPoint => ptr->PipelineBindPoint;
public void SetPipelineBindPoint(VkPipelineBindPoint value) => ptr->PipelineBindPoint = value;
public uint InputAttachmentCount => ptr->InputAttachmentCount;
public void SetInputAttachmentCount(uint value) => ptr->InputAttachmentCount = value;
public VkAttachmentReference PInputAttachments => ptr->PInputAttachments;
public void SetPInputAttachments(VkAttachmentReference value) => ptr->PInputAttachments = value;
public uint ColorAttachmentCount => ptr->ColorAttachmentCount;
public void SetColorAttachmentCount(uint value) => ptr->ColorAttachmentCount = value;
public VkAttachmentReference PColorAttachments => ptr->PColorAttachments;
public void SetPColorAttachments(VkAttachmentReference value) => ptr->PColorAttachments = value;
public VkAttachmentReference PResolveAttachments => ptr->PResolveAttachments;
public void SetPResolveAttachments(VkAttachmentReference value) => ptr->PResolveAttachments = value;
public VkAttachmentReference PDepthStencilAttachment => ptr->PDepthStencilAttachment;
public void SetPDepthStencilAttachment(VkAttachmentReference value) => ptr->PDepthStencilAttachment = value;
public uint PreserveAttachmentCount => ptr->PreserveAttachmentCount;
public void SetPreserveAttachmentCount(uint value) => ptr->PreserveAttachmentCount = value;
public uint* PPreserveAttachments => ptr->PPreserveAttachments;
public void SetPPreserveAttachments(uint* value) => ptr->PPreserveAttachments = value;
}
public unsafe partial struct VkSubpassDescription2KHR : IDisposable
{
//VkSubpassDescription2KHR
private VkSubpassDescription2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkSubpassDescription2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSubpassDescription2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSubpassDescription2KHR AsPtr() { fixed(Data* ptr = &this) return new VkSubpassDescription2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSubpassDescriptionFlags Flags;
public VkPipelineBindPoint PipelineBindPoint;
public uint ViewMask;
public uint InputAttachmentCount;
public VkAttachmentReference2KHR PInputAttachments;
public uint ColorAttachmentCount;
public VkAttachmentReference2KHR PColorAttachments;
public VkAttachmentReference2KHR PResolveAttachments;
public VkAttachmentReference2KHR PDepthStencilAttachment;
public uint PreserveAttachmentCount;
public uint* PPreserveAttachments;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSubpassDescriptionFlags Flags => ptr->Flags;
public void SetFlags(VkSubpassDescriptionFlags value) => ptr->Flags = value;
public VkPipelineBindPoint PipelineBindPoint => ptr->PipelineBindPoint;
public void SetPipelineBindPoint(VkPipelineBindPoint value) => ptr->PipelineBindPoint = value;
public uint ViewMask => ptr->ViewMask;
public void SetViewMask(uint value) => ptr->ViewMask = value;
public uint InputAttachmentCount => ptr->InputAttachmentCount;
public void SetInputAttachmentCount(uint value) => ptr->InputAttachmentCount = value;
public VkAttachmentReference2KHR PInputAttachments => ptr->PInputAttachments;
public void SetPInputAttachments(VkAttachmentReference2KHR value) => ptr->PInputAttachments = value;
public uint ColorAttachmentCount => ptr->ColorAttachmentCount;
public void SetColorAttachmentCount(uint value) => ptr->ColorAttachmentCount = value;
public VkAttachmentReference2KHR PColorAttachments => ptr->PColorAttachments;
public void SetPColorAttachments(VkAttachmentReference2KHR value) => ptr->PColorAttachments = value;
public VkAttachmentReference2KHR PResolveAttachments => ptr->PResolveAttachments;
public void SetPResolveAttachments(VkAttachmentReference2KHR value) => ptr->PResolveAttachments = value;
public VkAttachmentReference2KHR PDepthStencilAttachment => ptr->PDepthStencilAttachment;
public void SetPDepthStencilAttachment(VkAttachmentReference2KHR value) => ptr->PDepthStencilAttachment = value;
public uint PreserveAttachmentCount => ptr->PreserveAttachmentCount;
public void SetPreserveAttachmentCount(uint value) => ptr->PreserveAttachmentCount = value;
public uint* PPreserveAttachments => ptr->PPreserveAttachments;
public void SetPPreserveAttachments(uint* value) => ptr->PPreserveAttachments = value;
}
public unsafe partial struct VkSubpassEndInfoKHR : IDisposable
{
//VkSubpassEndInfoKHR
private VkSubpassEndInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkSubpassEndInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSubpassEndInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSubpassEndInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkSubpassEndInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
}
public unsafe partial struct VkSubresourceLayout : IDisposable
{
//VkSubresourceLayout
private VkSubresourceLayout(Data* ptr)
{
this.ptr = ptr;
}
public static VkSubresourceLayout New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSubresourceLayout(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSubresourceLayout AsPtr() { fixed(Data* ptr = &this) return new VkSubresourceLayout(ptr); }
public VkDeviceSize Offset;
public VkDeviceSize Size;
public VkDeviceSize RowPitch;
public VkDeviceSize ArrayPitch;
public VkDeviceSize DepthPitch;
}
public VkDeviceSize Offset => ptr->Offset;
public void SetOffset(VkDeviceSize value) => ptr->Offset = value;
public VkDeviceSize Size => ptr->Size;
public void SetSize(VkDeviceSize value) => ptr->Size = value;
public VkDeviceSize RowPitch => ptr->RowPitch;
public void SetRowPitch(VkDeviceSize value) => ptr->RowPitch = value;
public VkDeviceSize ArrayPitch => ptr->ArrayPitch;
public void SetArrayPitch(VkDeviceSize value) => ptr->ArrayPitch = value;
public VkDeviceSize DepthPitch => ptr->DepthPitch;
public void SetDepthPitch(VkDeviceSize value) => ptr->DepthPitch = value;
}
public unsafe partial struct VkSurfaceCapabilities2EXT : IDisposable
{
//VkSurfaceCapabilities2EXT
private VkSurfaceCapabilities2EXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkSurfaceCapabilities2EXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSurfaceCapabilities2EXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSurfaceCapabilities2EXT AsPtr() { fixed(Data* ptr = &this) return new VkSurfaceCapabilities2EXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public uint MinImageCount;
public uint MaxImageCount;
public VkExtent2D CurrentExtent;
public VkExtent2D MinImageExtent;
public VkExtent2D MaxImageExtent;
public uint MaxImageArrayLayers;
public VkSurfaceTransformFlagsKHR SupportedTransforms;
public VkSurfaceTransformFlagBitsKHR CurrentTransform;
public VkCompositeAlphaFlagsKHR SupportedCompositeAlpha;
public VkImageUsageFlags SupportedUsageFlags;
public VkSurfaceCounterFlagsEXT SupportedSurfaceCounters;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public uint MinImageCount => ptr->MinImageCount;
public void SetMinImageCount(uint value) => ptr->MinImageCount = value;
public uint MaxImageCount => ptr->MaxImageCount;
public void SetMaxImageCount(uint value) => ptr->MaxImageCount = value;
public VkExtent2D CurrentExtent => ptr->CurrentExtent;
public void SetCurrentExtent(VkExtent2D value) => ptr->CurrentExtent = value;
public VkExtent2D MinImageExtent => ptr->MinImageExtent;
public void SetMinImageExtent(VkExtent2D value) => ptr->MinImageExtent = value;
public VkExtent2D MaxImageExtent => ptr->MaxImageExtent;
public void SetMaxImageExtent(VkExtent2D value) => ptr->MaxImageExtent = value;
public uint MaxImageArrayLayers => ptr->MaxImageArrayLayers;
public void SetMaxImageArrayLayers(uint value) => ptr->MaxImageArrayLayers = value;
public VkSurfaceTransformFlagsKHR SupportedTransforms => ptr->SupportedTransforms;
public void SetSupportedTransforms(VkSurfaceTransformFlagsKHR value) => ptr->SupportedTransforms = value;
public VkSurfaceTransformFlagBitsKHR CurrentTransform => ptr->CurrentTransform;
public void SetCurrentTransform(VkSurfaceTransformFlagBitsKHR value) => ptr->CurrentTransform = value;
public VkCompositeAlphaFlagsKHR SupportedCompositeAlpha => ptr->SupportedCompositeAlpha;
public void SetSupportedCompositeAlpha(VkCompositeAlphaFlagsKHR value) => ptr->SupportedCompositeAlpha = value;
public VkImageUsageFlags SupportedUsageFlags => ptr->SupportedUsageFlags;
public void SetSupportedUsageFlags(VkImageUsageFlags value) => ptr->SupportedUsageFlags = value;
public VkSurfaceCounterFlagsEXT SupportedSurfaceCounters => ptr->SupportedSurfaceCounters;
public void SetSupportedSurfaceCounters(VkSurfaceCounterFlagsEXT value) => ptr->SupportedSurfaceCounters = value;
}
public unsafe partial struct VkSurfaceCapabilities2KHR : IDisposable
{
//VkSurfaceCapabilities2KHR
private VkSurfaceCapabilities2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkSurfaceCapabilities2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSurfaceCapabilities2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSurfaceCapabilities2KHR AsPtr() { fixed(Data* ptr = &this) return new VkSurfaceCapabilities2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSurfaceCapabilitiesKHR SurfaceCapabilities;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSurfaceCapabilitiesKHR SurfaceCapabilities => ptr->SurfaceCapabilities;
public void SetSurfaceCapabilities(VkSurfaceCapabilitiesKHR value) => ptr->SurfaceCapabilities = value;
}
public unsafe partial struct VkSurfaceCapabilitiesKHR
{
//VkSurfaceCapabilitiesKHR
public uint MinImageCount;
public uint MaxImageCount;
public VkExtent2D CurrentExtent;
public VkExtent2D MinImageExtent;
public VkExtent2D MaxImageExtent;
public uint MaxImageArrayLayers;
public VkSurfaceTransformFlagsKHR SupportedTransforms;
public VkSurfaceTransformFlagBitsKHR CurrentTransform;
public VkCompositeAlphaFlagsKHR SupportedCompositeAlpha;
public VkImageUsageFlags SupportedUsageFlags;
}
public unsafe partial struct VkSurfaceFormat2KHR : IDisposable
{
//VkSurfaceFormat2KHR
private VkSurfaceFormat2KHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkSurfaceFormat2KHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSurfaceFormat2KHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSurfaceFormat2KHR AsPtr() { fixed(Data* ptr = &this) return new VkSurfaceFormat2KHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSurfaceFormatKHR SurfaceFormat;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSurfaceFormatKHR SurfaceFormat => ptr->SurfaceFormat;
public void SetSurfaceFormat(VkSurfaceFormatKHR value) => ptr->SurfaceFormat = value;
}
public unsafe partial struct VkSurfaceFormatKHR
{
//VkSurfaceFormatKHR
public VkFormat Format;
public VkColorSpaceKHR ColorSpace;
}
public unsafe partial struct VkSwapchainCreateInfoKHR : IDisposable
{
//VkSwapchainCreateInfoKHR
private VkSwapchainCreateInfoKHR(Data* ptr)
{
this.ptr = ptr;
}
public static VkSwapchainCreateInfoKHR New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkSwapchainCreateInfoKHR(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkSwapchainCreateInfoKHR AsPtr() { fixed(Data* ptr = &this) return new VkSwapchainCreateInfoKHR(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkSwapchainCreateFlagsKHR Flags;
public VkSurfaceKHR Surface;
public uint MinImageCount;
public VkFormat ImageFormat;
public VkColorSpaceKHR ImageColorSpace;
public VkExtent2D ImageExtent;
public uint ImageArrayLayers;
public VkImageUsageFlags ImageUsage;
public VkSharingMode ImageSharingMode;
public uint QueueFamilyIndexCount;
public uint* PQueueFamilyIndices;
public VkSurfaceTransformFlagBitsKHR PreTransform;
public VkCompositeAlphaFlagBitsKHR CompositeAlpha;
public VkPresentModeKHR PresentMode;
public VkBool32 Clipped;
public VkSwapchainKHR OldSwapchain;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkSwapchainCreateFlagsKHR Flags => ptr->Flags;
public void SetFlags(VkSwapchainCreateFlagsKHR value) => ptr->Flags = value;
public VkSurfaceKHR Surface => ptr->Surface;
public void SetSurface(VkSurfaceKHR value) => ptr->Surface = value;
public uint MinImageCount => ptr->MinImageCount;
public void SetMinImageCount(uint value) => ptr->MinImageCount = value;
public VkFormat ImageFormat => ptr->ImageFormat;
public void SetImageFormat(VkFormat value) => ptr->ImageFormat = value;
public VkColorSpaceKHR ImageColorSpace => ptr->ImageColorSpace;
public void SetImageColorSpace(VkColorSpaceKHR value) => ptr->ImageColorSpace = value;
public VkExtent2D ImageExtent => ptr->ImageExtent;
public void SetImageExtent(VkExtent2D value) => ptr->ImageExtent = value;
public uint ImageArrayLayers => ptr->ImageArrayLayers;
public void SetImageArrayLayers(uint value) => ptr->ImageArrayLayers = value;
public VkImageUsageFlags ImageUsage => ptr->ImageUsage;
public void SetImageUsage(VkImageUsageFlags value) => ptr->ImageUsage = value;
public VkSharingMode ImageSharingMode => ptr->ImageSharingMode;
public void SetImageSharingMode(VkSharingMode value) => ptr->ImageSharingMode = value;
public uint QueueFamilyIndexCount => ptr->QueueFamilyIndexCount;
public void SetQueueFamilyIndexCount(uint value) => ptr->QueueFamilyIndexCount = value;
public uint* PQueueFamilyIndices => ptr->PQueueFamilyIndices;
public void SetPQueueFamilyIndices(uint* value) => ptr->PQueueFamilyIndices = value;
public VkSurfaceTransformFlagBitsKHR PreTransform => ptr->PreTransform;
public void SetPreTransform(VkSurfaceTransformFlagBitsKHR value) => ptr->PreTransform = value;
public VkCompositeAlphaFlagBitsKHR CompositeAlpha => ptr->CompositeAlpha;
public void SetCompositeAlpha(VkCompositeAlphaFlagBitsKHR value) => ptr->CompositeAlpha = value;
public VkPresentModeKHR PresentMode => ptr->PresentMode;
public void SetPresentMode(VkPresentModeKHR value) => ptr->PresentMode = value;
public VkBool32 Clipped => ptr->Clipped;
public void SetClipped(VkBool32 value) => ptr->Clipped = value;
public VkSwapchainKHR OldSwapchain => ptr->OldSwapchain;
public void SetOldSwapchain(VkSwapchainKHR value) => ptr->OldSwapchain = value;
}
public unsafe partial struct VkValidationCacheCreateInfoEXT : IDisposable
{
//VkValidationCacheCreateInfoEXT
private VkValidationCacheCreateInfoEXT(Data* ptr)
{
this.ptr = ptr;
}
public static VkValidationCacheCreateInfoEXT New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkValidationCacheCreateInfoEXT(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkValidationCacheCreateInfoEXT AsPtr() { fixed(Data* ptr = &this) return new VkValidationCacheCreateInfoEXT(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkValidationCacheCreateFlagsEXT Flags;
public UIntPtr InitialDataSize;
public IntPtr PInitialData;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkValidationCacheCreateFlagsEXT Flags => ptr->Flags;
public void SetFlags(VkValidationCacheCreateFlagsEXT value) => ptr->Flags = value;
public UIntPtr InitialDataSize => ptr->InitialDataSize;
public void SetInitialDataSize(UIntPtr value) => ptr->InitialDataSize = value;
public IntPtr PInitialData => ptr->PInitialData;
public void SetPInitialData(IntPtr value) => ptr->PInitialData = value;
}
public unsafe partial struct VkVertexInputAttributeDescription : IDisposable
{
//VkVertexInputAttributeDescription
private VkVertexInputAttributeDescription(Data* ptr)
{
this.ptr = ptr;
}
public static VkVertexInputAttributeDescription New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkVertexInputAttributeDescription(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkVertexInputAttributeDescription AsPtr() { fixed(Data* ptr = &this) return new VkVertexInputAttributeDescription(ptr); }
public uint Location;
public uint Binding;
public VkFormat Format;
public uint Offset;
}
public uint Location => ptr->Location;
public void SetLocation(uint value) => ptr->Location = value;
public uint Binding => ptr->Binding;
public void SetBinding(uint value) => ptr->Binding = value;
public VkFormat Format => ptr->Format;
public void SetFormat(VkFormat value) => ptr->Format = value;
public uint Offset => ptr->Offset;
public void SetOffset(uint value) => ptr->Offset = value;
}
public unsafe partial struct VkVertexInputBindingDescription : IDisposable
{
//VkVertexInputBindingDescription
private VkVertexInputBindingDescription(Data* ptr)
{
this.ptr = ptr;
}
public static VkVertexInputBindingDescription New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkVertexInputBindingDescription(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkVertexInputBindingDescription AsPtr() { fixed(Data* ptr = &this) return new VkVertexInputBindingDescription(ptr); }
public uint Binding;
public uint Stride;
public VkVertexInputRate InputRate;
}
public uint Binding => ptr->Binding;
public void SetBinding(uint value) => ptr->Binding = value;
public uint Stride => ptr->Stride;
public void SetStride(uint value) => ptr->Stride = value;
public VkVertexInputRate InputRate => ptr->InputRate;
public void SetInputRate(VkVertexInputRate value) => ptr->InputRate = value;
}
public unsafe partial struct VkViewport : IDisposable
{
//VkViewport
private VkViewport(Data* ptr)
{
this.ptr = ptr;
}
public static VkViewport New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkViewport(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkViewport AsPtr() { fixed(Data* ptr = &this) return new VkViewport(ptr); }
public float X;
public float Y;
public float Width;
public float Height;
public float MinDepth;
public float MaxDepth;
}
public float X => ptr->X;
public void SetX(float value) => ptr->X = value;
public float Y => ptr->Y;
public void SetY(float value) => ptr->Y = value;
public float Width => ptr->Width;
public void SetWidth(float value) => ptr->Width = value;
public float Height => ptr->Height;
public void SetHeight(float value) => ptr->Height = value;
public float MinDepth => ptr->MinDepth;
public void SetMinDepth(float value) => ptr->MinDepth = value;
public float MaxDepth => ptr->MaxDepth;
public void SetMaxDepth(float value) => ptr->MaxDepth = value;
}
public unsafe partial struct VkViewportWScalingNV : IDisposable
{
//VkViewportWScalingNV
private VkViewportWScalingNV(Data* ptr)
{
this.ptr = ptr;
}
public static VkViewportWScalingNV New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkViewportWScalingNV(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkViewportWScalingNV AsPtr() { fixed(Data* ptr = &this) return new VkViewportWScalingNV(ptr); }
public float Xcoeff;
public float Ycoeff;
}
public float Xcoeff => ptr->Xcoeff;
public void SetXcoeff(float value) => ptr->Xcoeff = value;
public float Ycoeff => ptr->Ycoeff;
public void SetYcoeff(float value) => ptr->Ycoeff = value;
}
public unsafe partial struct VkWriteDescriptorSet : IDisposable
{
//VkWriteDescriptorSet
private VkWriteDescriptorSet(Data* ptr)
{
this.ptr = ptr;
}
public static VkWriteDescriptorSet New(Data val = default)
{
var ptr = Alloc<Data>();
*ptr = val;
return new VkWriteDescriptorSet(ptr);
}
public void Dispose()
{
if(ptr != null) Free(ptr);
}
Data* ptr;
public unsafe partial struct Data
{
public VkWriteDescriptorSet AsPtr() { fixed(Data* ptr = &this) return new VkWriteDescriptorSet(ptr); }
public VkStructureType SType;
public IntPtr PNext;
public VkDescriptorSet DstSet;
public uint DstBinding;
public uint DstArrayElement;
public uint DescriptorCount;
public VkDescriptorType DescriptorType;
public VkDescriptorImageInfo PImageInfo;
public VkDescriptorBufferInfo PBufferInfo;
public VkBufferView* PTexelBufferView;
}
public VkStructureType SType => ptr->SType;
public void SetSType(VkStructureType value) => ptr->SType = value;
public IntPtr PNext => ptr->PNext;
public void SetPNext(IntPtr value) => ptr->PNext = value;
public VkDescriptorSet DstSet => ptr->DstSet;
public void SetDstSet(VkDescriptorSet value) => ptr->DstSet = value;
public uint DstBinding => ptr->DstBinding;
public void SetDstBinding(uint value) => ptr->DstBinding = value;
public uint DstArrayElement => ptr->DstArrayElement;
public void SetDstArrayElement(uint value) => ptr->DstArrayElement = value;
public uint DescriptorCount => ptr->DescriptorCount;
public void SetDescriptorCount(uint value) => ptr->DescriptorCount = value;
public VkDescriptorType DescriptorType => ptr->DescriptorType;
public void SetDescriptorType(VkDescriptorType value) => ptr->DescriptorType = value;
public VkDescriptorImageInfo PImageInfo => ptr->PImageInfo;
public void SetPImageInfo(VkDescriptorImageInfo value) => ptr->PImageInfo = value;
public VkDescriptorBufferInfo PBufferInfo => ptr->PBufferInfo;
public void SetPBufferInfo(VkDescriptorBufferInfo value) => ptr->PBufferInfo = value;
public VkBufferView* PTexelBufferView => ptr->PTexelBufferView;
public void SetPTexelBufferView(VkBufferView* value) => ptr->PTexelBufferView = value;
}
public unsafe partial struct VkXYColorEXT
{
//VkXYColorEXT
public float X;
public float Y;
}
public unsafe partial struct VkAccessFlags
{
public VkAccessFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkAttachmentDescriptionFlags
{
public VkAttachmentDescriptionFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkBool32
{
public VkBool32(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkBufferCreateFlags
{
public VkBufferCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkBufferUsageFlags
{
public VkBufferUsageFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkBufferViewCreateFlags
{
public VkBufferViewCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkBuildAccelerationStructureFlagsNV
{
public VkBuildAccelerationStructureFlagsNV(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkColorComponentFlags
{
public VkColorComponentFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkCommandBufferResetFlags
{
public VkCommandBufferResetFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkCommandBufferUsageFlags
{
public VkCommandBufferUsageFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkCommandPoolCreateFlags
{
public VkCommandPoolCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkCommandPoolResetFlags
{
public VkCommandPoolResetFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkCommandPoolTrimFlags
{
public VkCommandPoolTrimFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkCompositeAlphaFlagsKHR
{
public VkCompositeAlphaFlagsKHR(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkConditionalRenderingFlagsEXT
{
public VkConditionalRenderingFlagsEXT(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkCullModeFlags
{
public VkCullModeFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDebugReportFlagsEXT
{
public VkDebugReportFlagsEXT(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDebugUtilsMessageSeverityFlagsEXT
{
public VkDebugUtilsMessageSeverityFlagsEXT(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDebugUtilsMessageTypeFlagsEXT
{
public VkDebugUtilsMessageTypeFlagsEXT(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDebugUtilsMessengerCallbackDataFlagsEXT
{
public VkDebugUtilsMessengerCallbackDataFlagsEXT(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDebugUtilsMessengerCreateFlagsEXT
{
public VkDebugUtilsMessengerCreateFlagsEXT(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDependencyFlags
{
public VkDependencyFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDescriptorPoolCreateFlags
{
public VkDescriptorPoolCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDescriptorPoolResetFlags
{
public VkDescriptorPoolResetFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDescriptorSetLayoutCreateFlags
{
public VkDescriptorSetLayoutCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDescriptorUpdateTemplateCreateFlags
{
public VkDescriptorUpdateTemplateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDeviceAddress
{
public VkDeviceAddress(UInt64 value)
{
Value = value;
}
public UInt64 Value;
}
public unsafe partial struct VkDeviceCreateFlags
{
public VkDeviceCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDeviceGroupPresentModeFlagsKHR
{
public VkDeviceGroupPresentModeFlagsKHR(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDeviceQueueCreateFlags
{
public VkDeviceQueueCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDeviceSize
{
public VkDeviceSize(UInt64 value)
{
Value = value;
}
public UInt64 Value;
}
public unsafe partial struct VkDisplayModeCreateFlagsKHR
{
public VkDisplayModeCreateFlagsKHR(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDisplayPlaneAlphaFlagsKHR
{
public VkDisplayPlaneAlphaFlagsKHR(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkDisplaySurfaceCreateFlagsKHR
{
public VkDisplaySurfaceCreateFlagsKHR(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkEventCreateFlags
{
public VkEventCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkExternalFenceFeatureFlags
{
public VkExternalFenceFeatureFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkExternalFenceHandleTypeFlags
{
public VkExternalFenceHandleTypeFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkExternalMemoryFeatureFlags
{
public VkExternalMemoryFeatureFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkExternalMemoryFeatureFlagsNV
{
public VkExternalMemoryFeatureFlagsNV(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkExternalMemoryHandleTypeFlags
{
public VkExternalMemoryHandleTypeFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkExternalMemoryHandleTypeFlagsNV
{
public VkExternalMemoryHandleTypeFlagsNV(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkExternalSemaphoreFeatureFlags
{
public VkExternalSemaphoreFeatureFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkExternalSemaphoreHandleTypeFlags
{
public VkExternalSemaphoreHandleTypeFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkFenceCreateFlags
{
public VkFenceCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkFenceImportFlags
{
public VkFenceImportFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkFormatFeatureFlags
{
public VkFormatFeatureFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkFramebufferCreateFlags
{
public VkFramebufferCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkGeometryFlagsNV
{
public VkGeometryFlagsNV(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkImageAspectFlags
{
public VkImageAspectFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkImageCreateFlags
{
public VkImageCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkImageUsageFlags
{
public VkImageUsageFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkImageViewCreateFlags
{
public VkImageViewCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkIndirectCommandsLayoutUsageFlagsNVX
{
public VkIndirectCommandsLayoutUsageFlagsNVX(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkInstanceCreateFlags
{
public VkInstanceCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkMemoryHeapFlags
{
public VkMemoryHeapFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkMemoryMapFlags
{
public VkMemoryMapFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkMemoryPropertyFlags
{
public VkMemoryPropertyFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkObjectEntryUsageFlagsNVX
{
public VkObjectEntryUsageFlagsNVX(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPeerMemoryFeatureFlags
{
public VkPeerMemoryFeatureFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineCacheCreateFlags
{
public VkPipelineCacheCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineColorBlendStateCreateFlags
{
public VkPipelineColorBlendStateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineCreateFlags
{
public VkPipelineCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineDepthStencilStateCreateFlags
{
public VkPipelineDepthStencilStateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineDynamicStateCreateFlags
{
public VkPipelineDynamicStateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineInputAssemblyStateCreateFlags
{
public VkPipelineInputAssemblyStateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineLayoutCreateFlags
{
public VkPipelineLayoutCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineMultisampleStateCreateFlags
{
public VkPipelineMultisampleStateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineRasterizationStateCreateFlags
{
public VkPipelineRasterizationStateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineShaderStageCreateFlags
{
public VkPipelineShaderStageCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineStageFlags
{
public VkPipelineStageFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineTessellationStateCreateFlags
{
public VkPipelineTessellationStateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineVertexInputStateCreateFlags
{
public VkPipelineVertexInputStateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkPipelineViewportStateCreateFlags
{
public VkPipelineViewportStateCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkQueryControlFlags
{
public VkQueryControlFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkQueryPipelineStatisticFlags
{
public VkQueryPipelineStatisticFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkQueryPoolCreateFlags
{
public VkQueryPoolCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkQueryResultFlags
{
public VkQueryResultFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkQueueFlags
{
public VkQueueFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkRenderPassCreateFlags
{
public VkRenderPassCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSampleCountFlags
{
public VkSampleCountFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSampleMask
{
public VkSampleMask(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSamplerCreateFlags
{
public VkSamplerCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSemaphoreCreateFlags
{
public VkSemaphoreCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSemaphoreImportFlags
{
public VkSemaphoreImportFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkShaderModuleCreateFlags
{
public VkShaderModuleCreateFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkShaderStageFlags
{
public VkShaderStageFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSparseImageFormatFlags
{
public VkSparseImageFormatFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSparseMemoryBindFlags
{
public VkSparseMemoryBindFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkStencilFaceFlags
{
public VkStencilFaceFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSubpassDescriptionFlags
{
public VkSubpassDescriptionFlags(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSurfaceCounterFlagsEXT
{
public VkSurfaceCounterFlagsEXT(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSurfaceTransformFlagsKHR
{
public VkSurfaceTransformFlagsKHR(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkSwapchainCreateFlagsKHR
{
public VkSwapchainCreateFlagsKHR(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
public unsafe partial struct VkValidationCacheCreateFlagsEXT
{
public VkValidationCacheCreateFlagsEXT(UInt32 value)
{
Value = value;
}
public UInt32 Value;
}
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public unsafe delegate IntPtr PFNVkAllocationFunctionDelegate(IntPtr pUserData, UIntPtr size, UIntPtr alignment, VkSystemAllocationScope allocationScope);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public unsafe delegate uint PFNVkDebugReportCallbackEXTDelegate(VkBool32 VkBool32, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, ulong @object, UIntPtr location, int messageCode, CString pLayerPrefix, CString pMessage, IntPtr pUserData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public unsafe delegate uint PFNVkDebugUtilsMessengerCallbackEXTDelegate(VkBool32 VkBool32, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, VkDebugUtilsMessengerCallbackDataEXT pCallbackData, IntPtr pUserData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public unsafe delegate void PFNVkFreeFunctionDelegate(IntPtr pUserData, IntPtr pMemory);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public unsafe delegate void PFNVkInternalAllocationNotificationDelegate(IntPtr pUserData, UIntPtr size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public unsafe delegate void PFNVkInternalFreeNotificationDelegate(IntPtr pUserData, UIntPtr size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public unsafe delegate IntPtr PFNVkReallocationFunctionDelegate(IntPtr pUserData, IntPtr pOriginal, UIntPtr size, UIntPtr alignment, VkSystemAllocationScope allocationScope);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public unsafe delegate void PFNVkVoidFunctionDelegate();
[StructLayout(LayoutKind.Explicit)]
public unsafe partial struct VkClearColorValue
{
[FieldOffset(0)]
public Float4 Float32;
[FieldOffset(0)]
public fixed int Int32[4];
[FieldOffset(0)]
public fixed uint Uint32[4];
}
[StructLayout(LayoutKind.Explicit)]
public unsafe partial struct VkClearValue
{
[FieldOffset(0)]
public VkClearColorValue Color;
[FieldOffset(0)]
public VkClearDepthStencilValue DepthStencil;
}
public unsafe partial struct Float4
{
//float4
public float _0;
public float _1;
public float _2;
public float _3;
public float this[int index]
{
get
{
fixed (float* ptr = &_0) return *(ptr + index);
}
}
}
public unsafe partial struct VkMemoryHeap16
{
//VkMemoryHeap16
public VkMemoryHeap _0;
public VkMemoryHeap _1;
public VkMemoryHeap _2;
public VkMemoryHeap _3;
public VkMemoryHeap _4;
public VkMemoryHeap _5;
public VkMemoryHeap _6;
public VkMemoryHeap _7;
public VkMemoryHeap _8;
public VkMemoryHeap _9;
public VkMemoryHeap _10;
public VkMemoryHeap _11;
public VkMemoryHeap _12;
public VkMemoryHeap _13;
public VkMemoryHeap _14;
public VkMemoryHeap _15;
public VkMemoryHeap this[int index]
{
get
{
fixed (VkMemoryHeap* ptr = &_0) return *(ptr + index);
}
}
}
public unsafe partial struct VkMemoryType32
{
//VkMemoryType32
public VkMemoryType _0;
public VkMemoryType _1;
public VkMemoryType _2;
public VkMemoryType _3;
public VkMemoryType _4;
public VkMemoryType _5;
public VkMemoryType _6;
public VkMemoryType _7;
public VkMemoryType _8;
public VkMemoryType _9;
public VkMemoryType _10;
public VkMemoryType _11;
public VkMemoryType _12;
public VkMemoryType _13;
public VkMemoryType _14;
public VkMemoryType _15;
public VkMemoryType _16;
public VkMemoryType _17;
public VkMemoryType _18;
public VkMemoryType _19;
public VkMemoryType _20;
public VkMemoryType _21;
public VkMemoryType _22;
public VkMemoryType _23;
public VkMemoryType _24;
public VkMemoryType _25;
public VkMemoryType _26;
public VkMemoryType _27;
public VkMemoryType _28;
public VkMemoryType _29;
public VkMemoryType _30;
public VkMemoryType _31;
public VkMemoryType this[int index]
{
get
{
fixed (VkMemoryType* ptr = &_0) return *(ptr + index);
}
}
}
public unsafe partial struct VkOffset3D2
{
//VkOffset3D2
public VkOffset3D _0;
public VkOffset3D _1;
public VkOffset3D this[int index]
{
get
{
fixed (VkOffset3D* ptr = &_0) return *(ptr + index);
}
}
}
public unsafe partial struct VkPhysicalDevice32
{
//VkPhysicalDevice32
public VkPhysicalDevice _0;
public VkPhysicalDevice _1;
public VkPhysicalDevice _2;
public VkPhysicalDevice _3;
public VkPhysicalDevice _4;
public VkPhysicalDevice _5;
public VkPhysicalDevice _6;
public VkPhysicalDevice _7;
public VkPhysicalDevice _8;
public VkPhysicalDevice _9;
public VkPhysicalDevice _10;
public VkPhysicalDevice _11;
public VkPhysicalDevice _12;
public VkPhysicalDevice _13;
public VkPhysicalDevice _14;
public VkPhysicalDevice _15;
public VkPhysicalDevice _16;
public VkPhysicalDevice _17;
public VkPhysicalDevice _18;
public VkPhysicalDevice _19;
public VkPhysicalDevice _20;
public VkPhysicalDevice _21;
public VkPhysicalDevice _22;
public VkPhysicalDevice _23;
public VkPhysicalDevice _24;
public VkPhysicalDevice _25;
public VkPhysicalDevice _26;
public VkPhysicalDevice _27;
public VkPhysicalDevice _28;
public VkPhysicalDevice _29;
public VkPhysicalDevice _30;
public VkPhysicalDevice _31;
public VkPhysicalDevice this[int index]
{
get
{
fixed (VkPhysicalDevice* ptr = &_0) return *(ptr + index);
}
}
}
public unsafe static partial class Vk
{
[DllImport(DllNames.VK, EntryPoint = "vkAcquireNextImage2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkAcquireNextImage2KHR(VkDevice device, VkAcquireNextImageInfoKHR pAcquireInfo, out uint pImageIndex);
[DllImport(DllNames.VK, EntryPoint = "vkAcquireNextImageKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, ulong timeout, VkSemaphore semaphore, VkFence fence, out uint pImageIndex);
[DllImport(DllNames.VK, EntryPoint = "vkAllocateCommandBuffers", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkAllocateCommandBuffers(VkDevice device, VkCommandBufferAllocateInfo pAllocateInfo, VkCommandBuffer* pCommandBuffers);
[DllImport(DllNames.VK, EntryPoint = "vkAllocateDescriptorSets", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkAllocateDescriptorSets(VkDevice device, VkDescriptorSetAllocateInfo pAllocateInfo, VkDescriptorSet* pDescriptorSets);
[DllImport(DllNames.VK, EntryPoint = "vkAllocateMemory", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkAllocateMemory(VkDevice device, VkMemoryAllocateInfo pAllocateInfo, VkAllocationCallbacks pAllocator, VkDeviceMemory* pMemory);
[DllImport(DllNames.VK, EntryPoint = "vkBeginCommandBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkBeginCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo pBeginInfo);
[DllImport(DllNames.VK, EntryPoint = "vkBindAccelerationStructureMemoryNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkBindAccelerationStructureMemoryNV(VkDevice device, uint bindInfoCount, VkBindAccelerationStructureMemoryInfoNV pBindInfos);
[DllImport(DllNames.VK, EntryPoint = "vkBindBufferMemory", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
[DllImport(DllNames.VK, EntryPoint = "vkBindBufferMemory2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkBindBufferMemory2(VkDevice device, uint bindInfoCount, VkBindBufferMemoryInfo pBindInfos);
[DllImport(DllNames.VK, EntryPoint = "vkBindBufferMemory2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkBindBufferMemory2KHR(VkDevice device, uint bindInfoCount, VkBindBufferMemoryInfo pBindInfos);
[DllImport(DllNames.VK, EntryPoint = "vkBindImageMemory", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
[DllImport(DllNames.VK, EntryPoint = "vkBindImageMemory2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkBindImageMemory2(VkDevice device, uint bindInfoCount, VkBindImageMemoryInfo pBindInfos);
[DllImport(DllNames.VK, EntryPoint = "vkBindImageMemory2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkBindImageMemory2KHR(VkDevice device, uint bindInfoCount, VkBindImageMemoryInfo pBindInfos);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBeginConditionalRenderingEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBeginDebugUtilsLabelEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, VkDebugUtilsLabelEXT pLabelInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBeginQuery", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query, VkQueryControlFlags flags);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBeginQueryIndexedEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query, VkQueryControlFlags flags, uint index);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBeginRenderPass", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBeginRenderPass(VkCommandBuffer commandBuffer, VkRenderPassBeginInfo pRenderPassBegin, VkSubpassContents contents);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBeginRenderPass2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, VkRenderPassBeginInfo pRenderPassBegin, VkSubpassBeginInfoKHR pSubpassBeginInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBeginTransformFeedbackEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint firstCounterBuffer, uint counterBufferCount, VkBuffer* pCounterBuffers, VkDeviceSize* pCounterBufferOffsets);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBindDescriptorSets", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint firstSet, uint descriptorSetCount, VkDescriptorSet* pDescriptorSets, uint dynamicOffsetCount, out uint pDynamicOffsets);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBindIndexBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBindPipeline", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBindShadingRateImageNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBindTransformFeedbackBuffersEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint firstBinding, uint bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets, VkDeviceSize* pSizes);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBindVertexBuffers", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint firstBinding, uint bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBlitImage", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageBlit pRegions, VkFilter filter);
[DllImport(DllNames.VK, EntryPoint = "vkCmdBuildAccelerationStructureNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset);
[DllImport(DllNames.VK, EntryPoint = "vkCmdClearAttachments", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdClearAttachments(VkCommandBuffer commandBuffer, uint attachmentCount, VkClearAttachment pAttachments, uint rectCount, VkClearRect pRects);
[DllImport(DllNames.VK, EntryPoint = "vkCmdClearColorImage", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue* pColor, uint rangeCount, VkImageSubresourceRange* pRanges);
[DllImport(DllNames.VK, EntryPoint = "vkCmdClearDepthStencilImage", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue* pDepthStencil, uint rangeCount, VkImageSubresourceRange* pRanges);
[DllImport(DllNames.VK, EntryPoint = "vkCmdCopyAccelerationStructureNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode);
[DllImport(DllNames.VK, EntryPoint = "vkCmdCopyBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint regionCount, VkBufferCopy pRegions);
[DllImport(DllNames.VK, EntryPoint = "vkCmdCopyBufferToImage", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkBufferImageCopy pRegions);
[DllImport(DllNames.VK, EntryPoint = "vkCmdCopyImage", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageCopy pRegions);
[DllImport(DllNames.VK, EntryPoint = "vkCmdCopyImageToBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint regionCount, VkBufferImageCopy pRegions);
[DllImport(DllNames.VK, EntryPoint = "vkCmdCopyQueryPoolResults", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDebugMarkerBeginEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT pMarkerInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDebugMarkerEndEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDebugMarkerInsertEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT pMarkerInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDispatch", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDispatch(VkCommandBuffer commandBuffer, uint groupCountX, uint groupCountY, uint groupCountZ);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDispatchBase", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDispatchBase(VkCommandBuffer commandBuffer, uint baseGroupX, uint baseGroupY, uint baseGroupZ, uint groupCountX, uint groupCountY, uint groupCountZ);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDispatchBaseKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint baseGroupX, uint baseGroupY, uint baseGroupZ, uint groupCountX, uint groupCountY, uint groupCountZ);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDispatchIndirect", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDraw", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDraw(VkCommandBuffer commandBuffer, uint vertexCount, uint instanceCount, uint firstVertex, uint firstInstance);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawIndexed", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint indexCount, uint instanceCount, uint firstIndex, int vertexOffset, uint firstInstance);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawIndexedIndirect", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawIndexedIndirectCountAMD", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint maxDrawCount, uint stride);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawIndexedIndirectCountKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint maxDrawCount, uint stride);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawIndirect", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawIndirectByteCountEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint instanceCount, uint firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint counterOffset, uint vertexStride);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawIndirectCountAMD", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint maxDrawCount, uint stride);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawIndirectCountKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint maxDrawCount, uint stride);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawMeshTasksIndirectCountNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint maxDrawCount, uint stride);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawMeshTasksIndirectNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride);
[DllImport(DllNames.VK, EntryPoint = "vkCmdDrawMeshTasksNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint taskCount, uint firstTask);
[DllImport(DllNames.VK, EntryPoint = "vkCmdEndConditionalRenderingEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer);
[DllImport(DllNames.VK, EntryPoint = "vkCmdEndDebugUtilsLabelEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer);
[DllImport(DllNames.VK, EntryPoint = "vkCmdEndQuery", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query);
[DllImport(DllNames.VK, EntryPoint = "vkCmdEndQueryIndexedEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query, uint index);
[DllImport(DllNames.VK, EntryPoint = "vkCmdEndRenderPass", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdEndRenderPass(VkCommandBuffer commandBuffer);
[DllImport(DllNames.VK, EntryPoint = "vkCmdEndRenderPass2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, VkSubpassEndInfoKHR pSubpassEndInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdEndTransformFeedbackEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint firstCounterBuffer, uint counterBufferCount, VkBuffer* pCounterBuffers, VkDeviceSize* pCounterBufferOffsets);
[DllImport(DllNames.VK, EntryPoint = "vkCmdExecuteCommands", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint commandBufferCount, VkCommandBuffer* pCommandBuffers);
[DllImport(DllNames.VK, EntryPoint = "vkCmdFillBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint data);
[DllImport(DllNames.VK, EntryPoint = "vkCmdInsertDebugUtilsLabelEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, VkDebugUtilsLabelEXT pLabelInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdNextSubpass", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
[DllImport(DllNames.VK, EntryPoint = "vkCmdNextSubpass2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, VkSubpassBeginInfoKHR pSubpassBeginInfo, VkSubpassEndInfoKHR pSubpassEndInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdPipelineBarrier", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint memoryBarrierCount, VkMemoryBarrier pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier pImageMemoryBarriers);
[DllImport(DllNames.VK, EntryPoint = "vkCmdProcessCommandsNVX", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, VkCmdProcessCommandsInfoNVX pProcessCommandsInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdPushConstants", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint offset, uint size, IntPtr pValues);
[DllImport(DllNames.VK, EntryPoint = "vkCmdPushDescriptorSetKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint @set, uint descriptorWriteCount, VkWriteDescriptorSet pDescriptorWrites);
[DllImport(DllNames.VK, EntryPoint = "vkCmdPushDescriptorSetWithTemplateKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint @set, IntPtr pData);
[DllImport(DllNames.VK, EntryPoint = "vkCmdReserveSpaceForCommandsNVX", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, VkCmdReserveSpaceForCommandsInfoNVX pReserveSpaceInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdResetEvent", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent @event, VkPipelineStageFlags stageMask);
[DllImport(DllNames.VK, EntryPoint = "vkCmdResetQueryPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount);
[DllImport(DllNames.VK, EntryPoint = "vkCmdResolveImage", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageResolve pRegions);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetBlendConstants", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetBlendConstants(VkCommandBuffer commandBuffer, in Float4 blendConstants);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetCheckpointNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, IntPtr pCheckpointMarker);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetCoarseSampleOrderNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint customSampleOrderCount, VkCoarseSampleOrderCustomNV pCustomSampleOrders);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetDepthBias", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetDepthBounds", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetDeviceMask", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint deviceMask);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetDeviceMaskKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint deviceMask);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetDiscardRectangleEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint firstDiscardRectangle, uint discardRectangleCount, VkRect2D* pDiscardRectangles);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetEvent", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent @event, VkPipelineStageFlags stageMask);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetExclusiveScissorNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint firstExclusiveScissor, uint exclusiveScissorCount, VkRect2D* pExclusiveScissors);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetLineWidth", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetSampleLocationsEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, VkSampleLocationsInfoEXT pSampleLocationsInfo);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetScissor", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetScissor(VkCommandBuffer commandBuffer, uint firstScissor, uint scissorCount, VkRect2D* pScissors);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetStencilCompareMask", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint compareMask);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetStencilReference", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint reference);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetStencilWriteMask", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint writeMask);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetViewport", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetViewport(VkCommandBuffer commandBuffer, uint firstViewport, uint viewportCount, VkViewport pViewports);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetViewportShadingRatePaletteNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint firstViewport, uint viewportCount, VkShadingRatePaletteNV pShadingRatePalettes);
[DllImport(DllNames.VK, EntryPoint = "vkCmdSetViewportWScalingNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint firstViewport, uint viewportCount, VkViewportWScalingNV pViewportWScalings);
[DllImport(DllNames.VK, EntryPoint = "vkCmdTraceRaysNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint width, uint height, uint depth);
[DllImport(DllNames.VK, EntryPoint = "vkCmdUpdateBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, IntPtr pData);
[DllImport(DllNames.VK, EntryPoint = "vkCmdWaitEvents", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdWaitEvents(VkCommandBuffer commandBuffer, uint eventCount, VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint memoryBarrierCount, VkMemoryBarrier pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier pImageMemoryBarriers);
[DllImport(DllNames.VK, EntryPoint = "vkCmdWriteAccelerationStructuresPropertiesNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint accelerationStructureCount, VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint firstQuery);
[DllImport(DllNames.VK, EntryPoint = "vkCmdWriteBufferMarkerAMD", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint marker);
[DllImport(DllNames.VK, EntryPoint = "vkCmdWriteTimestamp", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint query);
[DllImport(DllNames.VK, EntryPoint = "vkCompileDeferredNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint shader);
[DllImport(DllNames.VK, EntryPoint = "vkCreateAccelerationStructureNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateAccelerationStructureNV(VkDevice device, VkAccelerationStructureCreateInfoNV pCreateInfo, VkAllocationCallbacks pAllocator, VkAccelerationStructureNV* pAccelerationStructure);
[DllImport(DllNames.VK, EntryPoint = "vkCreateBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateBuffer(VkDevice device, VkBufferCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkBuffer* pBuffer);
[DllImport(DllNames.VK, EntryPoint = "vkCreateBufferView", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateBufferView(VkDevice device, VkBufferViewCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkBufferView* pView);
[DllImport(DllNames.VK, EntryPoint = "vkCreateCommandPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateCommandPool(VkDevice device, VkCommandPoolCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkCommandPool* pCommandPool);
[DllImport(DllNames.VK, EntryPoint = "vkCreateComputePipelines", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkComputePipelineCreateInfo pCreateInfos, VkAllocationCallbacks pAllocator, VkPipeline* pPipelines);
[DllImport(DllNames.VK, EntryPoint = "vkCreateDebugReportCallbackEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackCreateInfoEXT pCreateInfo, VkAllocationCallbacks pAllocator, VkDebugReportCallbackEXT* pCallback);
[DllImport(DllNames.VK, EntryPoint = "vkCreateDebugUtilsMessengerEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerCreateInfoEXT pCreateInfo, VkAllocationCallbacks pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
[DllImport(DllNames.VK, EntryPoint = "vkCreateDescriptorPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateDescriptorPool(VkDevice device, VkDescriptorPoolCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkDescriptorPool* pDescriptorPool);
[DllImport(DllNames.VK, EntryPoint = "vkCreateDescriptorSetLayout", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateDescriptorSetLayout(VkDevice device, VkDescriptorSetLayoutCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkDescriptorSetLayout* pSetLayout);
[DllImport(DllNames.VK, EntryPoint = "vkCreateDescriptorUpdateTemplate", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplateCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
[DllImport(DllNames.VK, EntryPoint = "vkCreateDescriptorUpdateTemplateKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplateCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
[DllImport(DllNames.VK, EntryPoint = "vkCreateDevice", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateDevice(VkPhysicalDevice physicalDevice, VkDeviceCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkDevice* pDevice);
[DllImport(DllNames.VK, EntryPoint = "vkCreateDisplayModeKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkDisplayModeCreateInfoKHR pCreateInfo, VkAllocationCallbacks pAllocator, VkDisplayModeKHR* pMode);
[DllImport(DllNames.VK, EntryPoint = "vkCreateDisplayPlaneSurfaceKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateDisplayPlaneSurfaceKHR(VkInstance instance, VkDisplaySurfaceCreateInfoKHR pCreateInfo, VkAllocationCallbacks pAllocator, VkSurfaceKHR* pSurface);
[DllImport(DllNames.VK, EntryPoint = "vkCreateEvent", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateEvent(VkDevice device, VkEventCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkEvent* pEvent);
[DllImport(DllNames.VK, EntryPoint = "vkCreateFence", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateFence(VkDevice device, VkFenceCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkFence* pFence);
[DllImport(DllNames.VK, EntryPoint = "vkCreateFramebuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateFramebuffer(VkDevice device, VkFramebufferCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkFramebuffer* pFramebuffer);
[DllImport(DllNames.VK, EntryPoint = "vkCreateGraphicsPipelines", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkGraphicsPipelineCreateInfo pCreateInfos, VkAllocationCallbacks pAllocator, VkPipeline* pPipelines);
[DllImport(DllNames.VK, EntryPoint = "vkCreateImage", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateImage(VkDevice device, VkImageCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkImage* pImage);
[DllImport(DllNames.VK, EntryPoint = "vkCreateImageView", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateImageView(VkDevice device, VkImageViewCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkImageView* pView);
[DllImport(DllNames.VK, EntryPoint = "vkCreateIndirectCommandsLayoutNVX", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutCreateInfoNVX pCreateInfo, VkAllocationCallbacks pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
[DllImport(DllNames.VK, EntryPoint = "vkCreateInstance", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateInstance(VkInstanceCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkInstance* pInstance);
[DllImport(DllNames.VK, EntryPoint = "vkCreateObjectTableNVX", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateObjectTableNVX(VkDevice device, VkObjectTableCreateInfoNVX pCreateInfo, VkAllocationCallbacks pAllocator, VkObjectTableNVX* pObjectTable);
[DllImport(DllNames.VK, EntryPoint = "vkCreatePipelineCache", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreatePipelineCache(VkDevice device, VkPipelineCacheCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkPipelineCache* pPipelineCache);
[DllImport(DllNames.VK, EntryPoint = "vkCreatePipelineLayout", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreatePipelineLayout(VkDevice device, VkPipelineLayoutCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkPipelineLayout* pPipelineLayout);
[DllImport(DllNames.VK, EntryPoint = "vkCreateQueryPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateQueryPool(VkDevice device, VkQueryPoolCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkQueryPool* pQueryPool);
[DllImport(DllNames.VK, EntryPoint = "vkCreateRayTracingPipelinesNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkRayTracingPipelineCreateInfoNV pCreateInfos, VkAllocationCallbacks pAllocator, VkPipeline* pPipelines);
[DllImport(DllNames.VK, EntryPoint = "vkCreateRenderPass", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateRenderPass(VkDevice device, VkRenderPassCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkRenderPass* pRenderPass);
[DllImport(DllNames.VK, EntryPoint = "vkCreateRenderPass2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateRenderPass2KHR(VkDevice device, VkRenderPassCreateInfo2KHR pCreateInfo, VkAllocationCallbacks pAllocator, VkRenderPass* pRenderPass);
[DllImport(DllNames.VK, EntryPoint = "vkCreateSampler", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateSampler(VkDevice device, VkSamplerCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkSampler* pSampler);
[DllImport(DllNames.VK, EntryPoint = "vkCreateSamplerYcbcrConversion", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateSamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversionCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
[DllImport(DllNames.VK, EntryPoint = "vkCreateSamplerYcbcrConversionKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateSamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversionCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
[DllImport(DllNames.VK, EntryPoint = "vkCreateSemaphore", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateSemaphore(VkDevice device, VkSemaphoreCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkSemaphore* pSemaphore);
[DllImport(DllNames.VK, EntryPoint = "vkCreateShaderModule", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateShaderModule(VkDevice device, VkShaderModuleCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, VkShaderModule* pShaderModule);
[DllImport(DllNames.VK, EntryPoint = "vkCreateSharedSwapchainsKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateSharedSwapchainsKHR(VkDevice device, uint swapchainCount, VkSwapchainCreateInfoKHR pCreateInfos, VkAllocationCallbacks pAllocator, VkSwapchainKHR* pSwapchains);
[DllImport(DllNames.VK, EntryPoint = "vkCreateSwapchainKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateSwapchainKHR(VkDevice device, VkSwapchainCreateInfoKHR pCreateInfo, VkAllocationCallbacks pAllocator, VkSwapchainKHR* pSwapchain);
[DllImport(DllNames.VK, EntryPoint = "vkCreateValidationCacheEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkCreateValidationCacheEXT(VkDevice device, VkValidationCacheCreateInfoEXT pCreateInfo, VkAllocationCallbacks pAllocator, VkValidationCacheEXT* pValidationCache);
[DllImport(DllNames.VK, EntryPoint = "vkDebugMarkerSetObjectNameEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkDebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT pNameInfo);
[DllImport(DllNames.VK, EntryPoint = "vkDebugMarkerSetObjectTagEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkDebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT pTagInfo);
[DllImport(DllNames.VK, EntryPoint = "vkDebugReportMessageEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, ulong @object, UIntPtr location, int messageCode, CString pLayerPrefix, CString pMessage);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyAccelerationStructureNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyBuffer(VkDevice device, VkBuffer buffer, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyBufferView", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyBufferView(VkDevice device, VkBufferView bufferView, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyCommandPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyDebugReportCallbackEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyDebugUtilsMessengerEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyDescriptorPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyDescriptorSetLayout", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyDescriptorUpdateTemplate", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyDescriptorUpdateTemplateKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyDevice", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyDevice(VkDevice device, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyEvent", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyEvent(VkDevice device, VkEvent @event, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyFence", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyFence(VkDevice device, VkFence fence, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyFramebuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyImage", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyImage(VkDevice device, VkImage image, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyImageView", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyImageView(VkDevice device, VkImageView imageView, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyIndirectCommandsLayoutNVX", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyInstance", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyInstance(VkInstance instance, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyObjectTableNVX", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyPipeline", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyPipeline(VkDevice device, VkPipeline pipeline, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyPipelineCache", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyPipelineLayout", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyQueryPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyRenderPass", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroySampler", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroySampler(VkDevice device, VkSampler sampler, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroySamplerYcbcrConversion", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroySamplerYcbcrConversionKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroySemaphore", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroySemaphore(VkDevice device, VkSemaphore semaphore, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyShaderModule", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroySurfaceKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroySwapchainKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDestroyValidationCacheEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkDeviceWaitIdle", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkDeviceWaitIdle(VkDevice device);
[DllImport(DllNames.VK, EntryPoint = "vkDisplayPowerControlEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, VkDisplayPowerInfoEXT pDisplayPowerInfo);
[DllImport(DllNames.VK, EntryPoint = "vkEndCommandBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkEndCommandBuffer(VkCommandBuffer commandBuffer);
[DllImport(DllNames.VK, EntryPoint = "vkEnumerateDeviceExtensionProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, CString pLayerName, out uint pPropertyCount, VkExtensionProperties pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkEnumerateDeviceLayerProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, out uint pPropertyCount, VkLayerProperties pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkEnumerateInstanceExtensionProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkEnumerateInstanceExtensionProperties(CString pLayerName, out uint pPropertyCount, VkExtensionProperties pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkEnumerateInstanceLayerProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkEnumerateInstanceLayerProperties(out uint pPropertyCount, VkLayerProperties pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkEnumerateInstanceVersion", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkEnumerateInstanceVersion(out uint pApiVersion);
[DllImport(DllNames.VK, EntryPoint = "vkEnumeratePhysicalDeviceGroups", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkEnumeratePhysicalDeviceGroups(VkInstance instance, out uint pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties pPhysicalDeviceGroupProperties);
[DllImport(DllNames.VK, EntryPoint = "vkEnumeratePhysicalDeviceGroupsKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, out uint pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties pPhysicalDeviceGroupProperties);
[DllImport(DllNames.VK, EntryPoint = "vkEnumeratePhysicalDevices", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkEnumeratePhysicalDevices(VkInstance instance, out uint pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
[DllImport(DllNames.VK, EntryPoint = "vkFlushMappedMemoryRanges", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkFlushMappedMemoryRanges(VkDevice device, uint memoryRangeCount, VkMappedMemoryRange pMemoryRanges);
[DllImport(DllNames.VK, EntryPoint = "vkFreeCommandBuffers", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint commandBufferCount, VkCommandBuffer* pCommandBuffers);
[DllImport(DllNames.VK, EntryPoint = "vkFreeDescriptorSets", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint descriptorSetCount, VkDescriptorSet* pDescriptorSets);
[DllImport(DllNames.VK, EntryPoint = "vkFreeMemory", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkFreeMemory(VkDevice device, VkDeviceMemory memory, VkAllocationCallbacks pAllocator);
[DllImport(DllNames.VK, EntryPoint = "vkGetAccelerationStructureHandleNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, UIntPtr dataSize, IntPtr pData);
[DllImport(DllNames.VK, EntryPoint = "vkGetAccelerationStructureMemoryRequirementsNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, VkAccelerationStructureMemoryRequirementsInfoNV pInfo, VkMemoryRequirements2KHR pMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetBufferDeviceAddressEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkDeviceAddress VkGetBufferDeviceAddressEXT(VkDevice device, VkBufferDeviceAddressInfoEXT pInfo);
[DllImport(DllNames.VK, EntryPoint = "vkGetBufferMemoryRequirements", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetBufferMemoryRequirements2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetBufferMemoryRequirements2(VkDevice device, VkBufferMemoryRequirementsInfo2 pInfo, VkMemoryRequirements2 pMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetBufferMemoryRequirements2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetBufferMemoryRequirements2KHR(VkDevice device, VkBufferMemoryRequirementsInfo2 pInfo, VkMemoryRequirements2 pMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetCalibratedTimestampsEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetCalibratedTimestampsEXT(VkDevice device, uint timestampCount, VkCalibratedTimestampInfoEXT pTimestampInfos, out ulong pTimestamps, out ulong pMaxDeviation);
[DllImport(DllNames.VK, EntryPoint = "vkGetDescriptorSetLayoutSupport", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetDescriptorSetLayoutSupport(VkDevice device, VkDescriptorSetLayoutCreateInfo pCreateInfo, VkDescriptorSetLayoutSupport pSupport);
[DllImport(DllNames.VK, EntryPoint = "vkGetDescriptorSetLayoutSupportKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetDescriptorSetLayoutSupportKHR(VkDevice device, VkDescriptorSetLayoutCreateInfo pCreateInfo, VkDescriptorSetLayoutSupport pSupport);
[DllImport(DllNames.VK, EntryPoint = "vkGetDeviceGroupPeerMemoryFeatures", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint heapIndex, uint localDeviceIndex, uint remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
[DllImport(DllNames.VK, EntryPoint = "vkGetDeviceGroupPeerMemoryFeaturesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint heapIndex, uint localDeviceIndex, uint remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
[DllImport(DllNames.VK, EntryPoint = "vkGetDeviceGroupPresentCapabilitiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities);
[DllImport(DllNames.VK, EntryPoint = "vkGetDeviceGroupSurfacePresentModesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
[DllImport(DllNames.VK, EntryPoint = "vkGetDeviceMemoryCommitment", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
[DllImport(DllNames.VK, EntryPoint = "vkGetDeviceProcAddr", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern PFNVkVoidFunctionDelegate VkGetDeviceProcAddr(VkDevice device, CString pName);
[DllImport(DllNames.VK, EntryPoint = "vkGetDeviceQueue", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetDeviceQueue(VkDevice device, uint queueFamilyIndex, uint queueIndex, VkQueue* pQueue);
[DllImport(DllNames.VK, EntryPoint = "vkGetDeviceQueue2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetDeviceQueue2(VkDevice device, VkDeviceQueueInfo2 pQueueInfo, VkQueue* pQueue);
[DllImport(DllNames.VK, EntryPoint = "vkGetDisplayModeProperties2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, out uint pPropertyCount, VkDisplayModeProperties2KHR pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetDisplayModePropertiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, out uint pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetDisplayPlaneCapabilities2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, VkDisplayPlaneInfo2KHR pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR pCapabilities);
[DllImport(DllNames.VK, EntryPoint = "vkGetDisplayPlaneCapabilitiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
[DllImport(DllNames.VK, EntryPoint = "vkGetDisplayPlaneSupportedDisplaysKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint planeIndex, out uint pDisplayCount, VkDisplayKHR* pDisplays);
[DllImport(DllNames.VK, EntryPoint = "vkGetEventStatus", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetEventStatus(VkDevice device, VkEvent @event);
[DllImport(DllNames.VK, EntryPoint = "vkGetFenceFdKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetFenceFdKHR(VkDevice device, VkFenceGetFdInfoKHR pGetFdInfo, out int pFd);
[DllImport(DllNames.VK, EntryPoint = "vkGetFenceStatus", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetFenceStatus(VkDevice device, VkFence fence);
[DllImport(DllNames.VK, EntryPoint = "vkGetImageDrmFormatModifierPropertiesEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetImageMemoryRequirements", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetImageMemoryRequirements2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetImageMemoryRequirements2(VkDevice device, VkImageMemoryRequirementsInfo2 pInfo, VkMemoryRequirements2 pMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetImageMemoryRequirements2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetImageMemoryRequirements2KHR(VkDevice device, VkImageMemoryRequirementsInfo2 pInfo, VkMemoryRequirements2 pMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetImageSparseMemoryRequirements", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, out uint pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetImageSparseMemoryRequirements2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetImageSparseMemoryRequirements2(VkDevice device, VkImageSparseMemoryRequirementsInfo2 pInfo, out uint pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 pSparseMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetImageSparseMemoryRequirements2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetImageSparseMemoryRequirements2KHR(VkDevice device, VkImageSparseMemoryRequirementsInfo2 pInfo, out uint pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 pSparseMemoryRequirements);
[DllImport(DllNames.VK, EntryPoint = "vkGetImageSubresourceLayout", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetImageSubresourceLayout(VkDevice device, VkImage image, VkImageSubresource* pSubresource, VkSubresourceLayout pLayout);
[DllImport(DllNames.VK, EntryPoint = "vkGetInstanceProcAddr", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern PFNVkVoidFunctionDelegate VkGetInstanceProcAddr(VkInstance instance, CString pName);
[DllImport(DllNames.VK, EntryPoint = "vkGetMemoryFdKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetMemoryFdKHR(VkDevice device, VkMemoryGetFdInfoKHR pGetFdInfo, out int pFd);
[DllImport(DllNames.VK, EntryPoint = "vkGetMemoryFdPropertiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR pMemoryFdProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetMemoryHostPointerPropertiesEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, IntPtr pHostPointer, VkMemoryHostPointerPropertiesEXT pMemoryHostPointerProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPastPresentationTimingGOOGLE", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, out uint pPresentationTimingCount, VkPastPresentationTimingGOOGLE pPresentationTimings);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, out uint pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceDisplayPlaneProperties2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, out uint pPropertyCount, VkDisplayPlaneProperties2KHR pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, out uint pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceDisplayProperties2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, out uint pPropertyCount, VkDisplayProperties2KHR pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceDisplayPropertiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, out uint pPropertyCount, VkDisplayPropertiesKHR* pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceExternalBufferProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo, VkExternalBufferProperties pExternalBufferProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceExternalBufferPropertiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo, VkExternalBufferProperties pExternalBufferProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceExternalFenceProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo, VkExternalFenceProperties pExternalFenceProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceExternalFencePropertiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo, VkExternalFenceProperties pExternalFenceProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV pExternalImageFormatProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceExternalSemaphoreProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo, VkExternalSemaphoreProperties pExternalSemaphoreProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo, VkExternalSemaphoreProperties pExternalSemaphoreProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceFeatures", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceFeatures2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 pFeatures);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceFeatures2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 pFeatures);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceFormatProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceFormatProperties2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 pFormatProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceFormatProperties2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 pFormatProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX pFeatures, VkDeviceGeneratedCommandsLimitsNVX pLimits);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceImageFormatProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceImageFormatProperties2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo, VkImageFormatProperties2 pImageFormatProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceImageFormatProperties2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo, VkImageFormatProperties2 pImageFormatProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceMemoryProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceMemoryProperties2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 pMemoryProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceMemoryProperties2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 pMemoryProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceMultisamplePropertiesEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT pMultisampleProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDevicePresentRectanglesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out uint pRectCount, VkRect2D* pRects);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceProperties2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceProperties2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceQueueFamilyProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, out uint pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceQueueFamilyProperties2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, out uint pQueueFamilyPropertyCount, VkQueueFamilyProperties2 pQueueFamilyProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceQueueFamilyProperties2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, out uint pQueueFamilyPropertyCount, VkQueueFamilyProperties2 pQueueFamilyProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSparseImageFormatProperties", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, out uint pPropertyCount, VkSparseImageFormatProperties* pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSparseImageFormatProperties2", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo, out uint pPropertyCount, VkSparseImageFormatProperties2 pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo, out uint pPropertyCount, VkSparseImageFormatProperties2 pProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSurfaceCapabilities2EXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT pSurfaceCapabilities);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSurfaceCapabilities2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo, VkSurfaceCapabilities2KHR pSurfaceCapabilities);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSurfaceFormats2KHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo, out uint pSurfaceFormatCount, VkSurfaceFormat2KHR pSurfaceFormats);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSurfaceFormatsKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out uint pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSurfacePresentModesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out uint pPresentModeCount, VkPresentModeKHR* pPresentModes);
[DllImport(DllNames.VK, EntryPoint = "vkGetPhysicalDeviceSurfaceSupportKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
[DllImport(DllNames.VK, EntryPoint = "vkGetPipelineCacheData", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, out UIntPtr pDataSize, IntPtr pData);
[DllImport(DllNames.VK, EntryPoint = "vkGetQueryPoolResults", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint firstQuery, uint queryCount, UIntPtr dataSize, IntPtr pData, VkDeviceSize stride, VkQueryResultFlags flags);
[DllImport(DllNames.VK, EntryPoint = "vkGetQueueCheckpointDataNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetQueueCheckpointDataNV(VkQueue queue, out uint pCheckpointDataCount, VkCheckpointDataNV pCheckpointData);
[DllImport(DllNames.VK, EntryPoint = "vkGetRayTracingShaderGroupHandlesNV", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint firstGroup, uint groupCount, UIntPtr dataSize, IntPtr pData);
[DllImport(DllNames.VK, EntryPoint = "vkGetRefreshCycleDurationGOOGLE", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE pDisplayTimingProperties);
[DllImport(DllNames.VK, EntryPoint = "vkGetRenderAreaGranularity", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
[DllImport(DllNames.VK, EntryPoint = "vkGetSemaphoreFdKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetSemaphoreFdKHR(VkDevice device, VkSemaphoreGetFdInfoKHR pGetFdInfo, out int pFd);
[DllImport(DllNames.VK, EntryPoint = "vkGetShaderInfoAMD", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, out UIntPtr pInfoSize, IntPtr pInfo);
[DllImport(DllNames.VK, EntryPoint = "vkGetSwapchainCounterEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, out ulong pCounterValue);
[DllImport(DllNames.VK, EntryPoint = "vkGetSwapchainImagesKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, out uint pSwapchainImageCount, VkImage* pSwapchainImages);
[DllImport(DllNames.VK, EntryPoint = "vkGetSwapchainStatusKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain);
[DllImport(DllNames.VK, EntryPoint = "vkGetValidationCacheDataEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, out UIntPtr pDataSize, IntPtr pData);
[DllImport(DllNames.VK, EntryPoint = "vkImportFenceFdKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkImportFenceFdKHR(VkDevice device, VkImportFenceFdInfoKHR pImportFenceFdInfo);
[DllImport(DllNames.VK, EntryPoint = "vkImportSemaphoreFdKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkImportSemaphoreFdKHR(VkDevice device, VkImportSemaphoreFdInfoKHR pImportSemaphoreFdInfo);
[DllImport(DllNames.VK, EntryPoint = "vkInvalidateMappedMemoryRanges", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkInvalidateMappedMemoryRanges(VkDevice device, uint memoryRangeCount, VkMappedMemoryRange pMemoryRanges);
[DllImport(DllNames.VK, EntryPoint = "vkMapMemory", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, out void* ppData);
[DllImport(DllNames.VK, EntryPoint = "vkMergePipelineCaches", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint srcCacheCount, VkPipelineCache* pSrcCaches);
[DllImport(DllNames.VK, EntryPoint = "vkMergeValidationCachesEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint srcCacheCount, VkValidationCacheEXT* pSrcCaches);
[DllImport(DllNames.VK, EntryPoint = "vkQueueBeginDebugUtilsLabelEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkQueueBeginDebugUtilsLabelEXT(VkQueue queue, VkDebugUtilsLabelEXT pLabelInfo);
[DllImport(DllNames.VK, EntryPoint = "vkQueueBindSparse", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkQueueBindSparse(VkQueue queue, uint bindInfoCount, VkBindSparseInfo pBindInfo, VkFence fence);
[DllImport(DllNames.VK, EntryPoint = "vkQueueEndDebugUtilsLabelEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkQueueEndDebugUtilsLabelEXT(VkQueue queue);
[DllImport(DllNames.VK, EntryPoint = "vkQueueInsertDebugUtilsLabelEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkQueueInsertDebugUtilsLabelEXT(VkQueue queue, VkDebugUtilsLabelEXT pLabelInfo);
[DllImport(DllNames.VK, EntryPoint = "vkQueuePresentKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR pPresentInfo);
[DllImport(DllNames.VK, EntryPoint = "vkQueueSubmit", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkQueueSubmit(VkQueue queue, uint submitCount, VkSubmitInfo pSubmits, VkFence fence);
[DllImport(DllNames.VK, EntryPoint = "vkQueueWaitIdle", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkQueueWaitIdle(VkQueue queue);
[DllImport(DllNames.VK, EntryPoint = "vkRegisterDeviceEventEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkRegisterDeviceEventEXT(VkDevice device, VkDeviceEventInfoEXT pDeviceEventInfo, VkAllocationCallbacks pAllocator, VkFence* pFence);
[DllImport(DllNames.VK, EntryPoint = "vkRegisterDisplayEventEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, VkDisplayEventInfoEXT pDisplayEventInfo, VkAllocationCallbacks pAllocator, VkFence* pFence);
[DllImport(DllNames.VK, EntryPoint = "vkRegisterObjectsNVX", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint objectCount, VkObjectTableEntryNVX* ppObjectTableEntries, out uint pObjectIndices);
[DllImport(DllNames.VK, EntryPoint = "vkReleaseDisplayEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
[DllImport(DllNames.VK, EntryPoint = "vkResetCommandBuffer", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
[DllImport(DllNames.VK, EntryPoint = "vkResetCommandPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
[DllImport(DllNames.VK, EntryPoint = "vkResetDescriptorPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
[DllImport(DllNames.VK, EntryPoint = "vkResetEvent", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkResetEvent(VkDevice device, VkEvent @event);
[DllImport(DllNames.VK, EntryPoint = "vkResetFences", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkResetFences(VkDevice device, uint fenceCount, VkFence* pFences);
[DllImport(DllNames.VK, EntryPoint = "vkSetDebugUtilsObjectNameEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkSetDebugUtilsObjectNameEXT(VkDevice device, VkDebugUtilsObjectNameInfoEXT pNameInfo);
[DllImport(DllNames.VK, EntryPoint = "vkSetDebugUtilsObjectTagEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkSetDebugUtilsObjectTagEXT(VkDevice device, VkDebugUtilsObjectTagInfoEXT pTagInfo);
[DllImport(DllNames.VK, EntryPoint = "vkSetEvent", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkSetEvent(VkDevice device, VkEvent @event);
[DllImport(DllNames.VK, EntryPoint = "vkSetHdrMetadataEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkSetHdrMetadataEXT(VkDevice device, uint swapchainCount, VkSwapchainKHR* pSwapchains, VkHdrMetadataEXT pMetadata);
[DllImport(DllNames.VK, EntryPoint = "vkSubmitDebugUtilsMessageEXT", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, VkDebugUtilsMessengerCallbackDataEXT pCallbackData);
[DllImport(DllNames.VK, EntryPoint = "vkTrimCommandPool", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
[DllImport(DllNames.VK, EntryPoint = "vkTrimCommandPoolKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
[DllImport(DllNames.VK, EntryPoint = "vkUnmapMemory", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkUnmapMemory(VkDevice device, VkDeviceMemory memory);
[DllImport(DllNames.VK, EntryPoint = "vkUnregisterObjectsNVX", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint objectCount, VkObjectEntryTypeNVX* pObjectEntryTypes, out uint pObjectIndices);
[DllImport(DllNames.VK, EntryPoint = "vkUpdateDescriptorSets", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkUpdateDescriptorSets(VkDevice device, uint descriptorWriteCount, VkWriteDescriptorSet pDescriptorWrites, uint descriptorCopyCount, VkCopyDescriptorSet pDescriptorCopies);
[DllImport(DllNames.VK, EntryPoint = "vkUpdateDescriptorSetWithTemplate", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, IntPtr pData);
[DllImport(DllNames.VK, EntryPoint = "vkUpdateDescriptorSetWithTemplateKHR", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern void VkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, IntPtr pData);
[DllImport(DllNames.VK, EntryPoint = "vkWaitForFences", CallingConvention=CallingConvention.Cdecl)]
public static unsafe extern VkResult VkWaitForFences(VkDevice device, uint fenceCount, VkFence* pFences, VkBool32 waitAll, ulong timeout);
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment