• Home
• org.lwjgl
• lwjgl-vulkan
• 3.1.1
• source code
• VkPhysicalDeviceLimits.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.lwjgl.vulkan.VkPhysicalDeviceLimits Maven / Gradle / Ivy

/*
 * Copyright LWJGL. All rights reserved.
 * License terms: https://www.lwjgl.org/license
 * MACHINE GENERATED FILE, DO NOT EDIT
 */
package org.lwjgl.vulkan;

import java.nio.*;

import org.lwjgl.system.*;

import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.MemoryUtil.*;

/**
 * Structure reporting implementation-dependent physical device limits.
 * 
 * 
Description
 * 
 * 

 * 
1
 * 
typedef enum VkSampleCountFlagBits {
    VK_SAMPLE_COUNT_1_BIT = 0x00000001,
    VK_SAMPLE_COUNT_2_BIT = 0x00000002,
    VK_SAMPLE_COUNT_4_BIT = 0x00000004,
    VK_SAMPLE_COUNT_8_BIT = 0x00000008,
    VK_SAMPLE_COUNT_16_BIT = 0x00000010,
    VK_SAMPLE_COUNT_32_BIT = 0x00000020,
    VK_SAMPLE_COUNT_64_BIT = 0x00000040,
} VkSampleCountFlagBits;
 * 
 * 
The sample count limits defined above represent the minimum supported sample counts for each image type. Individual images may support additional sample counts, which are queried using {@link VK10#vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties} as described in  Supported Sample Counts.
 * 
 * 
 * 
See Also
 * 
 * 
{@link VkPhysicalDeviceProperties}
 * 
 * 
Member documentation
 * 
 * 

 * 
{@code maxImageDimension1D} – the maximum dimension ({@code width}) of an image created with an {@code imageType} of {@link VK10#VK_IMAGE_TYPE_1D IMAGE_TYPE_1D}.
 * 
{@code maxImageDimension2D} – the maximum dimension ({@code width} or {@code height}) of an image created with an {@code imageType} of {@link VK10#VK_IMAGE_TYPE_2D IMAGE_TYPE_2D} and without {@link VK10#VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT IMAGE_CREATE_CUBE_COMPATIBLE_BIT} set in {@code flags}.
 * 
{@code maxImageDimension3D} – the maximum dimension ({@code width}, {@code height}, or {@code depth}) of an image created with an {@code imageType} of {@link VK10#VK_IMAGE_TYPE_3D IMAGE_TYPE_3D}.
 * 
{@code maxImageDimensionCube} – the maximum dimension ({@code width} or {@code height}) of an image created with an {@code imageType} of {@link VK10#VK_IMAGE_TYPE_2D IMAGE_TYPE_2D} and with {@link VK10#VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT IMAGE_CREATE_CUBE_COMPATIBLE_BIT} set in {@code flags}.
 * 
{@code maxImageArrayLayers} – the maximum number of layers ({@code arrayLayers}) for an image.
 * 
{@code maxTexelBufferElements} – the maximum number of addressable texels for a buffer view created on a buffer which was created with the {@link VK10#VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT} or {@link VK10#VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT} set in the {@code usage} member of the {@link VkBufferCreateInfo} structure.
 * 
{@code maxUniformBufferRange} – the maximum value that can be specified in the {@code range} member of any {@link VkDescriptorBufferInfo} structures passed to a call to {@link VK10#vkUpdateDescriptorSets UpdateDescriptorSets} for descriptors of type {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER DESCRIPTOR_TYPE_UNIFORM_BUFFER} or {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC}.
 * 
{@code maxStorageBufferRange} – the maximum value that can be specified in the {@code range} member of any {@link VkDescriptorBufferInfo} structures passed to a call to {@link VK10#vkUpdateDescriptorSets UpdateDescriptorSets} for descriptors of type {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER DESCRIPTOR_TYPE_STORAGE_BUFFER} or {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC}.
 * 
{@code maxPushConstantsSize} – the maximum size, in bytes, of the pool of push constant memory. For each of the push constant ranges indicated by the {@code pPushConstantRanges} member of the {@link VkPipelineLayoutCreateInfo} structure, {@code offset} + {@code size} must be less than or equal to this limit.
 * 
{@code maxMemoryAllocationCount} – the maximum number of device memory allocations, as created by {@link VK10#vkAllocateMemory AllocateMemory}, which can simultaneously exist.
 * 
{@code maxSamplerAllocationCount} – the maximum number of sampler objects, as created by {@link VK10#vkCreateSampler CreateSampler}, which can simultaneously exist on a device.
 * 
{@code bufferImageGranularity} – the granularity, in bytes, at which buffer or linear image resources, and optimal image resources can be bound to adjacent offsets in the same {@code VkDeviceMemory} object without aliasing. See Buffer-Image Granularity for more details.
 * 
{@code sparseAddressSpaceSize} – the total amount of address space available, in bytes, for sparse memory resources. This is an upper bound on the sum of the size of all sparse resources, regardless of whether any memory is bound to them.
 * 
{@code maxBoundDescriptorSets} – the maximum number of descriptor sets that can be simultaneously used by a pipeline. All {@code DescriptorSet} decorations in shader modules must have a value less than {@code maxBoundDescriptorSets}. See the “Descriptor Sets” section.
 * 
{@code maxPerStageDescriptorSamplers} – the maximum number of samplers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_SAMPLER DESCRIPTOR_TYPE_SAMPLER} or {@link VK10#VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER} count against this limit. A descriptor is accessible to a shader stage when the {@code stageFlags} member of the {@link VkDescriptorSetLayoutBinding} structure has the bit for that shader stage set. See the “Sampler” section and the “Combined Image Sampler” section.
 * 
{@code maxPerStageDescriptorUniformBuffers} – the maximum number of uniform buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER DESCRIPTOR_TYPE_UNIFORM_BUFFER} or {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC} count against this limit. A descriptor is accessible to a shader stage when the {@code stageFlags} member of the {@link VkDescriptorSetLayoutBinding} structure has the bit for that shader stage set. See the “Uniform Buffer” section and the “Dynamic Uniform Buffer” section.
 * 
{@code maxPerStageDescriptorStorageBuffers} – the maximum number of storage buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER DESCRIPTOR_TYPE_STORAGE_BUFFER} or {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC} count against this limit. A descriptor is accessible to a pipeline shader stage when the {@code stageFlags} member of the {@link VkDescriptorSetLayoutBinding} structure has the bit for that shader stage set. See the “Storage Buffer” section and the “Dynamic Storage Buffer” section.
 * 
{@code maxPerStageDescriptorSampledImages} – the maximum number of sampled images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER}, {@link VK10#VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE DESCRIPTOR_TYPE_SAMPLED_IMAGE}, or {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER} count against this limit. A descriptor is accessible to a pipeline shader stage when the {@code stageFlags} member of the {@link VkDescriptorSetLayoutBinding} structure has the bit for that shader stage set. See the “Combined Image Sampler” section, the “Sampled Image” section, and the “Uniform Texel Buffer” section.
 * 
{@code maxPerStageDescriptorStorageImages} – the maximum number of storage images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_IMAGE DESCRIPTOR_TYPE_STORAGE_IMAGE}, or {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER} count against this limit. A descriptor is accessible to a pipeline shader stage when the {@code stageFlags} member of the {@link VkDescriptorSetLayoutBinding} structure has the bit for that shader stage set. See the “Storage Image” section, and the “Storage Texel Buffer” section.
 * 
{@code maxPerStageDescriptorInputAttachments} – the maximum number of input attachments that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT DESCRIPTOR_TYPE_INPUT_ATTACHMENT} count against this limit. A descriptor is accessible to a pipeline shader stage when the {@code stageFlags} member of the {@link VkDescriptorSetLayoutBinding} structure has the bit for that shader stage set. These are only supported for the fragment stage. See the “Input Attachment” section.
 * 
{@code maxPerStageResources} – the maximum number of resources that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER}, {@link VK10#VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE DESCRIPTOR_TYPE_SAMPLED_IMAGE}, {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_IMAGE DESCRIPTOR_TYPE_STORAGE_IMAGE}, {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER}, {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER}, {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER DESCRIPTOR_TYPE_UNIFORM_BUFFER}, {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER DESCRIPTOR_TYPE_STORAGE_BUFFER}, {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC}, {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC}, or {@link VK10#VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT DESCRIPTOR_TYPE_INPUT_ATTACHMENT} count against this limit. For the fragment shader stage the framebuffer color attachments also count against this limit.
 * 
{@code maxDescriptorSetSamplers} – the maximum number of samplers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_SAMPLER DESCRIPTOR_TYPE_SAMPLER} or {@link VK10#VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER} count against this limit. See the “Sampler” section and the “Combined Image Sampler” section.
 * 
{@code maxDescriptorSetUniformBuffers} – the maximum number of uniform buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER DESCRIPTOR_TYPE_UNIFORM_BUFFER} or {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC} count against this limit. See the “Uniform Buffer” section and the “Dynamic Uniform Buffer” section.
 * 
{@code maxDescriptorSetUniformBuffersDynamic} – the maximum number of dynamic uniform buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC} count against this limit. See the “Dynamic Uniform Buffer” section.
 * 
{@code maxDescriptorSetStorageBuffers} – the maximum number of storage buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER DESCRIPTOR_TYPE_STORAGE_BUFFER} or {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC} count against this limit. See the “Storage Buffer” section and the “Dynamic Storage Buffer” section.
 * 
{@code maxDescriptorSetStorageBuffersDynamic} – the maximum number of dynamic storage buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC} count against this limit. See the “Dynamic Storage Buffer” section.
 * 
{@code maxDescriptorSetSampledImages} – the maximum number of sampled images that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER}, {@link VK10#VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE DESCRIPTOR_TYPE_SAMPLED_IMAGE}, or {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER} count against this limit. See the “Combined Image Sampler” section, the “Sampled Image” section, and the “Uniform Texel Buffer” section.
 * 
{@code maxDescriptorSetStorageImages} – the maximum number of storage images that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_IMAGE DESCRIPTOR_TYPE_STORAGE_IMAGE}, or {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER} count against this limit. See the “Storage Image” section, and the “Storage Texel Buffer” section.
 * 
{@code maxDescriptorSetInputAttachments} – the maximum number of input attachments that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of {@link VK10#VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT DESCRIPTOR_TYPE_INPUT_ATTACHMENT} count against this limit. See the “Input Attachment” section.
 * 
{@code maxVertexInputAttributes} – the maximum number of vertex input attributes that can be specified for a graphics pipeline. These are described in the array of {@link VkVertexInputAttributeDescription} structures that are provided at graphics pipeline creation time via the {@code pVertexAttributeDescriptions} member of the {@link VkPipelineVertexInputStateCreateInfo} structure. See the “Vertex Attributes” section and the “Vertex Input Description” section.
 * 
{@code maxVertexInputBindings} – the maximum number of vertex buffers that can be specified for providing vertex attributes to a graphics pipeline. These are described in the array of {@link VkVertexInputBindingDescription} structures that are provided at graphics pipeline creation time via the {@code pVertexBindingDescriptions} member of the {@link VkPipelineVertexInputStateCreateInfo} structure. The {@code binding} member of {@link VkVertexInputBindingDescription} must be less than this limit. See the “Vertex Input Description” section.
 * 
{@code maxVertexInputAttributeOffset} – the maximum vertex input attribute offset that can be added to the vertex input binding stride. The {@code offset} member of the {@link VkVertexInputAttributeDescription} structure must be less than or equal to this limit. See the “Vertex Input Description” section.
 * 
{@code maxVertexInputBindingStride} – the maximum vertex input binding stride that can be specified in a vertex input binding. The {@code stride} member of the {@link VkVertexInputBindingDescription} structure must be less than or equal to this limit. See the “Vertex Input Description” section.
 * 
{@code maxVertexOutputComponents} – the maximum number of components of output variables which can be output by a vertex shader. See the “Vertex Shaders” section.
 * 
{@code maxTessellationGenerationLevel} – the maximum tessellation generation level supported by the fixed-function tessellation primitive generator. See the “Tessellation” chapter.
 * 
{@code maxTessellationPatchSize} – the maximum patch size, in vertices, of patches that can be processed by the tessellation control shader and tessellation primitive generator. The {@code patchControlPoints} member of the {@link VkPipelineTessellationStateCreateInfo} structure specified at pipeline creation time and the value provided in the {@code OutputVertices} execution mode of shader modules must be less than or equal to this limit. See the “Tessellation” chapter.
 * 
{@code maxTessellationControlPerVertexInputComponents} – the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation control shader stage.
 * 
{@code maxTessellationControlPerVertexOutputComponents} – the maximum number of components of per-vertex output variables which can be output from the tessellation control shader stage.
 * 
{@code maxTessellationControlPerPatchOutputComponents} – the maximum number of components of per-patch output variables which can be output from the tessellation control shader stage.
 * 
{@code maxTessellationControlTotalOutputComponents} – the maximum total number of components of per-vertex and per-patch output variables which can be output from the tessellation control shader stage.
 * 
{@code maxTessellationEvaluationInputComponents} – the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation evaluation shader stage.
 * 
{@code maxTessellationEvaluationOutputComponents} – the maximum number of components of per-vertex output variables which can be output from the tessellation evaluation shader stage.
 * 
{@code maxGeometryShaderInvocations} – the maximum invocation count supported for instanced geometry shaders. The value provided in the {@code Invocations} execution mode of shader modules must be less than or equal to this limit. See the “Geometry Shading” chapter.
 * 
{@code maxGeometryInputComponents} – the maximum number of components of input variables which can be provided as inputs to the geometry shader stage.
 * 
{@code maxGeometryOutputComponents} – the maximum number of components of output variables which can be output from the geometry shader stage.
 * 
{@code maxGeometryOutputVertices} – the maximum number of vertices which can be emitted by any geometry shader.
 * 
{@code maxGeometryTotalOutputComponents} – the maximum total number of components of output, across all emitted vertices, which can be output from the geometry shader stage.
 * 
{@code maxFragmentInputComponents} – the maximum number of components of input variables which can be provided as inputs to the fragment shader stage.
 * 
{@code maxFragmentOutputAttachments} – the maximum number of output attachments which can be written to by the fragment shader stage.
 * 
{@code maxFragmentDualSrcAttachments} – the maximum number of output attachments which can be written to by the fragment shader stage when blending is enabled and one of the dual source blend modes is in use. See the “Dual-Source Blending” section and dualSrcBlend.
 * 
{@code maxFragmentCombinedOutputResources} – the total number of storage buffers, storage images, and output buffers which can be used in the fragment shader stage.
 * 
{@code maxComputeSharedMemorySize} – the maximum total storage size, in bytes, of all variables declared with the {@code WorkgroupLocal} storage class in shader modules (or with the {@code shared} storage qualifier in GLSL) in the compute shader stage.
 * 
{@code maxComputeWorkGroupCount} – the maximum number of local workgroups that can be dispatched by a single dispatch command. These three values represent the maximum number of local workgroups for the X, Y, and Z dimensions, respectively. The {@code x}, {@code y}, and {@code z} parameters to the {@link VK10#vkCmdDispatch CmdDispatch} command, or members of the {@link VkDispatchIndirectCommand} structure must be less than or equal to the corresponding limit. See the “Dispatching Commands” chapter.
 * 
{@code maxComputeWorkGroupInvocations} – the maximum total number of compute shader invocations in a single local workgroup. The product of the X, Y, and Z sizes as specified by the {@code LocalSize} execution mode in shader modules and by the object decorated by the {@code WorkgroupSize} decoration must be less than or equal to this limit.
 * 
{@code maxComputeWorkGroupSize} – the maximum size of a local compute workgroup, per dimension. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The {@code x}, {@code y}, and {@code z} sizes specified by the {@code LocalSize} execution mode and by the object decorated by the {@code WorkgroupSize} decoration in shader modules must be less than or equal to the corresponding limit.
 * 
{@code subPixelPrecisionBits} – the number of bits of subpixel precision in framebuffer coordinates xf and yf. See the “Rasterization” chapter.
 * 
{@code subTexelPrecisionBits} – the number of bits of precision in the division along an axis of an image used for minification and magnification filters. 2subTexelPrecisionBits is the actual number of divisions along each axis of the image represented. The filtering hardware will snap to these locations when computing the filtered results.
 * 
{@code mipmapPrecisionBits} – the number of bits of division that the LOD calculation for mipmap fetching get snapped to when determining the contribution from each mip level to the mip filtered results. 2mipmapPrecisionBits is the actual number of divisions.
 * 
 * 
Note
 * 
 * 
For example, if this value is 2 bits then when linearly filtering between two levels, each level could: contribute: 0%, 33%, 66%, or 100% (this is just an example and the amount of contribution should be covered by different equations in the spec).
 * 
 * 
{@code maxDrawIndexedIndexValue} – the maximum index value that can be used for indexed draw calls when using 32-bit indices. This excludes the primitive restart index value of 0xFFFFFFFF. See fullDrawIndexUint32.
 * 
{@code maxDrawIndirectCount} – the maximum draw count that is supported for indirect draw calls. See multiDrawIndirect.
 * 
{@code maxSamplerLodBias} – the maximum absolute sampler level of detail bias. The sum of the {@code mipLodBias} member of the {@link VkSamplerCreateInfo} structure and the {@code Bias} operand of image sampling operations in shader modules (or 0 if no {@code Bias} operand is provided to an image sampling operation) are clamped to the range [-maxSamplerLodBias,+maxSamplerLodBias]. See samplers-mipLodBias.
 * 
{@code maxSamplerAnisotropy} – the maximum degree of sampler anisotropy. The maximum degree of anisotropic filtering used for an image sampling operation is the minimum of the {@code maxAnisotropy} member of the {@link VkSamplerCreateInfo} structure and this limit. See samplers-maxAnisotropy.
 * 
{@code maxViewports} – the maximum number of active viewports. The {@code viewportCount} member of the {@link VkPipelineViewportStateCreateInfo} structure that is provided at pipeline creation must be less than or equal to this limit.
 * 
{@code maxViewportDimensions} – are the maximum viewport dimensions in the X (width) and Y (height) dimensions, respectively. The maximum viewport dimensions must be greater than or equal to the largest image which can be created and used as a framebuffer attachment. See Controlling the Viewport.
 * 
{@code viewportBoundsRange} – the [minimum, maximum] range that the corners of a viewport must be contained in. This range must be at least
[-2 {times} size, 2 {times} size - 1], where size = max(maxViewportDimensions[0], maxViewportDimensions[1]) See Controlling the Viewport.
 * 
 * 
Note
 * 
 * 
The intent of the {@code viewportBoundsRange} limit is to allow a maximum sized viewport to be arbitrarily shifted relative to the output target as long as at least some portion intersects. This would give a bounds limit of [-size + 1, 2 {times} size - 1] which would allow all possible non-empty-set intersections of the output target and the viewport. Since these numbers are typically powers of two, picking the signed number range using the smallest possible number of bits ends up with the specified range.
 * 
 * 
{@code viewportSubPixelBits} – the number of bits of subpixel precision for viewport bounds. The subpixel precision that floating-point viewport bounds are interpreted at is given by this limit.
 * 
{@code minMemoryMapAlignment} – the minimum required: alignment, in bytes, of host visible memory allocations within the host address space. When mapping a memory allocation with {@link VK10#vkMapMemory MapMemory}, subtracting {@code offset} bytes from the returned pointer will always produce an integer multiple of this limit. See the “Host Access to Device Memory Objects” section.
 * 
{@code minTexelBufferOffsetAlignment} – the minimum required: alignment, in bytes, for the {@code offset} member of the {@link VkBufferViewCreateInfo} structure for texel buffers. When a buffer view is created for a buffer which was created with {@link VK10#VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT} or {@link VK10#VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT} set in the {@code usage} member of the {@link VkBufferCreateInfo} structure, the {@code offset} must be an integer multiple of this limit.
 * 
{@code minUniformBufferOffsetAlignment} – the minimum required: alignment, in bytes, for the {@code offset} member of the {@link VkDescriptorBufferInfo} structure for uniform buffers. When a descriptor of type {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER DESCRIPTOR_TYPE_UNIFORM_BUFFER} or {@link VK10#VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC} is updated, the {@code offset} must be an integer multiple of this limit. Similarly, dynamic offsets for uniform buffers must be multiples of this limit.
 * 
{@code minStorageBufferOffsetAlignment} – the minimum required: alignment, in bytes, for the {@code offset} member of the {@link VkDescriptorBufferInfo} structure for storage buffers. When a descriptor of type {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER DESCRIPTOR_TYPE_STORAGE_BUFFER} or {@link VK10#VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC} is updated, the {@code offset} must be an integer multiple of this limit. Similarly, dynamic offsets for storage buffers must be multiples of this limit.
 * 
{@code minTexelOffset} – the minimum offset value for the {@code ConstOffset} image operand of any of the {@code OpImageSample}* or {@code OpImageFetch}* image instructions.
 * 
{@code maxTexelOffset} – the maximum offset value for the {@code ConstOffset} image operand of any of the {@code OpImageSample}* or {@code OpImageFetch}* image instructions.
 * 
{@code minTexelGatherOffset} – the minimum offset value for the {@code Offset} or {@code ConstOffsets} image operands of any of the {@code OpImage}*{@code Gather} image instructions.
 * 
{@code maxTexelGatherOffset} – the maximum offset value for the {@code Offset} or {@code ConstOffsets} image operands of any of the {@code OpImage}*{@code Gather} image instructions.
 * 
{@code minInterpolationOffset} – the minimum negative offset value for the {@code offset} operand of the {@code InterpolateAtOffset} extended instruction.
 * 
{@code maxInterpolationOffset} – the maximum positive offset value for the {@code offset} operand of the {@code InterpolateAtOffset} extended instruction.
 * 
{@code subPixelInterpolationOffsetBits} – the number of subpixel fractional bits that the {@code x} and {@code y} offsets to the {@code InterpolateAtOffset} extended instruction may be rounded to as fixed-point values.
 * 
{@code maxFramebufferWidth} – the maximum width for a framebuffer. The {@code width} member of the {@link VkFramebufferCreateInfo} structure must be less than or equal to this limit.
 * 
{@code maxFramebufferHeight} – the maximum height for a framebuffer. The {@code height} member of the {@link VkFramebufferCreateInfo} structure must be less than or equal to this limit.
 * 
{@code maxFramebufferLayers} – the maximum layer count for a layered framebuffer. The {@code layers} member of the {@link VkFramebufferCreateInfo} structure must be less than or equal to this limit.
 * 
{@code framebufferColorSampleCounts} – a bitmask1 of {@code VkSampleCountFlagBits} bits indicating the color sample counts that are supported for all framebuffer color attachments.
 * 
{@code framebufferDepthSampleCounts} – a bitmask1 of {@code VkSampleCountFlagBits} bits indicating the supported depth sample counts for all framebuffer depth/stencil attachments, when the format includes a depth component.
 * 
{@code framebufferStencilSampleCounts} – a bitmask1 of {@code VkSampleCountFlagBits} bits indicating the supported stencil sample counts for all framebuffer depth/stencil attachments, when the format includes a stencil component.
 * 
{@code framebufferNoAttachmentsSampleCounts} – a bitmask1 of {@code VkSampleCountFlagBits} bits indicating the supported sample counts for a framebuffer with no attachments.
 * 
{@code maxColorAttachments} – the maximum number of color attachments that can be used by a subpass in a render pass. The {@code colorAttachmentCount} member of the {@link VkSubpassDescription} structure must be less than or equal to this limit.
 * 
{@code sampledImageColorSampleCounts} – a bitmask1 of {@code VkSampleCountFlagBits} bits indicating the sample counts supported for all 2D images created with {@link VK10#VK_IMAGE_TILING_OPTIMAL IMAGE_TILING_OPTIMAL}, {@code usage} containing {@link VK10#VK_IMAGE_USAGE_SAMPLED_BIT IMAGE_USAGE_SAMPLED_BIT}, and a non-integer color format.
 * 
{@code sampledImageIntegerSampleCounts} – a bitmask1 of {@code VkSampleCountFlagBits} bits indicating the sample counts supported for all 2D images created with {@link VK10#VK_IMAGE_TILING_OPTIMAL IMAGE_TILING_OPTIMAL}, {@code usage} containing {@link VK10#VK_IMAGE_USAGE_SAMPLED_BIT IMAGE_USAGE_SAMPLED_BIT}, and an integer color format.
 * 
{@code sampledImageDepthSampleCounts} – a bitmask1 of {@code VkSampleCountFlagBits} bits indicating the sample counts supported for all 2D images created with {@link VK10#VK_IMAGE_TILING_OPTIMAL IMAGE_TILING_OPTIMAL}, {@code usage} containing {@link VK10#VK_IMAGE_USAGE_SAMPLED_BIT IMAGE_USAGE_SAMPLED_BIT}, and a depth format.
 * 
{@code sampledImageStencilSampleCounts} – a bitmask1 of {@code VkSampleCountFlagBits} bits indicating the sample supported for all 2D images created with {@link VK10#VK_IMAGE_TILING_OPTIMAL IMAGE_TILING_OPTIMAL}, {@code usage} containing {@link VK10#VK_IMAGE_USAGE_SAMPLED_BIT IMAGE_USAGE_SAMPLED_BIT}, and a stencil format.
 * 
{@code storageImageSampleCounts} – a bitmask1 of {@code VkSampleCountFlagBits} bits indicating the sample counts supported for all 2D images created with {@link VK10#VK_IMAGE_TILING_OPTIMAL IMAGE_TILING_OPTIMAL}, and {@code usage} containing {@link VK10#VK_IMAGE_USAGE_STORAGE_BIT IMAGE_USAGE_STORAGE_BIT}.
 * 
{@code maxSampleMaskWords} – the maximum number of array elements of a variable decorated with the {@code SampleMask} built-in decoration.
 * 
{@code timestampComputeAndGraphics} – indicates support for timestamps on all graphics and compute queues. If this limit is set to {@link VK10#VK_TRUE TRUE}, all queues that advertise the {@link VK10#VK_QUEUE_GRAPHICS_BIT QUEUE_GRAPHICS_BIT} or {@link VK10#VK_QUEUE_COMPUTE_BIT QUEUE_COMPUTE_BIT} in the {@link VkQueueFamilyProperties}{@code ::queueFlags} support {@link VkQueueFamilyProperties}{@code ::timestampValidBits} of at least 36. See Timestamp Queries.
 * 
{@code timestampPeriod} – the number of nanoseconds required: for a timestamp query to be incremented by 1. See Timestamp Queries.
 * 
{@code maxClipDistances} – the maximum number of clip distances that can be used in a single shader stage. The size of any array declared with the {@code ClipDistance} built-in decoration in a shader module must be less than or equal to this limit.
 * 
{@code maxCullDistances} – the maximum number of cull distances that can be used in a single shader stage. The size of any array declared with the {@code CullDistance} built-in decoration in a shader module must be less than or equal to this limit.
 * 
{@code maxCombinedClipAndCullDistances} – the maximum combined number of clip and cull distances that can be used in a single shader stage. The sum of the sizes of any pair of arrays declared with the {@code ClipDistance} and {@code CullDistance} built-in decoration used by a single shader stage in a shader module must be less than or equal to this limit.
 * 
{@code discreteQueuePriorities} – the number of discrete priorities that can be assigned to a queue based on the value of each member of {@link VkDeviceQueueCreateInfo}{@code ::pQueuePriorities}. This must be at least 2, and levels must be spread evenly over the range, with at least one level at 1.0, and another at 0.0. See the “Queue Priority” section.
 * 
{@code pointSizeRange} – the range [minimum,maximum] of supported sizes for points. Values written to variables decorated with the {@code PointSize} built-in decoration are clamped to this range.
 * 
{@code lineWidthRange} – the range [minimum,maximum] of supported widths for lines. Values specified by the {@code lineWidth} member of the {@link VkPipelineRasterizationStateCreateInfo} or the {@code lineWidth} parameter to {@link VK10#vkCmdSetLineWidth CmdSetLineWidth} are clamped to this range.
 * 
{@code pointSizeGranularity} – the granularity of supported point sizes. Not all point sizes in the range defined by {@code pointSizeRange} are supported. This limit specifies the granularity (or increment) between successive supported point sizes.
 * 
{@code lineWidthGranularity} – the granularity of supported line widths. Not all line widths in the range defined by {@code lineWidthRange} are supported. This limit specifies the granularity (or increment) between successive supported line widths.
 * 
{@code strictLines} – indicates whether lines are rasterized according to the preferred method of rasterization. If set to {@link VK10#VK_FALSE FALSE}, lines may be rasterized under a relaxed set of rules. If set to {@link VK10#VK_TRUE TRUE}, lines are rasterized as per the strict definition. See Basic Line Segment Rasterization.
 * 
{@code standardSampleLocations} – indicates whether rasterization uses the standard sample locations as documented in Multisampling. If set to {@link VK10#VK_TRUE TRUE}, the implementation uses the documented sample locations. If set to {@link VK10#VK_FALSE FALSE}, the implementation may use different sample locations.
 * 
{@code optimalBufferCopyOffsetAlignment} – the optimal buffer offset alignment in bytes for {@link VK10#vkCmdCopyBufferToImage CmdCopyBufferToImage} and {@link VK10#vkCmdCopyImageToBuffer CmdCopyImageToBuffer}. The per texel alignment requirements are still enforced, this is just an additional alignment recommendation for optimal performance and power.
 * 
{@code optimalBufferCopyRowPitchAlignment} – the optimal buffer row pitch alignment in bytes for {@link VK10#vkCmdCopyBufferToImage CmdCopyBufferToImage} and {@link VK10#vkCmdCopyImageToBuffer CmdCopyImageToBuffer}. Row pitch is the number of bytes between texels with the same X coordinate in adjacent rows (Y coordinates differ by one). The per texel alignment requirements are still enforced, this is just an additional alignment recommendation for optimal performance and power.
 * 
{@code nonCoherentAtomSize} – the size and alignment in bytes that bounds concurrent access to host-mapped device memory.
 * 
 * 
 * 
Layout
 * 
 * 
struct VkPhysicalDeviceLimits {
    uint32_t maxImageDimension1D;
    uint32_t maxImageDimension2D;
    uint32_t maxImageDimension3D;
    uint32_t maxImageDimensionCube;
    uint32_t maxImageArrayLayers;
    uint32_t maxTexelBufferElements;
    uint32_t maxUniformBufferRange;
    uint32_t maxStorageBufferRange;
    uint32_t maxPushConstantsSize;
    uint32_t maxMemoryAllocationCount;
    uint32_t maxSamplerAllocationCount;
    VkDeviceSize bufferImageGranularity;
    VkDeviceSize sparseAddressSpaceSize;
    uint32_t maxBoundDescriptorSets;
    uint32_t maxPerStageDescriptorSamplers;
    uint32_t maxPerStageDescriptorUniformBuffers;
    uint32_t maxPerStageDescriptorStorageBuffers;
    uint32_t maxPerStageDescriptorSampledImages;
    uint32_t maxPerStageDescriptorStorageImages;
    uint32_t maxPerStageDescriptorInputAttachments;
    uint32_t maxPerStageResources;
    uint32_t maxDescriptorSetSamplers;
    uint32_t maxDescriptorSetUniformBuffers;
    uint32_t maxDescriptorSetUniformBuffersDynamic;
    uint32_t maxDescriptorSetStorageBuffers;
    uint32_t maxDescriptorSetStorageBuffersDynamic;
    uint32_t maxDescriptorSetSampledImages;
    uint32_t maxDescriptorSetStorageImages;
    uint32_t maxDescriptorSetInputAttachments;
    uint32_t maxVertexInputAttributes;
    uint32_t maxVertexInputBindings;
    uint32_t maxVertexInputAttributeOffset;
    uint32_t maxVertexInputBindingStride;
    uint32_t maxVertexOutputComponents;
    uint32_t maxTessellationGenerationLevel;
    uint32_t maxTessellationPatchSize;
    uint32_t maxTessellationControlPerVertexInputComponents;
    uint32_t maxTessellationControlPerVertexOutputComponents;
    uint32_t maxTessellationControlPerPatchOutputComponents;
    uint32_t maxTessellationControlTotalOutputComponents;
    uint32_t maxTessellationEvaluationInputComponents;
    uint32_t maxTessellationEvaluationOutputComponents;
    uint32_t maxGeometryShaderInvocations;
    uint32_t maxGeometryInputComponents;
    uint32_t maxGeometryOutputComponents;
    uint32_t maxGeometryOutputVertices;
    uint32_t maxGeometryTotalOutputComponents;
    uint32_t maxFragmentInputComponents;
    uint32_t maxFragmentOutputAttachments;
    uint32_t maxFragmentDualSrcAttachments;
    uint32_t maxFragmentCombinedOutputResources;
    uint32_t maxComputeSharedMemorySize;
    uint32_t maxComputeWorkGroupCount[3];
    uint32_t maxComputeWorkGroupInvocations;
    uint32_t maxComputeWorkGroupSize[3];
    uint32_t subPixelPrecisionBits;
    uint32_t subTexelPrecisionBits;
    uint32_t mipmapPrecisionBits;
    uint32_t maxDrawIndexedIndexValue;
    uint32_t maxDrawIndirectCount;
    float maxSamplerLodBias;
    float maxSamplerAnisotropy;
    uint32_t maxViewports;
    uint32_t maxViewportDimensions[2];
    float viewportBoundsRange[2];
    uint32_t viewportSubPixelBits;
    size_t minMemoryMapAlignment;
    VkDeviceSize minTexelBufferOffsetAlignment;
    VkDeviceSize minUniformBufferOffsetAlignment;
    VkDeviceSize minStorageBufferOffsetAlignment;
    int32_t minTexelOffset;
    uint32_t maxTexelOffset;
    int32_t minTexelGatherOffset;
    uint32_t maxTexelGatherOffset;
    float minInterpolationOffset;
    float maxInterpolationOffset;
    uint32_t subPixelInterpolationOffsetBits;
    uint32_t maxFramebufferWidth;
    uint32_t maxFramebufferHeight;
    uint32_t maxFramebufferLayers;
    VkSampleCountFlags framebufferColorSampleCounts;
    VkSampleCountFlags framebufferDepthSampleCounts;
    VkSampleCountFlags framebufferStencilSampleCounts;
    VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
    uint32_t maxColorAttachments;
    VkSampleCountFlags sampledImageColorSampleCounts;
    VkSampleCountFlags sampledImageIntegerSampleCounts;
    VkSampleCountFlags sampledImageDepthSampleCounts;
    VkSampleCountFlags sampledImageStencilSampleCounts;
    VkSampleCountFlags storageImageSampleCounts;
    uint32_t maxSampleMaskWords;
    VkBool32 timestampComputeAndGraphics;
    float timestampPeriod;
    uint32_t maxClipDistances;
    uint32_t maxCullDistances;
    uint32_t maxCombinedClipAndCullDistances;
    uint32_t discreteQueuePriorities;
    float pointSizeRange[2];
    float lineWidthRange[2];
    float pointSizeGranularity;
    float lineWidthGranularity;
    VkBool32 strictLines;
    VkBool32 standardSampleLocations;
    VkDeviceSize optimalBufferCopyOffsetAlignment;
    VkDeviceSize optimalBufferCopyRowPitchAlignment;
    VkDeviceSize nonCoherentAtomSize;
}
 */
public class VkPhysicalDeviceLimits extends Struct {

	/** The struct size in bytes. */
	public static final int SIZEOF;

	public static final int ALIGNOF;

	/** The struct member offsets. */
	public static final int
		MAXIMAGEDIMENSION1D,
		MAXIMAGEDIMENSION2D,
		MAXIMAGEDIMENSION3D,
		MAXIMAGEDIMENSIONCUBE,
		MAXIMAGEARRAYLAYERS,
		MAXTEXELBUFFERELEMENTS,
		MAXUNIFORMBUFFERRANGE,
		MAXSTORAGEBUFFERRANGE,
		MAXPUSHCONSTANTSSIZE,
		MAXMEMORYALLOCATIONCOUNT,
		MAXSAMPLERALLOCATIONCOUNT,
		BUFFERIMAGEGRANULARITY,
		SPARSEADDRESSSPACESIZE,
		MAXBOUNDDESCRIPTORSETS,
		MAXPERSTAGEDESCRIPTORSAMPLERS,
		MAXPERSTAGEDESCRIPTORUNIFORMBUFFERS,
		MAXPERSTAGEDESCRIPTORSTORAGEBUFFERS,
		MAXPERSTAGEDESCRIPTORSAMPLEDIMAGES,
		MAXPERSTAGEDESCRIPTORSTORAGEIMAGES,
		MAXPERSTAGEDESCRIPTORINPUTATTACHMENTS,
		MAXPERSTAGERESOURCES,
		MAXDESCRIPTORSETSAMPLERS,
		MAXDESCRIPTORSETUNIFORMBUFFERS,
		MAXDESCRIPTORSETUNIFORMBUFFERSDYNAMIC,
		MAXDESCRIPTORSETSTORAGEBUFFERS,
		MAXDESCRIPTORSETSTORAGEBUFFERSDYNAMIC,
		MAXDESCRIPTORSETSAMPLEDIMAGES,
		MAXDESCRIPTORSETSTORAGEIMAGES,
		MAXDESCRIPTORSETINPUTATTACHMENTS,
		MAXVERTEXINPUTATTRIBUTES,
		MAXVERTEXINPUTBINDINGS,
		MAXVERTEXINPUTATTRIBUTEOFFSET,
		MAXVERTEXINPUTBINDINGSTRIDE,
		MAXVERTEXOUTPUTCOMPONENTS,
		MAXTESSELLATIONGENERATIONLEVEL,
		MAXTESSELLATIONPATCHSIZE,
		MAXTESSELLATIONCONTROLPERVERTEXINPUTCOMPONENTS,
		MAXTESSELLATIONCONTROLPERVERTEXOUTPUTCOMPONENTS,
		MAXTESSELLATIONCONTROLPERPATCHOUTPUTCOMPONENTS,
		MAXTESSELLATIONCONTROLTOTALOUTPUTCOMPONENTS,
		MAXTESSELLATIONEVALUATIONINPUTCOMPONENTS,
		MAXTESSELLATIONEVALUATIONOUTPUTCOMPONENTS,
		MAXGEOMETRYSHADERINVOCATIONS,
		MAXGEOMETRYINPUTCOMPONENTS,
		MAXGEOMETRYOUTPUTCOMPONENTS,
		MAXGEOMETRYOUTPUTVERTICES,
		MAXGEOMETRYTOTALOUTPUTCOMPONENTS,
		MAXFRAGMENTINPUTCOMPONENTS,
		MAXFRAGMENTOUTPUTATTACHMENTS,
		MAXFRAGMENTDUALSRCATTACHMENTS,
		MAXFRAGMENTCOMBINEDOUTPUTRESOURCES,
		MAXCOMPUTESHAREDMEMORYSIZE,
		MAXCOMPUTEWORKGROUPCOUNT,
		MAXCOMPUTEWORKGROUPINVOCATIONS,
		MAXCOMPUTEWORKGROUPSIZE,
		SUBPIXELPRECISIONBITS,
		SUBTEXELPRECISIONBITS,
		MIPMAPPRECISIONBITS,
		MAXDRAWINDEXEDINDEXVALUE,
		MAXDRAWINDIRECTCOUNT,
		MAXSAMPLERLODBIAS,
		MAXSAMPLERANISOTROPY,
		MAXVIEWPORTS,
		MAXVIEWPORTDIMENSIONS,
		VIEWPORTBOUNDSRANGE,
		VIEWPORTSUBPIXELBITS,
		MINMEMORYMAPALIGNMENT,
		MINTEXELBUFFEROFFSETALIGNMENT,
		MINUNIFORMBUFFEROFFSETALIGNMENT,
		MINSTORAGEBUFFEROFFSETALIGNMENT,
		MINTEXELOFFSET,
		MAXTEXELOFFSET,
		MINTEXELGATHEROFFSET,
		MAXTEXELGATHEROFFSET,
		MININTERPOLATIONOFFSET,
		MAXINTERPOLATIONOFFSET,
		SUBPIXELINTERPOLATIONOFFSETBITS,
		MAXFRAMEBUFFERWIDTH,
		MAXFRAMEBUFFERHEIGHT,
		MAXFRAMEBUFFERLAYERS,
		FRAMEBUFFERCOLORSAMPLECOUNTS,
		FRAMEBUFFERDEPTHSAMPLECOUNTS,
		FRAMEBUFFERSTENCILSAMPLECOUNTS,
		FRAMEBUFFERNOATTACHMENTSSAMPLECOUNTS,
		MAXCOLORATTACHMENTS,
		SAMPLEDIMAGECOLORSAMPLECOUNTS,
		SAMPLEDIMAGEINTEGERSAMPLECOUNTS,
		SAMPLEDIMAGEDEPTHSAMPLECOUNTS,
		SAMPLEDIMAGESTENCILSAMPLECOUNTS,
		STORAGEIMAGESAMPLECOUNTS,
		MAXSAMPLEMASKWORDS,
		TIMESTAMPCOMPUTEANDGRAPHICS,
		TIMESTAMPPERIOD,
		MAXCLIPDISTANCES,
		MAXCULLDISTANCES,
		MAXCOMBINEDCLIPANDCULLDISTANCES,
		DISCRETEQUEUEPRIORITIES,
		POINTSIZERANGE,
		LINEWIDTHRANGE,
		POINTSIZEGRANULARITY,
		LINEWIDTHGRANULARITY,
		STRICTLINES,
		STANDARDSAMPLELOCATIONS,
		OPTIMALBUFFERCOPYOFFSETALIGNMENT,
		OPTIMALBUFFERCOPYROWPITCHALIGNMENT,
		NONCOHERENTATOMSIZE;

	static {
		Layout layout = __struct(
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(8),
			__member(8),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__array(4, 3),
			__member(4),
			__array(4, 3),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__array(4, 2),
			__array(4, 2),
			__member(4),
			__member(POINTER_SIZE),
			__member(8),
			__member(8),
			__member(8),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__array(4, 2),
			__array(4, 2),
			__member(4),
			__member(4),
			__member(4),
			__member(4),
			__member(8),
			__member(8),
			__member(8)
		);

		SIZEOF = layout.getSize();
		ALIGNOF = layout.getAlignment();

		MAXIMAGEDIMENSION1D = layout.offsetof(0);
		MAXIMAGEDIMENSION2D = layout.offsetof(1);
		MAXIMAGEDIMENSION3D = layout.offsetof(2);
		MAXIMAGEDIMENSIONCUBE = layout.offsetof(3);
		MAXIMAGEARRAYLAYERS = layout.offsetof(4);
		MAXTEXELBUFFERELEMENTS = layout.offsetof(5);
		MAXUNIFORMBUFFERRANGE = layout.offsetof(6);
		MAXSTORAGEBUFFERRANGE = layout.offsetof(7);
		MAXPUSHCONSTANTSSIZE = layout.offsetof(8);
		MAXMEMORYALLOCATIONCOUNT = layout.offsetof(9);
		MAXSAMPLERALLOCATIONCOUNT = layout.offsetof(10);
		BUFFERIMAGEGRANULARITY = layout.offsetof(11);
		SPARSEADDRESSSPACESIZE = layout.offsetof(12);
		MAXBOUNDDESCRIPTORSETS = layout.offsetof(13);
		MAXPERSTAGEDESCRIPTORSAMPLERS = layout.offsetof(14);
		MAXPERSTAGEDESCRIPTORUNIFORMBUFFERS = layout.offsetof(15);
		MAXPERSTAGEDESCRIPTORSTORAGEBUFFERS = layout.offsetof(16);
		MAXPERSTAGEDESCRIPTORSAMPLEDIMAGES = layout.offsetof(17);
		MAXPERSTAGEDESCRIPTORSTORAGEIMAGES = layout.offsetof(18);
		MAXPERSTAGEDESCRIPTORINPUTATTACHMENTS = layout.offsetof(19);
		MAXPERSTAGERESOURCES = layout.offsetof(20);
		MAXDESCRIPTORSETSAMPLERS = layout.offsetof(21);
		MAXDESCRIPTORSETUNIFORMBUFFERS = layout.offsetof(22);
		MAXDESCRIPTORSETUNIFORMBUFFERSDYNAMIC = layout.offsetof(23);
		MAXDESCRIPTORSETSTORAGEBUFFERS = layout.offsetof(24);
		MAXDESCRIPTORSETSTORAGEBUFFERSDYNAMIC = layout.offsetof(25);
		MAXDESCRIPTORSETSAMPLEDIMAGES = layout.offsetof(26);
		MAXDESCRIPTORSETSTORAGEIMAGES = layout.offsetof(27);
		MAXDESCRIPTORSETINPUTATTACHMENTS = layout.offsetof(28);
		MAXVERTEXINPUTATTRIBUTES = layout.offsetof(29);
		MAXVERTEXINPUTBINDINGS = layout.offsetof(30);
		MAXVERTEXINPUTATTRIBUTEOFFSET = layout.offsetof(31);
		MAXVERTEXINPUTBINDINGSTRIDE = layout.offsetof(32);
		MAXVERTEXOUTPUTCOMPONENTS = layout.offsetof(33);
		MAXTESSELLATIONGENERATIONLEVEL = layout.offsetof(34);
		MAXTESSELLATIONPATCHSIZE = layout.offsetof(35);
		MAXTESSELLATIONCONTROLPERVERTEXINPUTCOMPONENTS = layout.offsetof(36);
		MAXTESSELLATIONCONTROLPERVERTEXOUTPUTCOMPONENTS = layout.offsetof(37);
		MAXTESSELLATIONCONTROLPERPATCHOUTPUTCOMPONENTS = layout.offsetof(38);
		MAXTESSELLATIONCONTROLTOTALOUTPUTCOMPONENTS = layout.offsetof(39);
		MAXTESSELLATIONEVALUATIONINPUTCOMPONENTS = layout.offsetof(40);
		MAXTESSELLATIONEVALUATIONOUTPUTCOMPONENTS = layout.offsetof(41);
		MAXGEOMETRYSHADERINVOCATIONS = layout.offsetof(42);
		MAXGEOMETRYINPUTCOMPONENTS = layout.offsetof(43);
		MAXGEOMETRYOUTPUTCOMPONENTS = layout.offsetof(44);
		MAXGEOMETRYOUTPUTVERTICES = layout.offsetof(45);
		MAXGEOMETRYTOTALOUTPUTCOMPONENTS = layout.offsetof(46);
		MAXFRAGMENTINPUTCOMPONENTS = layout.offsetof(47);
		MAXFRAGMENTOUTPUTATTACHMENTS = layout.offsetof(48);
		MAXFRAGMENTDUALSRCATTACHMENTS = layout.offsetof(49);
		MAXFRAGMENTCOMBINEDOUTPUTRESOURCES = layout.offsetof(50);
		MAXCOMPUTESHAREDMEMORYSIZE = layout.offsetof(51);
		MAXCOMPUTEWORKGROUPCOUNT = layout.offsetof(52);
		MAXCOMPUTEWORKGROUPINVOCATIONS = layout.offsetof(53);
		MAXCOMPUTEWORKGROUPSIZE = layout.offsetof(54);
		SUBPIXELPRECISIONBITS = layout.offsetof(55);
		SUBTEXELPRECISIONBITS = layout.offsetof(56);
		MIPMAPPRECISIONBITS = layout.offsetof(57);
		MAXDRAWINDEXEDINDEXVALUE = layout.offsetof(58);
		MAXDRAWINDIRECTCOUNT = layout.offsetof(59);
		MAXSAMPLERLODBIAS = layout.offsetof(60);
		MAXSAMPLERANISOTROPY = layout.offsetof(61);
		MAXVIEWPORTS = layout.offsetof(62);
		MAXVIEWPORTDIMENSIONS = layout.offsetof(63);
		VIEWPORTBOUNDSRANGE = layout.offsetof(64);
		VIEWPORTSUBPIXELBITS = layout.offsetof(65);
		MINMEMORYMAPALIGNMENT = layout.offsetof(66);
		MINTEXELBUFFEROFFSETALIGNMENT = layout.offsetof(67);
		MINUNIFORMBUFFEROFFSETALIGNMENT = layout.offsetof(68);
		MINSTORAGEBUFFEROFFSETALIGNMENT = layout.offsetof(69);
		MINTEXELOFFSET = layout.offsetof(70);
		MAXTEXELOFFSET = layout.offsetof(71);
		MINTEXELGATHEROFFSET = layout.offsetof(72);
		MAXTEXELGATHEROFFSET = layout.offsetof(73);
		MININTERPOLATIONOFFSET = layout.offsetof(74);
		MAXINTERPOLATIONOFFSET = layout.offsetof(75);
		SUBPIXELINTERPOLATIONOFFSETBITS = layout.offsetof(76);
		MAXFRAMEBUFFERWIDTH = layout.offsetof(77);
		MAXFRAMEBUFFERHEIGHT = layout.offsetof(78);
		MAXFRAMEBUFFERLAYERS = layout.offsetof(79);
		FRAMEBUFFERCOLORSAMPLECOUNTS = layout.offsetof(80);
		FRAMEBUFFERDEPTHSAMPLECOUNTS = layout.offsetof(81);
		FRAMEBUFFERSTENCILSAMPLECOUNTS = layout.offsetof(82);
		FRAMEBUFFERNOATTACHMENTSSAMPLECOUNTS = layout.offsetof(83);
		MAXCOLORATTACHMENTS = layout.offsetof(84);
		SAMPLEDIMAGECOLORSAMPLECOUNTS = layout.offsetof(85);
		SAMPLEDIMAGEINTEGERSAMPLECOUNTS = layout.offsetof(86);
		SAMPLEDIMAGEDEPTHSAMPLECOUNTS = layout.offsetof(87);
		SAMPLEDIMAGESTENCILSAMPLECOUNTS = layout.offsetof(88);
		STORAGEIMAGESAMPLECOUNTS = layout.offsetof(89);
		MAXSAMPLEMASKWORDS = layout.offsetof(90);
		TIMESTAMPCOMPUTEANDGRAPHICS = layout.offsetof(91);
		TIMESTAMPPERIOD = layout.offsetof(92);
		MAXCLIPDISTANCES = layout.offsetof(93);
		MAXCULLDISTANCES = layout.offsetof(94);
		MAXCOMBINEDCLIPANDCULLDISTANCES = layout.offsetof(95);
		DISCRETEQUEUEPRIORITIES = layout.offsetof(96);
		POINTSIZERANGE = layout.offsetof(97);
		LINEWIDTHRANGE = layout.offsetof(98);
		POINTSIZEGRANULARITY = layout.offsetof(99);
		LINEWIDTHGRANULARITY = layout.offsetof(100);
		STRICTLINES = layout.offsetof(101);
		STANDARDSAMPLELOCATIONS = layout.offsetof(102);
		OPTIMALBUFFERCOPYOFFSETALIGNMENT = layout.offsetof(103);
		OPTIMALBUFFERCOPYROWPITCHALIGNMENT = layout.offsetof(104);
		NONCOHERENTATOMSIZE = layout.offsetof(105);
	}

	VkPhysicalDeviceLimits(long address, ByteBuffer container) {
		super(address, container);
	}

	/**
	 * Creates a {@link VkPhysicalDeviceLimits} instance at the current position of the specified {@link ByteBuffer} container. Changes to the buffer's content will be
	 * visible to the struct instance and vice versa.
	 *
	 * 
The created instance holds a strong reference to the container object.
	 */
	public VkPhysicalDeviceLimits(ByteBuffer container) {
		this(memAddress(container), checkContainer(container, SIZEOF));
	}

	@Override
	public int sizeof() { return SIZEOF; }

	/** Returns the value of the {@code maxImageDimension1D} field. */
	public int maxImageDimension1D() { return nmaxImageDimension1D(address()); }
	/** Returns the value of the {@code maxImageDimension2D} field. */
	public int maxImageDimension2D() { return nmaxImageDimension2D(address()); }
	/** Returns the value of the {@code maxImageDimension3D} field. */
	public int maxImageDimension3D() { return nmaxImageDimension3D(address()); }
	/** Returns the value of the {@code maxImageDimensionCube} field. */
	public int maxImageDimensionCube() { return nmaxImageDimensionCube(address()); }
	/** Returns the value of the {@code maxImageArrayLayers} field. */
	public int maxImageArrayLayers() { return nmaxImageArrayLayers(address()); }
	/** Returns the value of the {@code maxTexelBufferElements} field. */
	public int maxTexelBufferElements() { return nmaxTexelBufferElements(address()); }
	/** Returns the value of the {@code maxUniformBufferRange} field. */
	public int maxUniformBufferRange() { return nmaxUniformBufferRange(address()); }
	/** Returns the value of the {@code maxStorageBufferRange} field. */
	public int maxStorageBufferRange() { return nmaxStorageBufferRange(address()); }
	/** Returns the value of the {@code maxPushConstantsSize} field. */
	public int maxPushConstantsSize() { return nmaxPushConstantsSize(address()); }
	/** Returns the value of the {@code maxMemoryAllocationCount} field. */
	public int maxMemoryAllocationCount() { return nmaxMemoryAllocationCount(address()); }
	/** Returns the value of the {@code maxSamplerAllocationCount} field. */
	public int maxSamplerAllocationCount() { return nmaxSamplerAllocationCount(address()); }
	/** Returns the value of the {@code bufferImageGranularity} field. */
	public long bufferImageGranularity() { return nbufferImageGranularity(address()); }
	/** Returns the value of the {@code sparseAddressSpaceSize} field. */
	public long sparseAddressSpaceSize() { return nsparseAddressSpaceSize(address()); }
	/** Returns the value of the {@code maxBoundDescriptorSets} field. */
	public int maxBoundDescriptorSets() { return nmaxBoundDescriptorSets(address()); }
	/** Returns the value of the {@code maxPerStageDescriptorSamplers} field. */
	public int maxPerStageDescriptorSamplers() { return nmaxPerStageDescriptorSamplers(address()); }
	/** Returns the value of the {@code maxPerStageDescriptorUniformBuffers} field. */
	public int maxPerStageDescriptorUniformBuffers() { return nmaxPerStageDescriptorUniformBuffers(address()); }
	/** Returns the value of the {@code maxPerStageDescriptorStorageBuffers} field. */
	public int maxPerStageDescriptorStorageBuffers() { return nmaxPerStageDescriptorStorageBuffers(address()); }
	/** Returns the value of the {@code maxPerStageDescriptorSampledImages} field. */
	public int maxPerStageDescriptorSampledImages() { return nmaxPerStageDescriptorSampledImages(address()); }
	/** Returns the value of the {@code maxPerStageDescriptorStorageImages} field. */
	public int maxPerStageDescriptorStorageImages() { return nmaxPerStageDescriptorStorageImages(address()); }
	/** Returns the value of the {@code maxPerStageDescriptorInputAttachments} field. */
	public int maxPerStageDescriptorInputAttachments() { return nmaxPerStageDescriptorInputAttachments(address()); }
	/** Returns the value of the {@code maxPerStageResources} field. */
	public int maxPerStageResources() { return nmaxPerStageResources(address()); }
	/** Returns the value of the {@code maxDescriptorSetSamplers} field. */
	public int maxDescriptorSetSamplers() { return nmaxDescriptorSetSamplers(address()); }
	/** Returns the value of the {@code maxDescriptorSetUniformBuffers} field. */
	public int maxDescriptorSetUniformBuffers() { return nmaxDescriptorSetUniformBuffers(address()); }
	/** Returns the value of the {@code maxDescriptorSetUniformBuffersDynamic} field. */
	public int maxDescriptorSetUniformBuffersDynamic() { return nmaxDescriptorSetUniformBuffersDynamic(address()); }
	/** Returns the value of the {@code maxDescriptorSetStorageBuffers} field. */
	public int maxDescriptorSetStorageBuffers() { return nmaxDescriptorSetStorageBuffers(address()); }
	/** Returns the value of the {@code maxDescriptorSetStorageBuffersDynamic} field. */
	public int maxDescriptorSetStorageBuffersDynamic() { return nmaxDescriptorSetStorageBuffersDynamic(address()); }
	/** Returns the value of the {@code maxDescriptorSetSampledImages} field. */
	public int maxDescriptorSetSampledImages() { return nmaxDescriptorSetSampledImages(address()); }
	/** Returns the value of the {@code maxDescriptorSetStorageImages} field. */
	public int maxDescriptorSetStorageImages() { return nmaxDescriptorSetStorageImages(address()); }
	/** Returns the value of the {@code maxDescriptorSetInputAttachments} field. */
	public int maxDescriptorSetInputAttachments() { return nmaxDescriptorSetInputAttachments(address()); }
	/** Returns the value of the {@code maxVertexInputAttributes} field. */
	public int maxVertexInputAttributes() { return nmaxVertexInputAttributes(address()); }
	/** Returns the value of the {@code maxVertexInputBindings} field. */
	public int maxVertexInputBindings() { return nmaxVertexInputBindings(address()); }
	/** Returns the value of the {@code maxVertexInputAttributeOffset} field. */
	public int maxVertexInputAttributeOffset() { return nmaxVertexInputAttributeOffset(address()); }
	/** Returns the value of the {@code maxVertexInputBindingStride} field. */
	public int maxVertexInputBindingStride() { return nmaxVertexInputBindingStride(address()); }
	/** Returns the value of the {@code maxVertexOutputComponents} field. */
	public int maxVertexOutputComponents() { return nmaxVertexOutputComponents(address()); }
	/** Returns the value of the {@code maxTessellationGenerationLevel} field. */
	public int maxTessellationGenerationLevel() { return nmaxTessellationGenerationLevel(address()); }
	/** Returns the value of the {@code maxTessellationPatchSize} field. */
	public int maxTessellationPatchSize() { return nmaxTessellationPatchSize(address()); }
	/** Returns the value of the {@code maxTessellationControlPerVertexInputComponents} field. */
	public int maxTessellationControlPerVertexInputComponents() { return nmaxTessellationControlPerVertexInputComponents(address()); }
	/** Returns the value of the {@code maxTessellationControlPerVertexOutputComponents} field. */
	public int maxTessellationControlPerVertexOutputComponents() { return nmaxTessellationControlPerVertexOutputComponents(address()); }
	/** Returns the value of the {@code maxTessellationControlPerPatchOutputComponents} field. */
	public int maxTessellationControlPerPatchOutputComponents() { return nmaxTessellationControlPerPatchOutputComponents(address()); }
	/** Returns the value of the {@code maxTessellationControlTotalOutputComponents} field. */
	public int maxTessellationControlTotalOutputComponents() { return nmaxTessellationControlTotalOutputComponents(address()); }
	/** Returns the value of the {@code maxTessellationEvaluationInputComponents} field. */
	public int maxTessellationEvaluationInputComponents() { return nmaxTessellationEvaluationInputComponents(address()); }
	/** Returns the value of the {@code maxTessellationEvaluationOutputComponents} field. */
	public int maxTessellationEvaluationOutputComponents() { return nmaxTessellationEvaluationOutputComponents(address()); }
	/** Returns the value of the {@code maxGeometryShaderInvocations} field. */
	public int maxGeometryShaderInvocations() { return nmaxGeometryShaderInvocations(address()); }
	/** Returns the value of the {@code maxGeometryInputComponents} field. */
	public int maxGeometryInputComponents() { return nmaxGeometryInputComponents(address()); }
	/** Returns the value of the {@code maxGeometryOutputComponents} field. */
	public int maxGeometryOutputComponents() { return nmaxGeometryOutputComponents(address()); }
	/** Returns the value of the {@code maxGeometryOutputVertices} field. */
	public int maxGeometryOutputVertices() { return nmaxGeometryOutputVertices(address()); }
	/** Returns the value of the {@code maxGeometryTotalOutputComponents} field. */
	public int maxGeometryTotalOutputComponents() { return nmaxGeometryTotalOutputComponents(address()); }
	/** Returns the value of the {@code maxFragmentInputComponents} field. */
	public int maxFragmentInputComponents() { return nmaxFragmentInputComponents(address()); }
	/** Returns the value of the {@code maxFragmentOutputAttachments} field. */
	public int maxFragmentOutputAttachments() { return nmaxFragmentOutputAttachments(address()); }
	/** Returns the value of the {@code maxFragmentDualSrcAttachments} field. */
	public int maxFragmentDualSrcAttachments() { return nmaxFragmentDualSrcAttachments(address()); }
	/** Returns the value of the {@code maxFragmentCombinedOutputResources} field. */
	public int maxFragmentCombinedOutputResources() { return nmaxFragmentCombinedOutputResources(address()); }
	/** Returns the value of the {@code maxComputeSharedMemorySize} field. */
	public int maxComputeSharedMemorySize() { return nmaxComputeSharedMemorySize(address()); }
	/** Returns a {@link IntBuffer} view of the {@code maxComputeWorkGroupCount} field. */
	public IntBuffer maxComputeWorkGroupCount() { return nmaxComputeWorkGroupCount(address()); }
	/** Returns the value at the specified index of the {@code maxComputeWorkGroupCount} field. */
	public int maxComputeWorkGroupCount(int index) { return nmaxComputeWorkGroupCount(address(), index); }
	/** Returns the value of the {@code maxComputeWorkGroupInvocations} field. */
	public int maxComputeWorkGroupInvocations() { return nmaxComputeWorkGroupInvocations(address()); }
	/** Returns a {@link IntBuffer} view of the {@code maxComputeWorkGroupSize} field. */
	public IntBuffer maxComputeWorkGroupSize() { return nmaxComputeWorkGroupSize(address()); }
	/** Returns the value at the specified index of the {@code maxComputeWorkGroupSize} field. */
	public int maxComputeWorkGroupSize(int index) { return nmaxComputeWorkGroupSize(address(), index); }
	/** Returns the value of the {@code subPixelPrecisionBits} field. */
	public int subPixelPrecisionBits() { return nsubPixelPrecisionBits(address()); }
	/** Returns the value of the {@code subTexelPrecisionBits} field. */
	public int subTexelPrecisionBits() { return nsubTexelPrecisionBits(address()); }
	/** Returns the value of the {@code mipmapPrecisionBits} field. */
	public int mipmapPrecisionBits() { return nmipmapPrecisionBits(address()); }
	/** Returns the value of the {@code maxDrawIndexedIndexValue} field. */
	public int maxDrawIndexedIndexValue() { return nmaxDrawIndexedIndexValue(address()); }
	/** Returns the value of the {@code maxDrawIndirectCount} field. */
	public int maxDrawIndirectCount() { return nmaxDrawIndirectCount(address()); }
	/** Returns the value of the {@code maxSamplerLodBias} field. */
	public float maxSamplerLodBias() { return nmaxSamplerLodBias(address()); }
	/** Returns the value of the {@code maxSamplerAnisotropy} field. */
	public float maxSamplerAnisotropy() { return nmaxSamplerAnisotropy(address()); }
	/** Returns the value of the {@code maxViewports} field. */
	public int maxViewports() { return nmaxViewports(address()); }
	/** Returns a {@link IntBuffer} view of the {@code maxViewportDimensions} field. */
	public IntBuffer maxViewportDimensions() { return nmaxViewportDimensions(address()); }
	/** Returns the value at the specified index of the {@code maxViewportDimensions} field. */
	public int maxViewportDimensions(int index) { return nmaxViewportDimensions(address(), index); }
	/** Returns a {@link FloatBuffer} view of the {@code viewportBoundsRange} field. */
	public FloatBuffer viewportBoundsRange() { return nviewportBoundsRange(address()); }
	/** Returns the value at the specified index of the {@code viewportBoundsRange} field. */
	public float viewportBoundsRange(int index) { return nviewportBoundsRange(address(), index); }
	/** Returns the value of the {@code viewportSubPixelBits} field. */
	public int viewportSubPixelBits() { return nviewportSubPixelBits(address()); }
	/** Returns the value of the {@code minMemoryMapAlignment} field. */
	public long minMemoryMapAlignment() { return nminMemoryMapAlignment(address()); }
	/** Returns the value of the {@code minTexelBufferOffsetAlignment} field. */
	public long minTexelBufferOffsetAlignment() { return nminTexelBufferOffsetAlignment(address()); }
	/** Returns the value of the {@code minUniformBufferOffsetAlignment} field. */
	public long minUniformBufferOffsetAlignment() { return nminUniformBufferOffsetAlignment(address()); }
	/** Returns the value of the {@code minStorageBufferOffsetAlignment} field. */
	public long minStorageBufferOffsetAlignment() { return nminStorageBufferOffsetAlignment(address()); }
	/** Returns the value of the {@code minTexelOffset} field. */
	public int minTexelOffset() { return nminTexelOffset(address()); }
	/** Returns the value of the {@code maxTexelOffset} field. */
	public int maxTexelOffset() { return nmaxTexelOffset(address()); }
	/** Returns the value of the {@code minTexelGatherOffset} field. */
	public int minTexelGatherOffset() { return nminTexelGatherOffset(address()); }
	/** Returns the value of the {@code maxTexelGatherOffset} field. */
	public int maxTexelGatherOffset() { return nmaxTexelGatherOffset(address()); }
	/** Returns the value of the {@code minInterpolationOffset} field. */
	public float minInterpolationOffset() { return nminInterpolationOffset(address()); }
	/** Returns the value of the {@code maxInterpolationOffset} field. */
	public float maxInterpolationOffset() { return nmaxInterpolationOffset(address()); }
	/** Returns the value of the {@code subPixelInterpolationOffsetBits} field. */
	public int subPixelInterpolationOffsetBits() { return nsubPixelInterpolationOffsetBits(address()); }
	/** Returns the value of the {@code maxFramebufferWidth} field. */
	public int maxFramebufferWidth() { return nmaxFramebufferWidth(address()); }
	/** Returns the value of the {@code maxFramebufferHeight} field. */
	public int maxFramebufferHeight() { return nmaxFramebufferHeight(address()); }
	/** Returns the value of the {@code maxFramebufferLayers} field. */
	public int maxFramebufferLayers() { return nmaxFramebufferLayers(address()); }
	/** Returns the value of the {@code framebufferColorSampleCounts} field. */
	public int framebufferColorSampleCounts() { return nframebufferColorSampleCounts(address()); }
	/** Returns the value of the {@code framebufferDepthSampleCounts} field. */
	public int framebufferDepthSampleCounts() { return nframebufferDepthSampleCounts(address()); }
	/** Returns the value of the {@code framebufferStencilSampleCounts} field. */
	public int framebufferStencilSampleCounts() { return nframebufferStencilSampleCounts(address()); }
	/** Returns the value of the {@code framebufferNoAttachmentsSampleCounts} field. */
	public int framebufferNoAttachmentsSampleCounts() { return nframebufferNoAttachmentsSampleCounts(address()); }
	/** Returns the value of the {@code maxColorAttachments} field. */
	public int maxColorAttachments() { return nmaxColorAttachments(address()); }
	/** Returns the value of the {@code sampledImageColorSampleCounts} field. */
	public int sampledImageColorSampleCounts() { return nsampledImageColorSampleCounts(address()); }
	/** Returns the value of the {@code sampledImageIntegerSampleCounts} field. */
	public int sampledImageIntegerSampleCounts() { return nsampledImageIntegerSampleCounts(address()); }
	/** Returns the value of the {@code sampledImageDepthSampleCounts} field. */
	public int sampledImageDepthSampleCounts() { return nsampledImageDepthSampleCounts(address()); }
	/** Returns the value of the {@code sampledImageStencilSampleCounts} field. */
	public int sampledImageStencilSampleCounts() { return nsampledImageStencilSampleCounts(address()); }
	/** Returns the value of the {@code storageImageSampleCounts} field. */
	public int storageImageSampleCounts() { return nstorageImageSampleCounts(address()); }
	/** Returns the value of the {@code maxSampleMaskWords} field. */
	public int maxSampleMaskWords() { return nmaxSampleMaskWords(address()); }
	/** Returns the value of the {@code timestampComputeAndGraphics} field. */
	public boolean timestampComputeAndGraphics() { return ntimestampComputeAndGraphics(address()) != 0; }
	/** Returns the value of the {@code timestampPeriod} field. */
	public float timestampPeriod() { return ntimestampPeriod(address()); }
	/** Returns the value of the {@code maxClipDistances} field. */
	public int maxClipDistances() { return nmaxClipDistances(address()); }
	/** Returns the value of the {@code maxCullDistances} field. */
	public int maxCullDistances() { return nmaxCullDistances(address()); }
	/** Returns the value of the {@code maxCombinedClipAndCullDistances} field. */
	public int maxCombinedClipAndCullDistances() { return nmaxCombinedClipAndCullDistances(address()); }
	/** Returns the value of the {@code discreteQueuePriorities} field. */
	public int discreteQueuePriorities() { return ndiscreteQueuePriorities(address()); }
	/** Returns a {@link FloatBuffer} view of the {@code pointSizeRange} field. */
	public FloatBuffer pointSizeRange() { return npointSizeRange(address()); }
	/** Returns the value at the specified index of the {@code pointSizeRange} field. */
	public float pointSizeRange(int index) { return npointSizeRange(address(), index); }
	/** Returns a {@link FloatBuffer} view of the {@code lineWidthRange} field. */
	public FloatBuffer lineWidthRange() { return nlineWidthRange(address()); }
	/** Returns the value at the specified index of the {@code lineWidthRange} field. */
	public float lineWidthRange(int index) { return nlineWidthRange(address(), index); }
	/** Returns the value of the {@code pointSizeGranularity} field. */
	public float pointSizeGranularity() { return npointSizeGranularity(address()); }
	/** Returns the value of the {@code lineWidthGranularity} field. */
	public float lineWidthGranularity() { return nlineWidthGranularity(address()); }
	/** Returns the value of the {@code strictLines} field. */
	public boolean strictLines() { return nstrictLines(address()) != 0; }
	/** Returns the value of the {@code standardSampleLocations} field. */
	public boolean standardSampleLocations() { return nstandardSampleLocations(address()) != 0; }
	/** Returns the value of the {@code optimalBufferCopyOffsetAlignment} field. */
	public long optimalBufferCopyOffsetAlignment() { return noptimalBufferCopyOffsetAlignment(address()); }
	/** Returns the value of the {@code optimalBufferCopyRowPitchAlignment} field. */
	public long optimalBufferCopyRowPitchAlignment() { return noptimalBufferCopyRowPitchAlignment(address()); }
	/** Returns the value of the {@code nonCoherentAtomSize} field. */
	public long nonCoherentAtomSize() { return nnonCoherentAtomSize(address()); }

	// -----------------------------------

	/** Returns a new {@link VkPhysicalDeviceLimits} instance for the specified memory address or {@code null} if the address is {@code NULL}. */
	public static VkPhysicalDeviceLimits create(long address) {
		return address == NULL ? null : new VkPhysicalDeviceLimits(address, null);
	}

	/**
	 * Create a {@link VkPhysicalDeviceLimits.Buffer} instance at the specified memory.
	 *
	 * @param address  the memory address
	 * @param capacity the buffer capacity
	 */
	public static Buffer create(long address, int capacity) {
		return address == NULL ? null : new Buffer(address, null, -1, 0, capacity, capacity);
	}

	// -----------------------------------

	/** Unsafe version of {@link #maxImageDimension1D}. */
	public static int nmaxImageDimension1D(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXIMAGEDIMENSION1D); }
	/** Unsafe version of {@link #maxImageDimension2D}. */
	public static int nmaxImageDimension2D(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXIMAGEDIMENSION2D); }
	/** Unsafe version of {@link #maxImageDimension3D}. */
	public static int nmaxImageDimension3D(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXIMAGEDIMENSION3D); }
	/** Unsafe version of {@link #maxImageDimensionCube}. */
	public static int nmaxImageDimensionCube(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXIMAGEDIMENSIONCUBE); }
	/** Unsafe version of {@link #maxImageArrayLayers}. */
	public static int nmaxImageArrayLayers(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXIMAGEARRAYLAYERS); }
	/** Unsafe version of {@link #maxTexelBufferElements}. */
	public static int nmaxTexelBufferElements(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTEXELBUFFERELEMENTS); }
	/** Unsafe version of {@link #maxUniformBufferRange}. */
	public static int nmaxUniformBufferRange(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXUNIFORMBUFFERRANGE); }
	/** Unsafe version of {@link #maxStorageBufferRange}. */
	public static int nmaxStorageBufferRange(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXSTORAGEBUFFERRANGE); }
	/** Unsafe version of {@link #maxPushConstantsSize}. */
	public static int nmaxPushConstantsSize(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXPUSHCONSTANTSSIZE); }
	/** Unsafe version of {@link #maxMemoryAllocationCount}. */
	public static int nmaxMemoryAllocationCount(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXMEMORYALLOCATIONCOUNT); }
	/** Unsafe version of {@link #maxSamplerAllocationCount}. */
	public static int nmaxSamplerAllocationCount(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXSAMPLERALLOCATIONCOUNT); }
	/** Unsafe version of {@link #bufferImageGranularity}. */
	public static long nbufferImageGranularity(long struct) { return memGetLong(struct + VkPhysicalDeviceLimits.BUFFERIMAGEGRANULARITY); }
	/** Unsafe version of {@link #sparseAddressSpaceSize}. */
	public static long nsparseAddressSpaceSize(long struct) { return memGetLong(struct + VkPhysicalDeviceLimits.SPARSEADDRESSSPACESIZE); }
	/** Unsafe version of {@link #maxBoundDescriptorSets}. */
	public static int nmaxBoundDescriptorSets(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXBOUNDDESCRIPTORSETS); }
	/** Unsafe version of {@link #maxPerStageDescriptorSamplers}. */
	public static int nmaxPerStageDescriptorSamplers(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXPERSTAGEDESCRIPTORSAMPLERS); }
	/** Unsafe version of {@link #maxPerStageDescriptorUniformBuffers}. */
	public static int nmaxPerStageDescriptorUniformBuffers(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXPERSTAGEDESCRIPTORUNIFORMBUFFERS); }
	/** Unsafe version of {@link #maxPerStageDescriptorStorageBuffers}. */
	public static int nmaxPerStageDescriptorStorageBuffers(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXPERSTAGEDESCRIPTORSTORAGEBUFFERS); }
	/** Unsafe version of {@link #maxPerStageDescriptorSampledImages}. */
	public static int nmaxPerStageDescriptorSampledImages(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXPERSTAGEDESCRIPTORSAMPLEDIMAGES); }
	/** Unsafe version of {@link #maxPerStageDescriptorStorageImages}. */
	public static int nmaxPerStageDescriptorStorageImages(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXPERSTAGEDESCRIPTORSTORAGEIMAGES); }
	/** Unsafe version of {@link #maxPerStageDescriptorInputAttachments}. */
	public static int nmaxPerStageDescriptorInputAttachments(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXPERSTAGEDESCRIPTORINPUTATTACHMENTS); }
	/** Unsafe version of {@link #maxPerStageResources}. */
	public static int nmaxPerStageResources(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXPERSTAGERESOURCES); }
	/** Unsafe version of {@link #maxDescriptorSetSamplers}. */
	public static int nmaxDescriptorSetSamplers(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDESCRIPTORSETSAMPLERS); }
	/** Unsafe version of {@link #maxDescriptorSetUniformBuffers}. */
	public static int nmaxDescriptorSetUniformBuffers(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDESCRIPTORSETUNIFORMBUFFERS); }
	/** Unsafe version of {@link #maxDescriptorSetUniformBuffersDynamic}. */
	public static int nmaxDescriptorSetUniformBuffersDynamic(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDESCRIPTORSETUNIFORMBUFFERSDYNAMIC); }
	/** Unsafe version of {@link #maxDescriptorSetStorageBuffers}. */
	public static int nmaxDescriptorSetStorageBuffers(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDESCRIPTORSETSTORAGEBUFFERS); }
	/** Unsafe version of {@link #maxDescriptorSetStorageBuffersDynamic}. */
	public static int nmaxDescriptorSetStorageBuffersDynamic(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDESCRIPTORSETSTORAGEBUFFERSDYNAMIC); }
	/** Unsafe version of {@link #maxDescriptorSetSampledImages}. */
	public static int nmaxDescriptorSetSampledImages(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDESCRIPTORSETSAMPLEDIMAGES); }
	/** Unsafe version of {@link #maxDescriptorSetStorageImages}. */
	public static int nmaxDescriptorSetStorageImages(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDESCRIPTORSETSTORAGEIMAGES); }
	/** Unsafe version of {@link #maxDescriptorSetInputAttachments}. */
	public static int nmaxDescriptorSetInputAttachments(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDESCRIPTORSETINPUTATTACHMENTS); }
	/** Unsafe version of {@link #maxVertexInputAttributes}. */
	public static int nmaxVertexInputAttributes(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXVERTEXINPUTATTRIBUTES); }
	/** Unsafe version of {@link #maxVertexInputBindings}. */
	public static int nmaxVertexInputBindings(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXVERTEXINPUTBINDINGS); }
	/** Unsafe version of {@link #maxVertexInputAttributeOffset}. */
	public static int nmaxVertexInputAttributeOffset(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXVERTEXINPUTATTRIBUTEOFFSET); }
	/** Unsafe version of {@link #maxVertexInputBindingStride}. */
	public static int nmaxVertexInputBindingStride(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXVERTEXINPUTBINDINGSTRIDE); }
	/** Unsafe version of {@link #maxVertexOutputComponents}. */
	public static int nmaxVertexOutputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXVERTEXOUTPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxTessellationGenerationLevel}. */
	public static int nmaxTessellationGenerationLevel(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTESSELLATIONGENERATIONLEVEL); }
	/** Unsafe version of {@link #maxTessellationPatchSize}. */
	public static int nmaxTessellationPatchSize(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTESSELLATIONPATCHSIZE); }
	/** Unsafe version of {@link #maxTessellationControlPerVertexInputComponents}. */
	public static int nmaxTessellationControlPerVertexInputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTESSELLATIONCONTROLPERVERTEXINPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxTessellationControlPerVertexOutputComponents}. */
	public static int nmaxTessellationControlPerVertexOutputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTESSELLATIONCONTROLPERVERTEXOUTPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxTessellationControlPerPatchOutputComponents}. */
	public static int nmaxTessellationControlPerPatchOutputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTESSELLATIONCONTROLPERPATCHOUTPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxTessellationControlTotalOutputComponents}. */
	public static int nmaxTessellationControlTotalOutputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTESSELLATIONCONTROLTOTALOUTPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxTessellationEvaluationInputComponents}. */
	public static int nmaxTessellationEvaluationInputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTESSELLATIONEVALUATIONINPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxTessellationEvaluationOutputComponents}. */
	public static int nmaxTessellationEvaluationOutputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTESSELLATIONEVALUATIONOUTPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxGeometryShaderInvocations}. */
	public static int nmaxGeometryShaderInvocations(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXGEOMETRYSHADERINVOCATIONS); }
	/** Unsafe version of {@link #maxGeometryInputComponents}. */
	public static int nmaxGeometryInputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXGEOMETRYINPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxGeometryOutputComponents}. */
	public static int nmaxGeometryOutputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXGEOMETRYOUTPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxGeometryOutputVertices}. */
	public static int nmaxGeometryOutputVertices(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXGEOMETRYOUTPUTVERTICES); }
	/** Unsafe version of {@link #maxGeometryTotalOutputComponents}. */
	public static int nmaxGeometryTotalOutputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXGEOMETRYTOTALOUTPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxFragmentInputComponents}. */
	public static int nmaxFragmentInputComponents(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXFRAGMENTINPUTCOMPONENTS); }
	/** Unsafe version of {@link #maxFragmentOutputAttachments}. */
	public static int nmaxFragmentOutputAttachments(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXFRAGMENTOUTPUTATTACHMENTS); }
	/** Unsafe version of {@link #maxFragmentDualSrcAttachments}. */
	public static int nmaxFragmentDualSrcAttachments(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXFRAGMENTDUALSRCATTACHMENTS); }
	/** Unsafe version of {@link #maxFragmentCombinedOutputResources}. */
	public static int nmaxFragmentCombinedOutputResources(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXFRAGMENTCOMBINEDOUTPUTRESOURCES); }
	/** Unsafe version of {@link #maxComputeSharedMemorySize}. */
	public static int nmaxComputeSharedMemorySize(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXCOMPUTESHAREDMEMORYSIZE); }
	/** Unsafe version of {@link #maxComputeWorkGroupCount}. */
	public static IntBuffer nmaxComputeWorkGroupCount(long struct) { return memIntBuffer(struct + VkPhysicalDeviceLimits.MAXCOMPUTEWORKGROUPCOUNT, 3); }
	/** Unsafe version of {@link #maxComputeWorkGroupCount(int) maxComputeWorkGroupCount}. */
	public static int nmaxComputeWorkGroupCount(long struct, int index) {
		if ( CHECKS ) check(index, 3);
		return memGetInt(struct + VkPhysicalDeviceLimits.MAXCOMPUTEWORKGROUPCOUNT + index * 4);
	}
	/** Unsafe version of {@link #maxComputeWorkGroupInvocations}. */
	public static int nmaxComputeWorkGroupInvocations(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXCOMPUTEWORKGROUPINVOCATIONS); }
	/** Unsafe version of {@link #maxComputeWorkGroupSize}. */
	public static IntBuffer nmaxComputeWorkGroupSize(long struct) { return memIntBuffer(struct + VkPhysicalDeviceLimits.MAXCOMPUTEWORKGROUPSIZE, 3); }
	/** Unsafe version of {@link #maxComputeWorkGroupSize(int) maxComputeWorkGroupSize}. */
	public static int nmaxComputeWorkGroupSize(long struct, int index) {
		if ( CHECKS ) check(index, 3);
		return memGetInt(struct + VkPhysicalDeviceLimits.MAXCOMPUTEWORKGROUPSIZE + index * 4);
	}
	/** Unsafe version of {@link #subPixelPrecisionBits}. */
	public static int nsubPixelPrecisionBits(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.SUBPIXELPRECISIONBITS); }
	/** Unsafe version of {@link #subTexelPrecisionBits}. */
	public static int nsubTexelPrecisionBits(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.SUBTEXELPRECISIONBITS); }
	/** Unsafe version of {@link #mipmapPrecisionBits}. */
	public static int nmipmapPrecisionBits(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MIPMAPPRECISIONBITS); }
	/** Unsafe version of {@link #maxDrawIndexedIndexValue}. */
	public static int nmaxDrawIndexedIndexValue(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDRAWINDEXEDINDEXVALUE); }
	/** Unsafe version of {@link #maxDrawIndirectCount}. */
	public static int nmaxDrawIndirectCount(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXDRAWINDIRECTCOUNT); }
	/** Unsafe version of {@link #maxSamplerLodBias}. */
	public static float nmaxSamplerLodBias(long struct) { return memGetFloat(struct + VkPhysicalDeviceLimits.MAXSAMPLERLODBIAS); }
	/** Unsafe version of {@link #maxSamplerAnisotropy}. */
	public static float nmaxSamplerAnisotropy(long struct) { return memGetFloat(struct + VkPhysicalDeviceLimits.MAXSAMPLERANISOTROPY); }
	/** Unsafe version of {@link #maxViewports}. */
	public static int nmaxViewports(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXVIEWPORTS); }
	/** Unsafe version of {@link #maxViewportDimensions}. */
	public static IntBuffer nmaxViewportDimensions(long struct) { return memIntBuffer(struct + VkPhysicalDeviceLimits.MAXVIEWPORTDIMENSIONS, 2); }
	/** Unsafe version of {@link #maxViewportDimensions(int) maxViewportDimensions}. */
	public static int nmaxViewportDimensions(long struct, int index) {
		if ( CHECKS ) check(index, 2);
		return memGetInt(struct + VkPhysicalDeviceLimits.MAXVIEWPORTDIMENSIONS + index * 4);
	}
	/** Unsafe version of {@link #viewportBoundsRange}. */
	public static FloatBuffer nviewportBoundsRange(long struct) { return memFloatBuffer(struct + VkPhysicalDeviceLimits.VIEWPORTBOUNDSRANGE, 2); }
	/** Unsafe version of {@link #viewportBoundsRange(int) viewportBoundsRange}. */
	public static float nviewportBoundsRange(long struct, int index) {
		if ( CHECKS ) check(index, 2);
		return memGetFloat(struct + VkPhysicalDeviceLimits.VIEWPORTBOUNDSRANGE + index * 4);
	}
	/** Unsafe version of {@link #viewportSubPixelBits}. */
	public static int nviewportSubPixelBits(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.VIEWPORTSUBPIXELBITS); }
	/** Unsafe version of {@link #minMemoryMapAlignment}. */
	public static long nminMemoryMapAlignment(long struct) { return memGetAddress(struct + VkPhysicalDeviceLimits.MINMEMORYMAPALIGNMENT); }
	/** Unsafe version of {@link #minTexelBufferOffsetAlignment}. */
	public static long nminTexelBufferOffsetAlignment(long struct) { return memGetLong(struct + VkPhysicalDeviceLimits.MINTEXELBUFFEROFFSETALIGNMENT); }
	/** Unsafe version of {@link #minUniformBufferOffsetAlignment}. */
	public static long nminUniformBufferOffsetAlignment(long struct) { return memGetLong(struct + VkPhysicalDeviceLimits.MINUNIFORMBUFFEROFFSETALIGNMENT); }
	/** Unsafe version of {@link #minStorageBufferOffsetAlignment}. */
	public static long nminStorageBufferOffsetAlignment(long struct) { return memGetLong(struct + VkPhysicalDeviceLimits.MINSTORAGEBUFFEROFFSETALIGNMENT); }
	/** Unsafe version of {@link #minTexelOffset}. */
	public static int nminTexelOffset(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MINTEXELOFFSET); }
	/** Unsafe version of {@link #maxTexelOffset}. */
	public static int nmaxTexelOffset(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTEXELOFFSET); }
	/** Unsafe version of {@link #minTexelGatherOffset}. */
	public static int nminTexelGatherOffset(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MINTEXELGATHEROFFSET); }
	/** Unsafe version of {@link #maxTexelGatherOffset}. */
	public static int nmaxTexelGatherOffset(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXTEXELGATHEROFFSET); }
	/** Unsafe version of {@link #minInterpolationOffset}. */
	public static float nminInterpolationOffset(long struct) { return memGetFloat(struct + VkPhysicalDeviceLimits.MININTERPOLATIONOFFSET); }
	/** Unsafe version of {@link #maxInterpolationOffset}. */
	public static float nmaxInterpolationOffset(long struct) { return memGetFloat(struct + VkPhysicalDeviceLimits.MAXINTERPOLATIONOFFSET); }
	/** Unsafe version of {@link #subPixelInterpolationOffsetBits}. */
	public static int nsubPixelInterpolationOffsetBits(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.SUBPIXELINTERPOLATIONOFFSETBITS); }
	/** Unsafe version of {@link #maxFramebufferWidth}. */
	public static int nmaxFramebufferWidth(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXFRAMEBUFFERWIDTH); }
	/** Unsafe version of {@link #maxFramebufferHeight}. */
	public static int nmaxFramebufferHeight(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXFRAMEBUFFERHEIGHT); }
	/** Unsafe version of {@link #maxFramebufferLayers}. */
	public static int nmaxFramebufferLayers(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXFRAMEBUFFERLAYERS); }
	/** Unsafe version of {@link #framebufferColorSampleCounts}. */
	public static int nframebufferColorSampleCounts(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.FRAMEBUFFERCOLORSAMPLECOUNTS); }
	/** Unsafe version of {@link #framebufferDepthSampleCounts}. */
	public static int nframebufferDepthSampleCounts(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.FRAMEBUFFERDEPTHSAMPLECOUNTS); }
	/** Unsafe version of {@link #framebufferStencilSampleCounts}. */
	public static int nframebufferStencilSampleCounts(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.FRAMEBUFFERSTENCILSAMPLECOUNTS); }
	/** Unsafe version of {@link #framebufferNoAttachmentsSampleCounts}. */
	public static int nframebufferNoAttachmentsSampleCounts(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.FRAMEBUFFERNOATTACHMENTSSAMPLECOUNTS); }
	/** Unsafe version of {@link #maxColorAttachments}. */
	public static int nmaxColorAttachments(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXCOLORATTACHMENTS); }
	/** Unsafe version of {@link #sampledImageColorSampleCounts}. */
	public static int nsampledImageColorSampleCounts(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.SAMPLEDIMAGECOLORSAMPLECOUNTS); }
	/** Unsafe version of {@link #sampledImageIntegerSampleCounts}. */
	public static int nsampledImageIntegerSampleCounts(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.SAMPLEDIMAGEINTEGERSAMPLECOUNTS); }
	/** Unsafe version of {@link #sampledImageDepthSampleCounts}. */
	public static int nsampledImageDepthSampleCounts(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.SAMPLEDIMAGEDEPTHSAMPLECOUNTS); }
	/** Unsafe version of {@link #sampledImageStencilSampleCounts}. */
	public static int nsampledImageStencilSampleCounts(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.SAMPLEDIMAGESTENCILSAMPLECOUNTS); }
	/** Unsafe version of {@link #storageImageSampleCounts}. */
	public static int nstorageImageSampleCounts(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.STORAGEIMAGESAMPLECOUNTS); }
	/** Unsafe version of {@link #maxSampleMaskWords}. */
	public static int nmaxSampleMaskWords(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXSAMPLEMASKWORDS); }
	/** Unsafe version of {@link #timestampComputeAndGraphics}. */
	public static int ntimestampComputeAndGraphics(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.TIMESTAMPCOMPUTEANDGRAPHICS); }
	/** Unsafe version of {@link #timestampPeriod}. */
	public static float ntimestampPeriod(long struct) { return memGetFloat(struct + VkPhysicalDeviceLimits.TIMESTAMPPERIOD); }
	/** Unsafe version of {@link #maxClipDistances}. */
	public static int nmaxClipDistances(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXCLIPDISTANCES); }
	/** Unsafe version of {@link #maxCullDistances}. */
	public static int nmaxCullDistances(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXCULLDISTANCES); }
	/** Unsafe version of {@link #maxCombinedClipAndCullDistances}. */
	public static int nmaxCombinedClipAndCullDistances(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.MAXCOMBINEDCLIPANDCULLDISTANCES); }
	/** Unsafe version of {@link #discreteQueuePriorities}. */
	public static int ndiscreteQueuePriorities(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.DISCRETEQUEUEPRIORITIES); }
	/** Unsafe version of {@link #pointSizeRange}. */
	public static FloatBuffer npointSizeRange(long struct) { return memFloatBuffer(struct + VkPhysicalDeviceLimits.POINTSIZERANGE, 2); }
	/** Unsafe version of {@link #pointSizeRange(int) pointSizeRange}. */
	public static float npointSizeRange(long struct, int index) {
		if ( CHECKS ) check(index, 2);
		return memGetFloat(struct + VkPhysicalDeviceLimits.POINTSIZERANGE + index * 4);
	}
	/** Unsafe version of {@link #lineWidthRange}. */
	public static FloatBuffer nlineWidthRange(long struct) { return memFloatBuffer(struct + VkPhysicalDeviceLimits.LINEWIDTHRANGE, 2); }
	/** Unsafe version of {@link #lineWidthRange(int) lineWidthRange}. */
	public static float nlineWidthRange(long struct, int index) {
		if ( CHECKS ) check(index, 2);
		return memGetFloat(struct + VkPhysicalDeviceLimits.LINEWIDTHRANGE + index * 4);
	}
	/** Unsafe version of {@link #pointSizeGranularity}. */
	public static float npointSizeGranularity(long struct) { return memGetFloat(struct + VkPhysicalDeviceLimits.POINTSIZEGRANULARITY); }
	/** Unsafe version of {@link #lineWidthGranularity}. */
	public static float nlineWidthGranularity(long struct) { return memGetFloat(struct + VkPhysicalDeviceLimits.LINEWIDTHGRANULARITY); }
	/** Unsafe version of {@link #strictLines}. */
	public static int nstrictLines(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.STRICTLINES); }
	/** Unsafe version of {@link #standardSampleLocations}. */
	public static int nstandardSampleLocations(long struct) { return memGetInt(struct + VkPhysicalDeviceLimits.STANDARDSAMPLELOCATIONS); }
	/** Unsafe version of {@link #optimalBufferCopyOffsetAlignment}. */
	public static long noptimalBufferCopyOffsetAlignment(long struct) { return memGetLong(struct + VkPhysicalDeviceLimits.OPTIMALBUFFERCOPYOFFSETALIGNMENT); }
	/** Unsafe version of {@link #optimalBufferCopyRowPitchAlignment}. */
	public static long noptimalBufferCopyRowPitchAlignment(long struct) { return memGetLong(struct + VkPhysicalDeviceLimits.OPTIMALBUFFERCOPYROWPITCHALIGNMENT); }
	/** Unsafe version of {@link #nonCoherentAtomSize}. */
	public static long nnonCoherentAtomSize(long struct) { return memGetLong(struct + VkPhysicalDeviceLimits.NONCOHERENTATOMSIZE); }

	// -----------------------------------

	/** An array of {@link VkPhysicalDeviceLimits} structs. */
	public static class Buffer extends StructBuffer {

		/**
		 * Creates a new {@link VkPhysicalDeviceLimits.Buffer} instance backed by the specified container.
		 *
		 * Changes to the container's content will be visible to the struct buffer instance and vice versa. The two buffers' position, limit, and mark values
		 * will be independent. The new buffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this buffer divided
		 * by {@link VkPhysicalDeviceLimits#SIZEOF}, and its mark will be undefined.
		 *
		 * 
The created buffer instance holds a strong reference to the container object.
		 */
		public Buffer(ByteBuffer container) {
			super(container, container.remaining() / SIZEOF);
		}

		Buffer(long address, ByteBuffer container, int mark, int pos, int lim, int cap) {
			super(address, container, mark, pos, lim, cap);
		}

		@Override
		protected Buffer self() {
			return this;
		}

		@Override
		protected Buffer newBufferInstance(long address, ByteBuffer container, int mark, int pos, int lim, int cap) {
			return new Buffer(address, container, mark, pos, lim, cap);
		}

		@Override
		protected VkPhysicalDeviceLimits newInstance(long address) {
			return new VkPhysicalDeviceLimits(address, container);
		}

		@Override
		protected int sizeof() {
			return SIZEOF;
		}

		/** Returns the value of the {@code maxImageDimension1D} field. */
		public int maxImageDimension1D() { return VkPhysicalDeviceLimits.nmaxImageDimension1D(address()); }
		/** Returns the value of the {@code maxImageDimension2D} field. */
		public int maxImageDimension2D() { return VkPhysicalDeviceLimits.nmaxImageDimension2D(address()); }
		/** Returns the value of the {@code maxImageDimension3D} field. */
		public int maxImageDimension3D() { return VkPhysicalDeviceLimits.nmaxImageDimension3D(address()); }
		/** Returns the value of the {@code maxImageDimensionCube} field. */
		public int maxImageDimensionCube() { return VkPhysicalDeviceLimits.nmaxImageDimensionCube(address()); }
		/** Returns the value of the {@code maxImageArrayLayers} field. */
		public int maxImageArrayLayers() { return VkPhysicalDeviceLimits.nmaxImageArrayLayers(address()); }
		/** Returns the value of the {@code maxTexelBufferElements} field. */
		public int maxTexelBufferElements() { return VkPhysicalDeviceLimits.nmaxTexelBufferElements(address()); }
		/** Returns the value of the {@code maxUniformBufferRange} field. */
		public int maxUniformBufferRange() { return VkPhysicalDeviceLimits.nmaxUniformBufferRange(address()); }
		/** Returns the value of the {@code maxStorageBufferRange} field. */
		public int maxStorageBufferRange() { return VkPhysicalDeviceLimits.nmaxStorageBufferRange(address()); }
		/** Returns the value of the {@code maxPushConstantsSize} field. */
		public int maxPushConstantsSize() { return VkPhysicalDeviceLimits.nmaxPushConstantsSize(address()); }
		/** Returns the value of the {@code maxMemoryAllocationCount} field. */
		public int maxMemoryAllocationCount() { return VkPhysicalDeviceLimits.nmaxMemoryAllocationCount(address()); }
		/** Returns the value of the {@code maxSamplerAllocationCount} field. */
		public int maxSamplerAllocationCount() { return VkPhysicalDeviceLimits.nmaxSamplerAllocationCount(address()); }
		/** Returns the value of the {@code bufferImageGranularity} field. */
		public long bufferImageGranularity() { return VkPhysicalDeviceLimits.nbufferImageGranularity(address()); }
		/** Returns the value of the {@code sparseAddressSpaceSize} field. */
		public long sparseAddressSpaceSize() { return VkPhysicalDeviceLimits.nsparseAddressSpaceSize(address()); }
		/** Returns the value of the {@code maxBoundDescriptorSets} field. */
		public int maxBoundDescriptorSets() { return VkPhysicalDeviceLimits.nmaxBoundDescriptorSets(address()); }
		/** Returns the value of the {@code maxPerStageDescriptorSamplers} field. */
		public int maxPerStageDescriptorSamplers() { return VkPhysicalDeviceLimits.nmaxPerStageDescriptorSamplers(address()); }
		/** Returns the value of the {@code maxPerStageDescriptorUniformBuffers} field. */
		public int maxPerStageDescriptorUniformBuffers() { return VkPhysicalDeviceLimits.nmaxPerStageDescriptorUniformBuffers(address()); }
		/** Returns the value of the {@code maxPerStageDescriptorStorageBuffers} field. */
		public int maxPerStageDescriptorStorageBuffers() { return VkPhysicalDeviceLimits.nmaxPerStageDescriptorStorageBuffers(address()); }
		/** Returns the value of the {@code maxPerStageDescriptorSampledImages} field. */
		public int maxPerStageDescriptorSampledImages() { return VkPhysicalDeviceLimits.nmaxPerStageDescriptorSampledImages(address()); }
		/** Returns the value of the {@code maxPerStageDescriptorStorageImages} field. */
		public int maxPerStageDescriptorStorageImages() { return VkPhysicalDeviceLimits.nmaxPerStageDescriptorStorageImages(address()); }
		/** Returns the value of the {@code maxPerStageDescriptorInputAttachments} field. */
		public int maxPerStageDescriptorInputAttachments() { return VkPhysicalDeviceLimits.nmaxPerStageDescriptorInputAttachments(address()); }
		/** Returns the value of the {@code maxPerStageResources} field. */
		public int maxPerStageResources() { return VkPhysicalDeviceLimits.nmaxPerStageResources(address()); }
		/** Returns the value of the {@code maxDescriptorSetSamplers} field. */
		public int maxDescriptorSetSamplers() { return VkPhysicalDeviceLimits.nmaxDescriptorSetSamplers(address()); }
		/** Returns the value of the {@code maxDescriptorSetUniformBuffers} field. */
		public int maxDescriptorSetUniformBuffers() { return VkPhysicalDeviceLimits.nmaxDescriptorSetUniformBuffers(address()); }
		/** Returns the value of the {@code maxDescriptorSetUniformBuffersDynamic} field. */
		public int maxDescriptorSetUniformBuffersDynamic() { return VkPhysicalDeviceLimits.nmaxDescriptorSetUniformBuffersDynamic(address()); }
		/** Returns the value of the {@code maxDescriptorSetStorageBuffers} field. */
		public int maxDescriptorSetStorageBuffers() { return VkPhysicalDeviceLimits.nmaxDescriptorSetStorageBuffers(address()); }
		/** Returns the value of the {@code maxDescriptorSetStorageBuffersDynamic} field. */
		public int maxDescriptorSetStorageBuffersDynamic() { return VkPhysicalDeviceLimits.nmaxDescriptorSetStorageBuffersDynamic(address()); }
		/** Returns the value of the {@code maxDescriptorSetSampledImages} field. */
		public int maxDescriptorSetSampledImages() { return VkPhysicalDeviceLimits.nmaxDescriptorSetSampledImages(address()); }
		/** Returns the value of the {@code maxDescriptorSetStorageImages} field. */
		public int maxDescriptorSetStorageImages() { return VkPhysicalDeviceLimits.nmaxDescriptorSetStorageImages(address()); }
		/** Returns the value of the {@code maxDescriptorSetInputAttachments} field. */
		public int maxDescriptorSetInputAttachments() { return VkPhysicalDeviceLimits.nmaxDescriptorSetInputAttachments(address()); }
		/** Returns the value of the {@code maxVertexInputAttributes} field. */
		public int maxVertexInputAttributes() { return VkPhysicalDeviceLimits.nmaxVertexInputAttributes(address()); }
		/** Returns the value of the {@code maxVertexInputBindings} field. */
		public int maxVertexInputBindings() { return VkPhysicalDeviceLimits.nmaxVertexInputBindings(address()); }
		/** Returns the value of the {@code maxVertexInputAttributeOffset} field. */
		public int maxVertexInputAttributeOffset() { return VkPhysicalDeviceLimits.nmaxVertexInputAttributeOffset(address()); }
		/** Returns the value of the {@code maxVertexInputBindingStride} field. */
		public int maxVertexInputBindingStride() { return VkPhysicalDeviceLimits.nmaxVertexInputBindingStride(address()); }
		/** Returns the value of the {@code maxVertexOutputComponents} field. */
		public int maxVertexOutputComponents() { return VkPhysicalDeviceLimits.nmaxVertexOutputComponents(address()); }
		/** Returns the value of the {@code maxTessellationGenerationLevel} field. */
		public int maxTessellationGenerationLevel() { return VkPhysicalDeviceLimits.nmaxTessellationGenerationLevel(address()); }
		/** Returns the value of the {@code maxTessellationPatchSize} field. */
		public int maxTessellationPatchSize() { return VkPhysicalDeviceLimits.nmaxTessellationPatchSize(address()); }
		/** Returns the value of the {@code maxTessellationControlPerVertexInputComponents} field. */
		public int maxTessellationControlPerVertexInputComponents() { return VkPhysicalDeviceLimits.nmaxTessellationControlPerVertexInputComponents(address()); }
		/** Returns the value of the {@code maxTessellationControlPerVertexOutputComponents} field. */
		public int maxTessellationControlPerVertexOutputComponents() { return VkPhysicalDeviceLimits.nmaxTessellationControlPerVertexOutputComponents(address()); }
		/** Returns the value of the {@code maxTessellationControlPerPatchOutputComponents} field. */
		public int maxTessellationControlPerPatchOutputComponents() { return VkPhysicalDeviceLimits.nmaxTessellationControlPerPatchOutputComponents(address()); }
		/** Returns the value of the {@code maxTessellationControlTotalOutputComponents} field. */
		public int maxTessellationControlTotalOutputComponents() { return VkPhysicalDeviceLimits.nmaxTessellationControlTotalOutputComponents(address()); }
		/** Returns the value of the {@code maxTessellationEvaluationInputComponents} field. */
		public int maxTessellationEvaluationInputComponents() { return VkPhysicalDeviceLimits.nmaxTessellationEvaluationInputComponents(address()); }
		/** Returns the value of the {@code maxTessellationEvaluationOutputComponents} field. */
		public int maxTessellationEvaluationOutputComponents() { return VkPhysicalDeviceLimits.nmaxTessellationEvaluationOutputComponents(address()); }
		/** Returns the value of the {@code maxGeometryShaderInvocations} field. */
		public int maxGeometryShaderInvocations() { return VkPhysicalDeviceLimits.nmaxGeometryShaderInvocations(address()); }
		/** Returns the value of the {@code maxGeometryInputComponents} field. */
		public int maxGeometryInputComponents() { return VkPhysicalDeviceLimits.nmaxGeometryInputComponents(address()); }
		/** Returns the value of the {@code maxGeometryOutputComponents} field. */
		public int maxGeometryOutputComponents() { return VkPhysicalDeviceLimits.nmaxGeometryOutputComponents(address()); }
		/** Returns the value of the {@code maxGeometryOutputVertices} field. */
		public int maxGeometryOutputVertices() { return VkPhysicalDeviceLimits.nmaxGeometryOutputVertices(address()); }
		/** Returns the value of the {@code maxGeometryTotalOutputComponents} field. */
		public int maxGeometryTotalOutputComponents() { return VkPhysicalDeviceLimits.nmaxGeometryTotalOutputComponents(address()); }
		/** Returns the value of the {@code maxFragmentInputComponents} field. */
		public int maxFragmentInputComponents() { return VkPhysicalDeviceLimits.nmaxFragmentInputComponents(address()); }
		/** Returns the value of the {@code maxFragmentOutputAttachments} field. */
		public int maxFragmentOutputAttachments() { return VkPhysicalDeviceLimits.nmaxFragmentOutputAttachments(address()); }
		/** Returns the value of the {@code maxFragmentDualSrcAttachments} field. */
		public int maxFragmentDualSrcAttachments() { return VkPhysicalDeviceLimits.nmaxFragmentDualSrcAttachments(address()); }
		/** Returns the value of the {@code maxFragmentCombinedOutputResources} field. */
		public int maxFragmentCombinedOutputResources() { return VkPhysicalDeviceLimits.nmaxFragmentCombinedOutputResources(address()); }
		/** Returns the value of the {@code maxComputeSharedMemorySize} field. */
		public int maxComputeSharedMemorySize() { return VkPhysicalDeviceLimits.nmaxComputeSharedMemorySize(address()); }
		/** Returns a {@link IntBuffer} view of the {@code maxComputeWorkGroupCount} field. */
		public IntBuffer maxComputeWorkGroupCount() { return VkPhysicalDeviceLimits.nmaxComputeWorkGroupCount(address()); }
		/** Returns the value at the specified index of the {@code maxComputeWorkGroupCount} field. */
		public int maxComputeWorkGroupCount(int index) { return VkPhysicalDeviceLimits.nmaxComputeWorkGroupCount(address(), index); }
		/** Returns the value of the {@code maxComputeWorkGroupInvocations} field. */
		public int maxComputeWorkGroupInvocations() { return VkPhysicalDeviceLimits.nmaxComputeWorkGroupInvocations(address()); }
		/** Returns a {@link IntBuffer} view of the {@code maxComputeWorkGroupSize} field. */
		public IntBuffer maxComputeWorkGroupSize() { return VkPhysicalDeviceLimits.nmaxComputeWorkGroupSize(address()); }
		/** Returns the value at the specified index of the {@code maxComputeWorkGroupSize} field. */
		public int maxComputeWorkGroupSize(int index) { return VkPhysicalDeviceLimits.nmaxComputeWorkGroupSize(address(), index); }
		/** Returns the value of the {@code subPixelPrecisionBits} field. */
		public int subPixelPrecisionBits() { return VkPhysicalDeviceLimits.nsubPixelPrecisionBits(address()); }
		/** Returns the value of the {@code subTexelPrecisionBits} field. */
		public int subTexelPrecisionBits() { return VkPhysicalDeviceLimits.nsubTexelPrecisionBits(address()); }
		/** Returns the value of the {@code mipmapPrecisionBits} field. */
		public int mipmapPrecisionBits() { return VkPhysicalDeviceLimits.nmipmapPrecisionBits(address()); }
		/** Returns the value of the {@code maxDrawIndexedIndexValue} field. */
		public int maxDrawIndexedIndexValue() { return VkPhysicalDeviceLimits.nmaxDrawIndexedIndexValue(address()); }
		/** Returns the value of the {@code maxDrawIndirectCount} field. */
		public int maxDrawIndirectCount() { return VkPhysicalDeviceLimits.nmaxDrawIndirectCount(address()); }
		/** Returns the value of the {@code maxSamplerLodBias} field. */
		public float maxSamplerLodBias() { return VkPhysicalDeviceLimits.nmaxSamplerLodBias(address()); }
		/** Returns the value of the {@code maxSamplerAnisotropy} field. */
		public float maxSamplerAnisotropy() { return VkPhysicalDeviceLimits.nmaxSamplerAnisotropy(address()); }
		/** Returns the value of the {@code maxViewports} field. */
		public int maxViewports() { return VkPhysicalDeviceLimits.nmaxViewports(address()); }
		/** Returns a {@link IntBuffer} view of the {@code maxViewportDimensions} field. */
		public IntBuffer maxViewportDimensions() { return VkPhysicalDeviceLimits.nmaxViewportDimensions(address()); }
		/** Returns the value at the specified index of the {@code maxViewportDimensions} field. */
		public int maxViewportDimensions(int index) { return VkPhysicalDeviceLimits.nmaxViewportDimensions(address(), index); }
		/** Returns a {@link FloatBuffer} view of the {@code viewportBoundsRange} field. */
		public FloatBuffer viewportBoundsRange() { return VkPhysicalDeviceLimits.nviewportBoundsRange(address()); }
		/** Returns the value at the specified index of the {@code viewportBoundsRange} field. */
		public float viewportBoundsRange(int index) { return VkPhysicalDeviceLimits.nviewportBoundsRange(address(), index); }
		/** Returns the value of the {@code viewportSubPixelBits} field. */
		public int viewportSubPixelBits() { return VkPhysicalDeviceLimits.nviewportSubPixelBits(address()); }
		/** Returns the value of the {@code minMemoryMapAlignment} field. */
		public long minMemoryMapAlignment() { return VkPhysicalDeviceLimits.nminMemoryMapAlignment(address()); }
		/** Returns the value of the {@code minTexelBufferOffsetAlignment} field. */
		public long minTexelBufferOffsetAlignment() { return VkPhysicalDeviceLimits.nminTexelBufferOffsetAlignment(address()); }
		/** Returns the value of the {@code minUniformBufferOffsetAlignment} field. */
		public long minUniformBufferOffsetAlignment() { return VkPhysicalDeviceLimits.nminUniformBufferOffsetAlignment(address()); }
		/** Returns the value of the {@code minStorageBufferOffsetAlignment} field. */
		public long minStorageBufferOffsetAlignment() { return VkPhysicalDeviceLimits.nminStorageBufferOffsetAlignment(address()); }
		/** Returns the value of the {@code minTexelOffset} field. */
		public int minTexelOffset() { return VkPhysicalDeviceLimits.nminTexelOffset(address()); }
		/** Returns the value of the {@code maxTexelOffset} field. */
		public int maxTexelOffset() { return VkPhysicalDeviceLimits.nmaxTexelOffset(address()); }
		/** Returns the value of the {@code minTexelGatherOffset} field. */
		public int minTexelGatherOffset() { return VkPhysicalDeviceLimits.nminTexelGatherOffset(address()); }
		/** Returns the value of the {@code maxTexelGatherOffset} field. */
		public int maxTexelGatherOffset() { return VkPhysicalDeviceLimits.nmaxTexelGatherOffset(address()); }
		/** Returns the value of the {@code minInterpolationOffset} field. */
		public float minInterpolationOffset() { return VkPhysicalDeviceLimits.nminInterpolationOffset(address()); }
		/** Returns the value of the {@code maxInterpolationOffset} field. */
		public float maxInterpolationOffset() { return VkPhysicalDeviceLimits.nmaxInterpolationOffset(address()); }
		/** Returns the value of the {@code subPixelInterpolationOffsetBits} field. */
		public int subPixelInterpolationOffsetBits() { return VkPhysicalDeviceLimits.nsubPixelInterpolationOffsetBits(address()); }
		/** Returns the value of the {@code maxFramebufferWidth} field. */
		public int maxFramebufferWidth() { return VkPhysicalDeviceLimits.nmaxFramebufferWidth(address()); }
		/** Returns the value of the {@code maxFramebufferHeight} field. */
		public int maxFramebufferHeight() { return VkPhysicalDeviceLimits.nmaxFramebufferHeight(address()); }
		/** Returns the value of the {@code maxFramebufferLayers} field. */
		public int maxFramebufferLayers() { return VkPhysicalDeviceLimits.nmaxFramebufferLayers(address()); }
		/** Returns the value of the {@code framebufferColorSampleCounts} field. */
		public int framebufferColorSampleCounts() { return VkPhysicalDeviceLimits.nframebufferColorSampleCounts(address()); }
		/** Returns the value of the {@code framebufferDepthSampleCounts} field. */
		public int framebufferDepthSampleCounts() { return VkPhysicalDeviceLimits.nframebufferDepthSampleCounts(address()); }
		/** Returns the value of the {@code framebufferStencilSampleCounts} field. */
		public int framebufferStencilSampleCounts() { return VkPhysicalDeviceLimits.nframebufferStencilSampleCounts(address()); }
		/** Returns the value of the {@code framebufferNoAttachmentsSampleCounts} field. */
		public int framebufferNoAttachmentsSampleCounts() { return VkPhysicalDeviceLimits.nframebufferNoAttachmentsSampleCounts(address()); }
		/** Returns the value of the {@code maxColorAttachments} field. */
		public int maxColorAttachments() { return VkPhysicalDeviceLimits.nmaxColorAttachments(address()); }
		/** Returns the value of the {@code sampledImageColorSampleCounts} field. */
		public int sampledImageColorSampleCounts() { return VkPhysicalDeviceLimits.nsampledImageColorSampleCounts(address()); }
		/** Returns the value of the {@code sampledImageIntegerSampleCounts} field. */
		public int sampledImageIntegerSampleCounts() { return VkPhysicalDeviceLimits.nsampledImageIntegerSampleCounts(address()); }
		/** Returns the value of the {@code sampledImageDepthSampleCounts} field. */
		public int sampledImageDepthSampleCounts() { return VkPhysicalDeviceLimits.nsampledImageDepthSampleCounts(address()); }
		/** Returns the value of the {@code sampledImageStencilSampleCounts} field. */
		public int sampledImageStencilSampleCounts() { return VkPhysicalDeviceLimits.nsampledImageStencilSampleCounts(address()); }
		/** Returns the value of the {@code storageImageSampleCounts} field. */
		public int storageImageSampleCounts() { return VkPhysicalDeviceLimits.nstorageImageSampleCounts(address()); }
		/** Returns the value of the {@code maxSampleMaskWords} field. */
		public int maxSampleMaskWords() { return VkPhysicalDeviceLimits.nmaxSampleMaskWords(address()); }
		/** Returns the value of the {@code timestampComputeAndGraphics} field. */
		public boolean timestampComputeAndGraphics() { return VkPhysicalDeviceLimits.ntimestampComputeAndGraphics(address()) != 0; }
		/** Returns the value of the {@code timestampPeriod} field. */
		public float timestampPeriod() { return VkPhysicalDeviceLimits.ntimestampPeriod(address()); }
		/** Returns the value of the {@code maxClipDistances} field. */
		public int maxClipDistances() { return VkPhysicalDeviceLimits.nmaxClipDistances(address()); }
		/** Returns the value of the {@code maxCullDistances} field. */
		public int maxCullDistances() { return VkPhysicalDeviceLimits.nmaxCullDistances(address()); }
		/** Returns the value of the {@code maxCombinedClipAndCullDistances} field. */
		public int maxCombinedClipAndCullDistances() { return VkPhysicalDeviceLimits.nmaxCombinedClipAndCullDistances(address()); }
		/** Returns the value of the {@code discreteQueuePriorities} field. */
		public int discreteQueuePriorities() { return VkPhysicalDeviceLimits.ndiscreteQueuePriorities(address()); }
		/** Returns a {@link FloatBuffer} view of the {@code pointSizeRange} field. */
		public FloatBuffer pointSizeRange() { return VkPhysicalDeviceLimits.npointSizeRange(address()); }
		/** Returns the value at the specified index of the {@code pointSizeRange} field. */
		public float pointSizeRange(int index) { return VkPhysicalDeviceLimits.npointSizeRange(address(), index); }
		/** Returns a {@link FloatBuffer} view of the {@code lineWidthRange} field. */
		public FloatBuffer lineWidthRange() { return VkPhysicalDeviceLimits.nlineWidthRange(address()); }
		/** Returns the value at the specified index of the {@code lineWidthRange} field. */
		public float lineWidthRange(int index) { return VkPhysicalDeviceLimits.nlineWidthRange(address(), index); }
		/** Returns the value of the {@code pointSizeGranularity} field. */
		public float pointSizeGranularity() { return VkPhysicalDeviceLimits.npointSizeGranularity(address()); }
		/** Returns the value of the {@code lineWidthGranularity} field. */
		public float lineWidthGranularity() { return VkPhysicalDeviceLimits.nlineWidthGranularity(address()); }
		/** Returns the value of the {@code strictLines} field. */
		public boolean strictLines() { return VkPhysicalDeviceLimits.nstrictLines(address()) != 0; }
		/** Returns the value of the {@code standardSampleLocations} field. */
		public boolean standardSampleLocations() { return VkPhysicalDeviceLimits.nstandardSampleLocations(address()) != 0; }
		/** Returns the value of the {@code optimalBufferCopyOffsetAlignment} field. */
		public long optimalBufferCopyOffsetAlignment() { return VkPhysicalDeviceLimits.noptimalBufferCopyOffsetAlignment(address()); }
		/** Returns the value of the {@code optimalBufferCopyRowPitchAlignment} field. */
		public long optimalBufferCopyRowPitchAlignment() { return VkPhysicalDeviceLimits.noptimalBufferCopyRowPitchAlignment(address()); }
		/** Returns the value of the {@code nonCoherentAtomSize} field. */
		public long nonCoherentAtomSize() { return VkPhysicalDeviceLimits.nnonCoherentAtomSize(address()); }

	}

}